Example #1
0
    def install_dependency(self, dependencyName, version, url, installDirectoryRelPath):
        savePath = utility.download_file(url, self.download_directory)
        utility.clear_directory_contents(self.extraction_directory)

        utility.extract_file(savePath, self.extraction_directory)
        os.remove(savePath)

        if self.installedDependencies.is_installed(dependencyName):
            self.remove_dependency(dependencyName)

        # not sure wether to add this or not (can cause serious impact)
        #if os.path.exists(installDirectory):
        #    utility.log("installation directory {i} for dependency {d} already exist, overwriting it...".format(i=installDirectory,d=dependencyName))
        #    shutil.rmtree(installDirectory)

        installDirectory = utility.joinPaths(self.dependencies_directory, installDirectoryRelPath)        
        utility.ensure_directory(installDirectory)

        # if the archive top level contains only one directory,copy its contents(not the directory itself)
        tempDirContents = [name for name in os.listdir(self.extraction_directory)]
        if len(tempDirContents) == 1 and os.path.isdir(utility.joinPaths(self.extraction_directory, tempDirContents[0])):
            dirPath = utility.joinPaths(self.extraction_directory, tempDirContents[0])
            utility.move_directory_contents(dirPath, installDirectory)
            os.rmdir(dirPath)
        else:
            utility.move_directory_contents(self.extraction_directory, installDirectory)

        self.installedDependencies.add_dependency(dependencyName, version, installDirectoryRelPath)
        return True
Example #2
0
def sync_dependencies(requiredDeps, installedDependencies, registryClient, repositoryClient, dependencyManager, flags):
    """synchronizing installed dependencies with requiredDeps, include installing,updating,downgrading and removing dependencies, in accordance to flags,
    Args:
        requiredDeps: array containing required dependencies for the project, in the format [{depName:version},{depName2,version}]
        installedDependencies: currently installed dependencies
        registryClient: client used for requesting a package details from the registry
        repositoryClient: client used for checking for a package repository url
        DependencyManager: responsible for dependency installation (or remove)
        flags: operations to be performed (can be update, install, downgrade, remove or any combintation of them)
    """

    utility.log("synchronizing dependencies")
    utility.ensure_directory(DEPSINSTALL_DIR_PATH)
    required_dependencies_names = requiredDeps.get_dependencies_names()
    for depName in required_dependencies_names:
        utility.log("Processing {d}".format(d=depName), 1)

        # get current installed version (or set version to 0.0 for new dependencies)
        if installedDependencies.is_installed(depName):
            installedVersion = installedDependencies.get_installed_version(depName)
        else:
            installedVersion = str(StrictVersion('0.0'))

        # get and normalize required version
        requiredVersion = requiredDeps.get_dependency_version(depName)
        requiredVersion = str(StrictVersion(requiredVersion))

        if StrictVersion(requiredVersion) == StrictVersion(installedVersion):
            utility.log("version {v} already installed".format(v=installedVersion))
        elif StrictVersion(requiredVersion) < StrictVersion(installedVersion):
            if flags.downgrade:
                if install_dependency(depName, requiredVersion, dependencyManager, registryClient, repositoryClient):
                    utility.log("{p} version {v} installed successfuly".format(p=depName, v=requiredVersion))
                else:
                    utility.log("{p} installation failed".format(p=depName))
            else:
                utility.log("Required version {v1} < Installed version {v2}, No action taken (downgrade flag is not set)".format(v1=requiredVersion, v2=installedVersion))
        else:
            if (flags.update and StrictVersion(installedVersion) > StrictVersion('0.0')) or (flags.install and StrictVersion(installedVersion) == StrictVersion('0.0')):
                if install_dependency(depName, requiredVersion, dependencyManager, registryClient, repositoryClient):
                    utility.log("{p} version {v} installed successfuly".format(p=depName, v=requiredVersion))
                else:
                    utility.log("{p} installation failed".format(p=depName))
            else:
                utility.log("Required version {v1} > Installed version {v2}, No action taken (update flag is not set)".format(v1=requiredVersion, v2=installedVersion))
        # unident log messages
        utility.log("", -1)

    dependenciesToRemove = [item for item, version in installedDependencies.get_dependencies_list().items() if item not in required_dependencies_names]
    if dependenciesToRemove:
        utility.log("Installed dependencies that are not needed anymore : " + ",".join(dependenciesToRemove))
        if not flags.remove:
            utility.log("ommiting uneeded dependencies (remove flag is not set)")
        else:
            for dependencyName in dependenciesToRemove:
                utility.log("removing {d}".format(d=dependencyName))
                dependencyManager.remove_dependency(dependencyName)

    generate_environment(installedDependencies.get_dependencies_list(), registryClient, os.path.basename(DEPSINSTALL_DIR_PATH), GENERATED_ENVIRONMENT_PATH)
    utility.log("synchronization operation finished")
