#!/usr/bin/python2.4

#

# CDDL HEADER START

#

# The contents of this file are subject to the terms of the

# Common Development and Distribution License (the "License").

# You may not use this file except in compliance with the License.

#

# You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE

# or http://www.opensolaris.org/os/licensing.

# See the License for the specific language governing permissions

# and limitations under the License.

#

# When distributing Covered Code, include this CDDL HEADER in each

# file and include the License file at usr/src/OPENSOLARIS.LICENSE.

# If applicable, add the following below this CDDL HEADER, with the

# fields enclosed by brackets "[]" replaced with your own identifying

# information: Portions Copyright [yyyy] [name of copyright owner]

#

# CDDL HEADER END

#

#

# Copyright 2009 Sun Microsystems, Inc.  All rights reserved.

# Use is subject to license terms.

#

#

# NOTE: Any changes to this file are considered a change in client api

# interfaces and must be fully documented in doc/client_api_versions.txt

# if they are visible changes to the public interfaces provided.

#

# This also means that changes to the interfaces here must be reflected in

# the client version number and compatible_versions specifier found in

# modules/client/api.py:__init__.

#

import calendar

import copy

import datetime as dt

import errno

import os

import pkg.client.api_errors as api_errors

import pkg.misc as misc

import pkg.portable as portable

import pkg.Uuid25

import shutil

import time

import urlparse

# The "core" type indicates that a repository contains all of the dependencies

# declared by packages in the repository.  It is primarily used for operating

# system repositories.

REPO_CTYPE_CORE = "core"

# The "supplemental" type indicates that a repository contains packages that

# rely on or are intended to be used with packages located in another

# repository.

REPO_CTYPE_SUPPLEMENTAL = "supplemental"

# Mapping of constant values to names (in the event these ever get changed to

# numeric values or it is decided they need "prettier" or different labels).

REPO_COLLECTION_TYPES = {

    REPO_CTYPE_CORE: "core",

    REPO_CTYPE_SUPPLEMENTAL: "supplemental",

}

# Supported Protocol Schemes

SUPPORTED_SCHEMES = set(("http", "https"))

# SSL Protocol Schemes

SSL_SCHEMES = set(("https",))

# Supported RepositoryURI sorting policies.

URI_SORT_PRIORITY = "priority"

# Sort policy mapping.

URI_SORT_POLICIES = {

    URI_SORT_PRIORITY: lambda obj: (obj.priority, obj.uri),

}

