#!/usr/bin/python

#

# 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 (c) 2008, 2012, Oracle and/or its affiliates. All rights reserved.

import cStringIO

import codecs

import datetime

import errno

import logging

import os

import os.path

import platform

import shutil

import stat

import sys

import tempfile

import urllib

import pkg.actions as actions

import pkg.catalog as catalog

import pkg.client.api_errors as apx

import pkg.client.progress as progress

import pkg.client.publisher as publisher

import pkg.config as cfg

import pkg.file_layout.file_manager as file_manager

import pkg.file_layout.layout as layout

import pkg.fmri as fmri

import pkg.indexer as indexer

import pkg.lockfile as lockfile

import pkg.manifest

import pkg.p5i as p5i

import pkg.portable as portable

import pkg.misc as misc

import pkg.nrlock

import pkg.search_errors as se

import pkg.query_parser as qp

import pkg.server.catalog as old_catalog

import pkg.server.query_parser as sqp

import pkg.server.transaction as trans

import pkg.version

CURRENT_REPO_VERSION = 4

from pkg.pkggzip import PkgGzipFile

class RepositoryError(Exception):

        """Base exception class for all Repository exceptions."""

        def __init__(self, *args):

                Exception.__init__(self, *args)

                if args:

                        self.data = args[0]

        def __unicode__(self):

                # To workaround python issues 6108 and 2517, this provides a

                # a standard wrapper for this class' exceptions so that they

                # have a chance of being stringified correctly.

                return str(self)

        def __str__(self):

                return str(self.data)

class RepositoryExistsError(RepositoryError):

        """Used to indicate that a repository already exists at the specified

        location.

        """

        def __str__(self):

                return _("A package repository (or a directory with content) "

                    "already exists at '%s'.") % self.data

class RepositoryFileNotFoundError(RepositoryError):

        """Used to indicate that the hash name provided for the requested file

        does not exist."""

        def __str__(self):

                return _("No file could be found for the specified "

                    "hash name: '%s'.") % self.data

class RepositoryInvalidError(RepositoryError):

        """Used to indicate that a valid repository could not be found at the

        specified location."""

        def __str__(self):

                if not self.data:

                        return _("The specified path does not contain a valid "

                            "package repository.")

                return _("The path '%s' does not contain a valid package "

                    "repository.") % self.data

class RepositoryInvalidFMRIError(RepositoryError):

        """Used to indicate that the FMRI provided is invalid."""

class RepositoryUnqualifiedFMRIError(RepositoryError):

        """Used to indicate that the FMRI provided is valid, but is missing

        publisher information."""

        def __str__(self):

                return _("This operation requires that a default publisher has "

                    "been set or that a publisher be specified in the FMRI "

                    "'%s'.") % self.data

class RepositoryInvalidTransactionIDError(RepositoryError):

        """Used to indicate that an invalid Transaction ID was supplied."""

        def __str__(self):

                return _("No transaction matching '%s' could be found.") % \

                    self.data

class RepositoryLockedError(RepositoryError):

        """Used to indicate that the repository is currently locked by another

        thread or process and cannot be modified."""

        def __init__(self, hostname=None, pid=None):

                RepositoryError.__init__(self)

                self.hostname = hostname

                self.pid = pid

        def __str__(self):

                if self.pid is not None:

                        # Even if the host is none, use this message.

                        return _("The repository cannot be modified as it is "

                            "currently in use by another process: "

                            "pid %(pid)s on %(host)s.") % {

                            "pid": self.pid, "host": self.hostname }

                return _("The repository cannot be modified as it is currently "

                    "in use by another process.")

class RepositoryManifestNotFoundError(RepositoryError):

        """Used to indicate that the requested manifest could not be found."""

        def __str__(self):

                return _("No manifest could be found for the FMRI: '%s'.") % \

                    self.data

class RepositoryMirrorError(RepositoryError):

        """Used to indicate that the requested operation could not be performed

        as the repository is in mirror mode."""

        def __str__(self):

                return _("The requested operation cannot be performed when the "

                    "repository is used in mirror mode.")

class RepositoryNoPublisherError(RepositoryError):

        """Used to indicate that the requested repository operation could not be

        completed as not default publisher has been set and one was not

        specified.

        """

        def __str__(self):

                return _("The requested operation could not be completed as a "

                    "default publisher has not been configured.")