Example #3
0
    def __init__(self):
        utility.ensure_directory(SETTINGS_DIR_PATH)
        utility.ensure_file_directory(SETTINGS_FILE_PATH)

        settings = ConfigParser.RawConfigParser()
        if os.path.exists(SETTINGS_FILE_PATH):
            settings.read(SETTINGS_FILE_PATH)
        self.settings = settings
        if not self.settings.has_section(GENERAL_SECTION):
            self.settings.add_section(GENERAL_SECTION)
Example #4
0
    def __init__(self, installed_dependencies, base_directory):
        assert (isinstance(installed_dependencies, InstalledDependencies))
        assert (base_directory and os.path.isdir(base_directory))

        self.dependencies_directory = base_directory
        self.download_directory = utility.joinPaths(base_directory, TMPDOWNLOAD_DIR_NAME)
        self.extraction_directory = utility.joinPaths(self.download_directory, TMPEXTRACTION_DIR_NAME)

        utility.remove_file_or_dir(self.extraction_directory)
        utility.remove_file_or_dir(self.download_directory)
        utility.ensure_directory(self.download_directory)
        utility.ensure_directory(self.extraction_directory)

        self.installedDependencies = installed_dependencies
Example #5
0
def cmd_sync(args):
    """cmd_sync validate and prepare synchronization operation environment"""
    flags = Flags(install=not args.without_install,
                  update=not args.without_update,
                  downgrade=not args.without_downgrade,
                  remove=not args.without_remove)

    utility.ensure_directory(DEPSINSTALL_DIR_PATH)

    # load currently installed dependencies
    installedDeps = InstalledDependencies(load_installed_deps_file())
    # make sure all dependencies are installed
    check_integrity(installedDeps, DEPSINSTALL_DIR_PATH)
    
    dependencyManager = DependencyManager(installedDeps, DEPSINSTALL_DIR_PATH)

    registryClient = get_registry_client()
    if not registryClient:
        print "registry server is not set, please set it before running ppm"
        return

    settings = Settings()
    if settings.get_current_project():
        project_name = settings.get_current_project()
        try:
            jsonData = registryClient.get_project_details(project_name)
        except Exception as e:
            print "Error occured while retrieving project {p} details from registry server: {e}".format(p=project_name, e=str(e))
            return
    elif os.path.exists(REQDEPS_FILE_PATH):
        try:
            jsonData = utility.load_json_file(REQDEPS_FILE_PATH)
        except Exception as e:
            print "Error occured while reading {f}: {e}".format(f=os.path.basename(REQDEPS_FILE_PATH), e=str(e))
            return            
    else:
        print "unable to fetch dependencies, you have to set a project or create a {d} file".format(d=os.path.basename(REQDEPS_FILE_PATH))
        return

    requiredDeps = RequiredDependencies(jsonData.get('devdependencies',{}))
    
    repositoryClient = get_repository_client()

    # synchronizing dependencies
    sync_dependencies(requiredDeps, installedDeps, registryClient, repositoryClient, dependencyManager, flags)

    # save newly installed packages as current dependencies
    save_installed_deps(installedDeps.get_data())
Example #6
0
def cmd_download(args):
    """ downloading one or more packages without monitoring them"""
    downloadDirectory = utility.joinPaths(os.getcwd(), args.directory)
    packages = [('@' in p and p.split('@')) or [p,"latest"] for p in args.packages]
    utility.ensure_directory(downloadDirectory)

    registryClient = get_registry_client()
    if not registryClient:
        raise Exception("registry server is not set, please set it using set-registry-server command")
    
    repositoryClient = get_repository_client()

    for name, version in packages:
        try:
            package_handler = registryClient.get_package_details(name)
        except Exception as e:
            utility.log(str(e))
            continue

        if version == 'latest':
            version = get_latest_version(package_handler.get_package_versions())
            if version == '0.0':
                utility.log("Package {p} is not in the ppm registry".format(p=name))
                continue
        else:
            version = str(StrictVersion(version))
            if not package_handler.check_version_existence(version):
                utility.log("Package {p} is not in the ppm registry".format(p=name))
                continue

        url = package_handler.get_package_url(version)
        # check for repository url
        if repositoryClient:
            repository_url = repositoryClient.get_package_repository_url(url)
            if repository_url:
                url = repository_url
        utility.download_file(url, downloadDirectory)