class RepositoryURI(object):

        """Class representing a repository URI and any transport-related

        information."""

        # These properties are declared here so that they show up in the pydoc

        # documentation as private, and for clarity in the property declarations

        # found near the end of the class definition.

        __priority = None

        __ssl_cert = None

        __ssl_key = None

        __trailing_slash = None

        __uri = None

        # Used to store the id of the original object this one was copied

        # from during __copy__.

        _source_object_id = None

        def __init__(self, uri, priority=None, ssl_cert=None, ssl_key=None,

            trailing_slash=True):

                # Must set first.

                self.__trailing_slash = trailing_slash

                # Note that the properties set here are intentionally lacking

                # the '__' prefix which means assignment will occur using the

                # get/set methods declared for the property near the end of

                # the class definition.

                self.priority = priority

                self.uri = uri

                self.ssl_cert = ssl_cert

                self.ssl_key = ssl_key

        def __copy__(self):

                uri = RepositoryURI(self.__uri, priority=self.__priority,

                    ssl_cert=self.__ssl_cert, ssl_key=self.__ssl_key,

                    trailing_slash=self.__trailing_slash)

                uri._source_object_id = id(self)

                return uri

        def __eq__(self, other):

                if isinstance(other, RepositoryURI):

                        return self.uri == other.uri

                if isinstance(other, str):

                        return self.uri == other

                return False

        def __ne__(self, other):

                if isinstance(other, RepositoryURI):

                        return self.uri != other.uri

                if isinstance(other, str):

                        return self.uri != other

                return True

        def __set_priority(self, value):

                if value is not None:

                        try:

                                value = int(value)

                        except (TypeError, ValueError):

                                raise api_errors.BadRepositoryURIPriority(value)

                self.__priority = value

        def __set_ssl_cert(self, filename):

                if self.scheme not in SSL_SCHEMES and filename:

                        raise api_errors.UnsupportedRepositoryURIAttribute(

                            "ssl_cert", scheme=self.scheme)

                if filename:

                        if not isinstance(filename, basestring):

                                raise api_errors.BadRepositoryAttributeValue(

                                    "ssl_cert", value=filename)

                        filename = os.path.abspath(filename)

                        if not os.path.exists(filename):

                                raise api_errors.NoSuchCertificate(filename,

                                    uri=self.uri)

                if filename == "":

                        filename = None

                # XXX attempt certificate verification here?

                self.__ssl_cert = filename

        def __set_ssl_key(self, filename):

                if self.scheme not in SSL_SCHEMES and filename:

                        raise api_errors.UnsupportedRepositoryURIAttribute(

                            "ssl_key", scheme=self.scheme)

                if filename:

                        if not isinstance(filename, basestring):

                                raise api_errors.BadRepositoryAttributeValue(

                                    "ssl_key", value=filename)

                        filename = os.path.abspath(filename)

                        if not os.path.exists(filename):

                                    uri=self.uri)

                if filename == "":

                        filename = None

                # XXX attempt key verification here?

                self.__ssl_key = filename

        def __set_trailing_slash(self, value):

                if value not in (True, False):

                        raise api_errors.BadRepositoryAttributeValue(

                            "trailing_slash", value=value)

                self.__trailing_slash = value

        def __set_uri(self, uri):

                if uri is None:

                        raise api_errors.BadRepositoryURI(uri)

                # Decompose URI to verify attributes.

                scheme, netloc, path, params, query = \

                    urlparse.urlsplit(uri, allow_fragments=0)

                # The set of currently supported protocol schemes.

                if scheme.lower() not in SUPPORTED_SCHEMES:

                        raise api_errors.UnsupportedRepositoryURI(uri)

                # XXX valid_pub_url's check isn't quite right and could prevent

                # usage of IDNs (international domain names).

                if not netloc or not misc.valid_pub_url(uri):

                        raise api_errors.BadRepositoryURI(uri)

                # Normalize URI scheme.

                uri = uri.replace(scheme, scheme.lower(), 1)

                if self.__trailing_slash:

                        uri = misc.url_affix_trailing_slash(uri)

                if scheme.lower() not in SSL_SCHEMES:

                        self.__ssl_cert = None

                        self.__ssl_key = None

                self.__uri = uri

        def __str__(self):

                return self.__uri

        ssl_cert = property(lambda self: self.__ssl_cert, __set_ssl_cert, None,

            "The absolute pathname of a PEM-encoded SSL certificate file.")

        ssl_key = property(lambda self: self.__ssl_key, __set_ssl_key, None,

            "The absolute pathname of a PEM-encoded SSL key file.")

        uri = property(lambda self: self.__uri, __set_uri, None,

            "The URI used to access a repository.")

        priority = property(lambda self: self.__priority, __set_priority, None,

            "An integer value representing the importance of this repository "

            "URI relative to others.")

        @property

        def scheme(self):

                """The URI scheme."""

                if not self.__uri:

                        return ""

                return urlparse.urlsplit(self.__uri, allow_fragments=0)[0]

        trailing_slash = property(lambda self: self.__trailing_slash,

            __set_trailing_slash, None,

            "A boolean value indicating whether any URI provided for this "

            "object should have a trailing slash appended when setting the "

            "URI property.")

