#!/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

#

import cStringIO

import codecs

import datetime

import errno

import logging

import os

import os.path

import shutil

import six

import stat

import sys

import tempfile

import zlib

from six.moves.urllib.parse import unquote

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.digest as digest

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.pkgsubprocess as subprocess

import pkg.version

from pkg.pkggzip import PkgGzipFile

CURRENT_REPO_VERSION = 4

REPO_QUARANTINE_DIR = "pkg5-quarantine"

REPO_VERIFY_BADHASH = 0

REPO_VERIFY_BADMANIFEST = 1

REPO_VERIFY_BADGZIP = 2

REPO_VERIFY_NOFILE = 3

REPO_VERIFY_PERM = 4

REPO_VERIFY_MFPERM = 5

REPO_VERIFY_BADSIG = 6

REPO_VERIFY_WARN_OPENPERMS = 7

REPO_VERIFY_DEPENDERROR = 8

REPO_VERIFY_UNKNOWN = 99

REPO_FIX_ITEM = 0

REPO_FIX_FAILED = 1

VERIFY_DEPENDENCY = "dependency"

verify_default_checks = frozenset([

      VERIFY_DEPENDENCY,

])

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 __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 '{0}'.").format(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: '{0}'.").format(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 '{0}' does not contain a valid package "

                    "repository.").format(self.data)

class RepositoryInvalidFMRIError(RepositoryError):

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

class RepositoryInvalidIgnoreDepFMRIError(RepositoryError):

        """Used to indicate an invalid FMRI in the ignored dependency

        file."""

        def __init__(self, filename, fmri):

                Exception.__init__(self)

                self.filename = filename

                self.fmri = fmri

        def __str__(self):

                return _("The FMRI in ignored-dependency file: {fn} is "

                    "invalid.\n'{fmri}'.").format(fn=self.filename,

                    fmri=self.fmri)

class RepositoryInvalidIgnoreDepEntryError(RepositoryError):

        """Used to indicate an invalid entry in the ignored dependency

        file."""

        def __init__(self, filename, entry):

                Exception.__init__(self)

                self.filename = filename

                self.entry = entry

        def __str__(self):

                return _("The entry in ignored-dependency file: {fn} is "

                    "invalid.\n'{entry}'.").format(fn=self.filename,

                    entry=self.entry)

class RepositoryIgnoreDepEntryAttrError(RepositoryError):

        """Used to indicate an unknown attribute for an ignored dep entry."""

        def __init__(self, etype, entry=None, attrs=None):

                RepositoryError.__init__(self)

                self.etype = etype

                self.entry = entry

                self.attrs = attrs

        def __str__(self):

                if self.etype == "missing":

                        return _("Missing attribute(s) in ignored-"

                            "dependency entry: '{entry}'.\n{attrs}.").format(

                            entry=self.entry,

                            attrs=", ".join(self.attrs))

                elif self.etype == "unknown":

                        return _("Unknown attribute(s) found in ignored-"

                            "dependency entry: '{entry}'.\n{attrs}.").format(

                            entry=self.entry, attrs=", ".join(self.attrs))

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 "

                    "'{0}'.").format(self.data)

class RepositoryInvalidTransactionIDError(RepositoryError):

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

        def __str__(self):

                return _("No transaction matching '{0}' could be found.").format(

                    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} on {host}.").format(

                            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: '{0}'.").format(

                    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 '{0}'.").format(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.").format(

                            self.data)

                return _("The specified search token '{0}' is invalid.").format(

                    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 '{0}' already exists.").format(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 '{0}' could be found.").format(

                    self.data)

class RepositoryVersionError(RepositoryError):

        """Raised when the repository specified uses a format greater than the

        current format (version).

        """

        def __init__(self, location, version, current_version):

                RepositoryError.__init__(self)

                self.location = location

                self.version = version

                self.current_version = current_version

        def __str__(self):

                return("The repository at '{location}' is version "

                    "'{version}'; only versions up to {current_version} are"

                    " supported.").format(**self.__dict__)

class RepositoryInvalidVersionError(RepositoryError):

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

        (version).

        """

        def __init__(self, location, version, supported):

                RepositoryError.__init__(self)

                self.location = location

                self.version = version

                self.supported = supported

        def __str__(self):

                return("The repository at '{location}' is version "

                    "'{version}'; only version {supported} repositories are"

                    " supported.").format(

                    **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 RepositoryQuarantinedPathExistsError(RepositoryError):

        """Raised when the repository is unable to quarantine a file because

        a file of that name is already in quarantine.

        """

        def __str__(self):

                return _("Quarantined path already exists.")

class RepositorySigNoTrustAnchorDirError(RepositoryError):

        """Raised when the repository trust anchor directory could not be found

        while performing repository verification."""

        def __str__(self):

                return _("Unable to find trust anchor directory {0}").format(

                    self.data)

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, allow_invalid=False, 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(allow_invalid=allow_invalid)

                finally:

                        self.__unlock_rstore()

        def __set_read_only(self, value):

                old_ro = self.__read_only

                self.__read_only = value

                if self.__catalog:

                        self.__catalog.read_only = value

                if self.cache_store:

                        self.cache_store.readonly = value

                if old_ro and not self.__read_only:

                        self.__lock_rstore(blocking=True)

                        try:

                                self.__init_state()

                        finally:

                                self.__unlock_rstore()

        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 as 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."""