class RepositoryNoSuchFileError(RepositoryError):

        """Used to indicate that the file provided does not exist."""

        def __str__(self):

                return _("No such file '%s'.") % self.data

class RepositoryReadOnlyError(RepositoryError):

        """Used to indicate that the requested operation could not be performed

        as the repository is currently read-only."""

        def __str__(self):

                return _("The repository is read-only and cannot be modified.")

class RepositorySearchTokenError(RepositoryError):

        """Used to indicate that the token(s) provided to search were undefined

        or invalid."""

        def __str__(self):

                if self.data is None:

                        return _("No token was provided to search.") % self.data

                return _("The specified search token '%s' is invalid.") % \

                    self.data

class RepositorySearchUnavailableError(RepositoryError):

        """Used to indicate that search is not currently available."""

        def __str__(self):

                return _("Search functionality is temporarily unavailable.")

class RepositoryDuplicatePublisher(RepositoryError):

        """Raised when the publisher specified for an operation already exists,

        and so cannot be added again.

        """

        def __str__(self):

                return _("Publisher '%s' already exists.") % self.data

class RepositoryUnknownPublisher(RepositoryError):

        """Raised when the publisher specified for an operation is unknown to

        the repository.

        """

        def __str__(self):

                if not self.data:

                        return _("No publisher was specified or no default "

                            "publisher has been configured for the repository.")

                return _("No publisher matching '%s' could be found.") % \

                    self.data

class RepositoryVersionError(RepositoryError):

        """Raised when the repository specified uses an unsupported format

        (version).

        """

        def __init__(self, location, version):

                RepositoryError.__init__(self)

                self.location = location

                self.version = version

        def __str__(self):

                return("The repository at '%(location)s' is version "

                    "'%(version)s'; only versions up to are supported.") % \

                    self.__dict__

class RepositoryUnsupportedOperationError(RepositoryError):

        """Raised when the repository is unable to support an operation,

        based upon its current configuration.

        """

        def __str__(self):

                return("Operation not supported for this configuration.")