class Repository(object):

        """Class representing a repository object.

        A repository object represents a location where clients can publish

        and retrieve package content and/or metadata.  It has the following

        characteristics:

                - may have one or more origins (URIs) for publication and

                  retrieval of package metadata and content.

                - may have zero or more mirrors (URIs) for retrieval of package

                  content."""

        # These properties are declared here so that they show up in the pydoc

        # documentation as private, and for clarity in the property declarations

        # found near the end of the class definition.

        __collection_type = None

        __legal_uris = []

        __mirrors = []

        __origins = []

        __refresh_seconds = None

        __registration_uri = None

        __related_uris = []

        __sort_policy = URI_SORT_PRIORITY

        # Used to store the id of the original object this one was copied

        # from during __copy__.

        _source_object_id = None

        name = None

        description = None

        registered = False

        def __init__(self, collection_type=REPO_CTYPE_CORE, description=None,

            legal_uris=None, mirrors=None, name=None, origins=None,

            refresh_seconds=None, registered=False, registration_uri=None,

            related_uris=None, sort_policy=URI_SORT_PRIORITY):

                """Initializes a repository object.

                'collection_type' is an optional constant value indicating the

                type of packages in the repository.

                'description' is an optional string value containing a

                descriptive paragraph for the repository.

                'legal_uris' should be a list of RepositoryURI objects or URI

                strings indicating where licensing, legal, and terms of service

                information for the repository can be found.

                'mirrors' is an optional list of RepositoryURI objects or URI

                strings indicating where package content can be retrieved.

                'name' is an optional, short, descriptive name for the

                repository.

                'origins' should be a list of RepositoryURI objects or URI

                strings indicating where package metadata can be retrieved.

                'refresh_seconds' is an optional integer value indicating the

                number of seconds clients should wait before refreshing cached

                repository catalog or repository metadata information.

                'registered' is an optional boolean value indicating whether

                a client has registered with the repository's publisher.

                'registration_uri' is an optional RepositoryURI object or a URI

                string indicating a location clients can use to register or

                obtain credentials needed to access the repository.

                'related_uris' is an optional list of RepositoryURI objects or a

                list of URI strings indicating the location of related

                repositories that a client may be interested in.

                'sort_policy' is an optional constant value indicating how

                legal_uris, mirrors, origins, and related_uris should be

                sorted."""

                # Note that the properties set here are intentionally lacking

                # the '__' prefix which means assignment will occur using the

                # get/set methods declared for the property near the end of

                # the class definition.

                # Must be set first so that it will apply to attributes set

                # afterwards.

                self.sort_policy = sort_policy

                self.collection_type = collection_type

                self.description = description

                self.legal_uris = legal_uris

                self.mirrors = mirrors

                self.name = name

                self.origins = origins

                self.refresh_seconds = refresh_seconds

                self.registered = registered

                self.registration_uri = registration_uri

                self.related_uris = related_uris

        def __add_uri(self, attr, uri, dup_check=None, priority=None,

            ssl_cert=None, ssl_key=None, trailing_slash=True):

                if not isinstance(uri, RepositoryURI):

                        uri = RepositoryURI(uri, priority=priority,

                            ssl_cert=ssl_cert, ssl_key=ssl_key,

                            trailing_slash=trailing_slash)

                if dup_check:

                        dup_check(uri)

                ulist = getattr(self, attr)

                ulist.append(uri)

                ulist.sort(key=URI_SORT_POLICIES[self.__sort_policy])

        def __copy__(self):

                cluris = [copy.copy(u) for u in self.legal_uris]

                cmirrors = [copy.copy(u) for u in self.mirrors]

                cruris = [copy.copy(u) for u in self.related_uris]

                corigins = [copy.copy(u) for u in self.origins]

                repo = Repository(collection_type=self.collection_type,

                    description=self.description,

                    legal_uris=cluris,

                    mirrors=cmirrors, name=self.name,

                    origins=corigins,

                    refresh_seconds=self.refresh_seconds,

                    registered=self.registered,

                    registration_uri=copy.copy(self.registration_uri),

                    related_uris=cruris)

                repo._source_object_id = id(self)

                return repo

        def __replace_uris(self, attr, value, trailing_slash=True):

                if value is None:

                        value = []

                if not isinstance(value, list):

                        raise api_errors.BadRepositoryAttributeValue(attr,

                            value=value)

                uris = []

                for u in value:

                        if not isinstance(u, RepositoryURI):

                                u = RepositoryURI(u,

                                    trailing_slash=trailing_slash)

                        elif trailing_slash:

                                u.uri = misc.url_affix_trailing_slash(u.uri)

                        uris.append(u)

                uris.sort(key=URI_SORT_POLICIES[self.__sort_policy])

                return uris

        def __set_collection_type(self, value):

                if value not in REPO_COLLECTION_TYPES:

                        raise api_errors.BadRepositoryCollectionType(value)

                self.__collection_type = value

        def __set_legal_uris(self, value):

                self.__legal_uris = self.__replace_uris("legal_uris", value,

                    trailing_slash=False)

        def __set_mirrors(self, value):

                self.__mirrors = self.__replace_uris("mirrors", value)

        def __set_origins(self, value):

                self.__origins = self.__replace_uris("origins", value)

        def __set_registration_uri(self, value):

                if value and not isinstance(value, RepositoryURI):

                        value = RepositoryURI(value, trailing_slash=False)

                self.__registration_uri = value

        def __set_related_uris(self, value):

                self.__related_uris = self.__replace_uris("related_uris",

                    value, trailing_slash=False)

        def __set_refresh_seconds(self, value):

                if value is not None:

                        try:

                                value = int(value)

                        except (TypeError, ValueError):

                                raise api_errors.BadRepositoryAttributeValue(

                                    "refresh_seconds", value=value)

                        if value < 0:

                                raise api_errors.BadRepositoryAttributeValue(

                                    "refresh_seconds", value=value)

                self.__refresh_seconds = value

        def __set_sort_policy(self, value):

                if value not in URI_SORT_POLICIES:

                        raise api_errors.BadRepositoryURISortPolicy(value)

                self.__sort_policy = value

        def add_legal_uri(self, uri, priority=None, ssl_cert=None,

            ssl_key=None):

                """Adds the specified legal URI to the repository.

                'uri' can be a RepositoryURI object or a URI string.  If

                it is a RepositoryURI object, all other parameters will be

                ignored."""

                self.__add_uri("legal_uris", uri, priority=priority,

                    ssl_cert=ssl_cert, ssl_key=ssl_key, trailing_slash=False)

        def add_mirror(self, mirror, priority=None, ssl_cert=None,

            ssl_key=None):

                """Adds the specified mirror to the repository.

                'mirror' can be a RepositoryURI object or a URI string.  If

                it is a RepositoryURI object, all other parameters will be

                ignored."""

                def dup_check(mirror):

                        if self.has_mirror(mirror):

                                raise api_errors.DuplicateRepositoryMirror(

                                    mirror)

                self.__add_uri("mirrors", mirror, dup_check=dup_check,

                    priority=priority, ssl_cert=ssl_cert, ssl_key=ssl_key)

        def add_origin(self, origin, priority=None, ssl_cert=None,

            ssl_key=None):

                """Adds the specified origin to the repository.

                'origin' can be a RepositoryURI object or a URI string.  If

                it is a RepositoryURI object, all other parameters will be

                ignored."""

                def dup_check(origin):

                        if self.has_origin(origin):

                                raise api_errors.DuplicateRepositoryOrigin(

                                    origin)

                self.__add_uri("origins", origin, dup_check=dup_check,

                    priority=priority, ssl_cert=ssl_cert, ssl_key=ssl_key)

        def add_related_uri(self, uri, priority=None, ssl_cert=None,

            ssl_key=None):

                """Adds the specified related URI to the repository.

                'uri' can be a RepositoryURI object or a URI string.  If

                it is a RepositoryURI object, all other parameters will be

                ignored."""

                self.__add_uri("related_uris", uri, priority=priority,

                    ssl_cert=ssl_cert, ssl_key=ssl_key, trailing_slash=False)

        def get_mirror(self, mirror):

                """Returns a RepositoryURI object representing the mirror

                that matches 'mirror'.

                'mirror' can be a RepositoryURI object or a URI string."""

                if not isinstance(mirror, RepositoryURI):

                        mirror = misc.url_affix_trailing_slash(mirror)

                for m in self.mirrors:

                        if mirror == m.uri:

                                return m

                raise api_errors.UnknownRepositoryMirror(mirror)

        def get_origin(self, origin):

                """Returns a RepositoryURI object representing the origin

                that matches 'origin'.

                'origin' can be a RepositoryURI object or a URI string."""

                if not isinstance(origin, RepositoryURI):

                        origin = misc.url_affix_trailing_slash(origin)

                for o in self.origins:

                        if origin == o.uri:

                                return o

                raise api_errors.UnknownRepositoryOrigin(origin)

        def has_mirror(self, mirror):

                """Returns a boolean value indicating whether a matching

                'mirror' exists for the repository.

                'mirror' can be a RepositoryURI object or a URI string."""

                if not isinstance(mirror, RepositoryURI):

                        mirror = misc.url_affix_trailing_slash(mirror)

                return mirror in self.mirrors

        def has_origin(self, origin):

                """Returns a boolean value indicating whether a matching

                'origin' exists for the repository.

                'origin' can be a RepositoryURI object or a URI string."""

                if not isinstance(origin, RepositoryURI):