class _RepoStore(object):

        """The _RepoStore object provides an interface for performing operations

        on a set of package data contained within a repository.  This class is

        intended only for use by the Repository class.

        """

        def __init__(self, file_layout=None, file_root=None, log_obj=None,

            mirror=False, pub=None, read_only=False, root=None,

            sort_file_max_size=indexer.SORT_FILE_MAX_SIZE, writable_root=None):

                """Prepare the repository for use."""

                self.__catalog = None

                self.__catalog_root = None

                # FileManager supports multiple layouts, but realistically, it

                # is desirable to only support one per repository format

                # version.

                self.__file_layout = file_layout

                self.__file_root = None

                self.__in_flight_trans = {}

                self.__read_only = read_only

                self.__root = None

                self.__sort_file_max_size = sort_file_max_size

                self.__tmp_root = None

                self.__writable_root = None

                self.cache_store = None

                self.catalog_version = -1

                self.manifest_root = None

                self.trans_root = None

                self.log_obj = log_obj

                self.mirror = mirror

                self.publisher = pub

                # Set before root, since it's possible to have the

                # file_root in an entirely different location.  The root

                # will govern file_root, if a value for file_root is not

                # supplied.

                if file_root:

                        self.__set_file_root(file_root)

                # Must be set before remaining roots.

                self.__set_root(root)

                # Ideally, callers would just specify overrides for the feed

                # cache root, index_root, etc.  But this must be set after all

                # of the others above.

                self.__set_writable_root(writable_root)

                self.__search_available = False

                self.__refresh_again = False

                self.__lock = pkg.nrlock.NRLock()

                if self.__tmp_root:

                        self.__lockfile = lockfile.LockFile(os.path.join(

                            self.__tmp_root, "lock"),

                            set_lockstr=lockfile.generic_lock_set_str,

                            get_lockstr=lockfile.generic_lock_get_str,

                            failure_exc=RepositoryLockedError,

                            provide_mutex=False)

                else:

                        self.__lockfile = None

                # Initialize.

                self.__lock_rstore(blocking=True)

                try:

                        self.__init_state()

                finally:

                        self.__unlock_rstore()

        def __set_read_only(self, value):

                self.__read_only = value

                if self.__catalog:

                        self.__catalog.read_only = value

        def __mkdtemp(self):

                """Create a temp directory under repository directory for

                various purposes."""

                if not self.root:

                        return

                if self.writable_root:

                        root = self.writable_root

                else:

                        root = self.root

                tempdir = os.path.normpath(os.path.join(root, "tmp"))

                misc.makedirs(tempdir)

                try:

                        return tempfile.mkdtemp(dir=tempdir)

                except EnvironmentError, e:

                        if e.errno == errno.EACCES:

                                raise apx.PermissionsException(

                                    e.filename)

                        if e.errno == errno.EROFS:

                                raise apx.ReadOnlyFileSystemException(

                                    e.filename)

                        raise

        def __add_package(self, pfmri, manifest=None):

                """Private version; caller responsible for repository

                locking."""

                if not manifest:

                        manifest = self._get_manifest(pfmri, sig=True)

                c = self.catalog

                c.add_package(pfmri, manifest=manifest)

        def __replace_package(self, pfmri, manifest=None):

                """Private version; caller responsible for repository

                locking."""

                if not manifest:

                        manifest = self._get_manifest(pfmri, sig=True)

                c = self.catalog

                c.remove_package(pfmri)

                c.add_package(pfmri, manifest=manifest)

        def __check_search(self):

                if not self.index_root:

                        return

                ind = indexer.Indexer(self.index_root,

                    self._get_manifest, self.manifest,

                    log=self.__index_log,

                    sort_file_max_size=self.__sort_file_max_size)

                cie = False

                try:

                        cie = ind.check_index_existence()

                except se.InconsistentIndexException:

                        pass

                if cie:

                        if not self.__search_available:

                                # State change to available.

                                self.__index_log("Search Available")

                                self.reset_search()

                        self.__search_available = True

                else:

                        if self.__search_available:

                                # State change to unavailable.

                                self.__index_log("Search Unavailable")

                                self.reset_search()

                        self.__search_available = False

        def __destroy_catalog(self):

                """Destroy the catalog."""

                self.__catalog = None

                if self.catalog_root and os.path.exists(self.catalog_root):

                        shutil.rmtree(self.catalog_root)

        @staticmethod

        def __fmri_from_path(pkgpath, ver):

                """Helper method that takes the full path to the package

                directory and the name of the manifest file, and returns an FMRI

                constructed from the information in those components."""

                v = pkg.version.Version(urllib.unquote(ver), None)

                f = fmri.PkgFmri(urllib.unquote(os.path.basename(pkgpath)))

                f.version = v

                return f

        def _get_manifest(self, pfmri, sig=False):

                """This function should be private; but is protected instead due

                to its usage as a callback."""

                mpath = self.manifest(pfmri)

                m = pkg.manifest.Manifest(pfmri)

                try:

                        m.set_content(pathname=mpath, signatures=sig)

                except EnvironmentError, e:

                        if e.errno == errno.ENOENT:

                                raise RepositoryManifestNotFoundError(

                                    e.filename)

                        raise

                return m

        def __index_log(self, msg):

                return self.__log(msg, "INDEX")

        def __get_transaction(self, trans_id):

                """Return the in-flight transaction with the matching trans_id.

                """

                if not self.trans_root:

                        raise RepositoryInvalidTransactionIDError(trans_id)

                try:

                        return self.__in_flight_trans[trans_id]

                except KeyError:

                        # Transaction not cached already, so load and

                        # cache if possible.

                        t = trans.Transaction()

                        try:

                                t.reopen(self, trans_id)

                        except trans.TransactionUnknownIDError:

                                raise RepositoryInvalidTransactionIDError(

                                    trans_id)

                        if not t:

                                raise RepositoryInvalidTransactionIDError(

                                    trans_id)

                        self.__in_flight_trans[trans_id] = t

                        return t

        def __discard_transaction(self, trans_id):

                """Discard any state information cached for a Transaction."""

                self.__in_flight_trans.pop(trans_id, None)

        def get_lock_status(self):

                """Returns a tuple of booleans of the form (storage_locked,

                index_locked).

                """

                storage_locked = False

                try: