Esempio n. 1
0
    def test_post2(self):
        # successful post
        createManifest(self)

        self.assertTrue(os.path.exists(os.path.join(PackageMgr.packagePath(), 'perlserver-1.0.0.unix.cronus')))
        self.assertTrue(os.path.exists(os.path.join(manifestutil.installedPkgRootPath('foo'), 'perlserver', '1.0.0.unix',
                                           'cronus', 'scripts', 'activate')))
        self.assertTrue(islink(os.path.join(manifestutil.manifestPath('foo', 'bar'), 'perlserver')))
        self.assertTrue(islink(os.path.join(manifestutil.installedPkgRootPath('foo'), 'perlserver', '1.0.0.unix', '.appdata')))
Esempio n. 2
0
    def listPackages(self, service):
        """ list installed packages in this service"""
        result = {}
        installedRoot = manifestutil.installedPkgRootPath(service)
        pkgs = [ packageDir for packageDir in os.listdir(installedRoot) ]
        pkgsVersions = []
        for pkg in pkgs:
            pkgVersions = {}
            pkgVersions['pkgName'] = os.path.basename(pkg)
            pkgVersions['pkgVersion'] = [ os.path.basename(verDir) for verDir in os.listdir(os.path.join(installedRoot, pkg)) ]
            pkgsVersions.append(pkgVersions)

        result['packages'] = pkgsVersions
        return doneResult(request, response, result = result, controller = self)
Esempio n. 3
0
    def listPackages(self, service):
        """ list installed packages in this service"""
        result = {}
        installedRoot = manifestutil.installedPkgRootPath(service)
        pkgs = [packageDir for packageDir in os.listdir(installedRoot)]
        pkgsVersions = []
        for pkg in pkgs:
            pkgVersions = {}
            pkgVersions['pkgName'] = os.path.basename(pkg)
            pkgVersions['pkgVersion'] = [
                os.path.basename(verDir)
                for verDir in os.listdir(os.path.join(installedRoot, pkg))
            ]
            pkgsVersions.append(pkgVersions)

        result['packages'] = pkgsVersions
        return doneResult(request, response, result=result, controller=self)
Esempio n. 4
0
    def doRun(self):
        """ Main body of the thread

        Progress Info:
        Look at the list of packages this manifest has and figure out the progress of this manifest
        Progress 1 = manifest directory created
        Progress 2-80 = all packages downloaded
        Progress 81-99 = all packages untarred
        Progress 100 = all links done
        """
        try:
            if self.__service != 'agent':
                utils.checkDiskFull()

            installedPkgPath = manifestutil.installedPkgRootPath(self.__service)

            # figure out which of the packages are already there
            remainingPackages = {}
            pkgDict = PackageUtil.parseUri(self.__package)
            pkgPath = os.path.join(installedPkgPath, pkgDict['packageName'], pkgDict['packageVersion'])
            remainingPackages[self.__package] = pkgDict

            if (not os.path.exists(pkgPath)):
                # now make sure all the packages are downloaded
                try:
                    self._downloadPackages([self.__package])
                except AgentException as exc:
                    # check if it is download error, then modify exception appropriately
                    if exc.getCode() == Errors.DC_FAILED_DOWNLOAD:
                        exc = AgentException(Errors.MANIFEST_PACKAGE_DOWNLOAD_FAILED,
                                            'Manifest (%s/%s) failed downloading package - %s'
                                            % (self.__service, self.__module, exc.getMsg()))
                    raise exc

                LOG.info('Completed download packages for (%s/%s)' % (self.__service, self.__module))

                # now untar the packages
                self._untarPackages(remainingPackages, self.__service, ServiceController.installedPkgPath(self.__service))
                LOG.info('Completed untar all packages for (%s/%s)' % (self.__service, self.__module))

            # now create the links
            for pkgDict in remainingPackages.itervalues():
                pkgPath = os.path.join(installedPkgPath, pkgDict['packageName'], pkgDict['packageVersion'])
                modulePath = os.path.join(manifestutil.moduleRootPath(self.__service), self.__module)
                    
                # validate target folder does exist
                if not os.path.exists(pkgPath):
                    raise AgentException(Errors.PACKAGE_PATH_ERROR, 'invalid untarred package at %s' % pkgPath)
                    
                # remove existing module 
                isExistingModule = os.path.exists(modulePath) 
                if isExistingModule:
                    execThread = self._getBuiltThread('deactivate')
                    if execThread:
                        super(ModuleCreate, self)._runExeThread(execThread)
                    rmlink(modulePath)
                    
                execThread = self._getBuiltThread('activate')
                if execThread:
                    super(ModuleCreate, self)._runExeThread(execThread)
                symlink(pkgPath, modulePath)
                
                # load controllers from package
                manifestutil.processModule(self.__service, self.__module, not isExistingModule)
                

            LOG.info('Completed create module for (%s/%s)' % (self.__service, self.__module))
            self._updateStatus(progress = 100)

        except AgentException as exc:
            LOG.info(exc.getMsg())
            self._updateStatus(httpStatus = 500, error = exc.getCode(), errorMsg = exc.getMsg())
            
        except Exception as exc:
            errCode = Errors.UNKNOWN_ERROR
            msg = 'Unknown error for (%s/%s) - %s - %s' % (self.__service, self.__module,
                                                           str(exc), traceback.format_exc(2))
            LOG.info(msg)
            self._updateStatus(httpStatus = 500, error = errCode, errorMsg = msg)
Esempio n. 5
0
    def doRun(self):
        """ Main body of the thread

        Progress Info:
        Look at the list of packages this manifest has and figure out the progress of this manifest
        Progress 1 = manifest directory created
        Progress 2-80 = all packages downloaded
        Progress 81-99 = all packages untarred
        Progress 100 = all links done
        """
        try:
            if self.__service != 'agent':
                utils.checkDiskFull()

            installedPkgPath = manifestutil.installedPkgRootPath(
                self.__service)

            # figure out which of the packages are already there
            remainingPackages = {}
            pkgDict = PackageUtil.parseUri(self.__package)
            pkgPath = os.path.join(installedPkgPath, pkgDict['packageName'],
                                   pkgDict['packageVersion'])
            remainingPackages[self.__package] = pkgDict

            if (not os.path.exists(pkgPath)):
                # now make sure all the packages are downloaded
                try:
                    self._downloadPackages([self.__package])
                except AgentException as exc:
                    # check if it is download error, then modify exception appropriately
                    if exc.getCode() == Errors.DC_FAILED_DOWNLOAD:
                        exc = AgentException(
                            Errors.MANIFEST_PACKAGE_DOWNLOAD_FAILED,
                            'Manifest (%s/%s) failed downloading package - %s'
                            % (self.__service, self.__module, exc.getMsg()))
                    raise exc

                LOG.info('Completed download packages for (%s/%s)' %
                         (self.__service, self.__module))

                # now untar the packages
                self._untarPackages(
                    remainingPackages, self.__service,
                    ServiceController.installedPkgPath(self.__service))
                LOG.info('Completed untar all packages for (%s/%s)' %
                         (self.__service, self.__module))

            # now create the links
            for pkgDict in remainingPackages.itervalues():
                pkgPath = os.path.join(installedPkgPath,
                                       pkgDict['packageName'],
                                       pkgDict['packageVersion'])
                modulePath = os.path.join(
                    manifestutil.moduleRootPath(self.__service), self.__module)

                # validate target folder does exist
                if not os.path.exists(pkgPath):
                    raise AgentException(
                        Errors.PACKAGE_PATH_ERROR,
                        'invalid untarred package at %s' % pkgPath)

                # remove existing module
                isExistingModule = os.path.exists(modulePath)
                if isExistingModule:
                    execThreadTuple = self._getBuiltThread('deactivate')
                    super(ModuleCreate,
                          self)._runExeThread(self, execThreadTuple)
                    rmlink(modulePath)

                execThreadTuple = self._getBuiltThread('activate')
                super(ModuleCreate, self)._runExeThread(execThreadTuple)
                symlink(pkgPath, modulePath)

                # load controllers from package
                manifestutil.processModule(self.__service, self.__module,
                                           not isExistingModule)

            LOG.info('Completed create module for (%s/%s)' %
                     (self.__service, self.__module))
            self._updateStatus(progress=100)

        except AgentException as exc:
            LOG.info(exc.getMsg())
            self._updateStatus(httpStatus=500,
                               error=exc.getCode(),
                               errorMsg=exc.getMsg())

        except Exception as exc:
            errCode = Errors.UNKNOWN_ERROR
            msg = 'Unknown error for (%s/%s) - %s - %s' % (
                self.__service, self.__manifest, str(exc),
                traceback.format_exc(2))
            LOG.info(msg)
            self._updateStatus(httpStatus=500, error=errCode, errorMsg=msg)
Esempio n. 6
0
    def doRun(self):
        """ Main body of the thread

        Progress Info:
        Look at the list of packages this manifest has and figure out the progress of this manifest
        Progress 1 = manifest directory created
        Progress 2-80 = all packages downloaded
        Progress 81-99 = all packages untarred
        Progress 100 = all links done
        """
        inProgressPath = ManifestCreate.inProgress(manifestutil.manifestPath(self.__service, self.__manifest))
        try:
            if self.__service != 'agent':
                utils.checkDiskFull()

            installedPkgPath = manifestutil.installedPkgRootPath(self.__service)

            # This should not happen but make sure there isn'trn already a manifest directory in progress
            if (os.path.isdir(inProgressPath)):
                # probably another manifest create thread died out half way.
                # Cleanup and reattempt manifest creation
                LOG.debug('Manifest inprogress found for service/manifest (%s/%s). Will cleanup and retry' % (self.__service, self.__manifest))
                shutil.rmtree(inProgressPath)

            # make sure that the service path and installed package path exists
            if (not os.path.isdir(manifestutil.manifestRootPath(self.__service)) or
                not os.path.isdir(manifestutil.installedPkgRootPath(self.__service))):
                errCode = Errors.SERVICE_NOT_FOUND
                msg = 'Service (%s) for manifest (%s) not found' % (self.__service, self.__manifest)
                self._updateStatus(httpStatus = 500, error = errCode, errorMsg = msg)
                return

            # ok create the manifest path
            os.mkdir(inProgressPath)

            self._updateProgress(1)

            # figure out which of the packages are already there
            remainingPackages = {}
            for pkgUri in self.__packages:
                pkgDict = PackageUtil.parseUri(pkgUri)
                pkgPath = os.path.join(installedPkgPath, pkgDict['packageName'], pkgDict['packageVersion'])
                pkgName = pkgDict['packageName']
                if (not os.path.exists(pkgPath)) or ((self.__forcePackages is not None) and pkgName in self.__forcePackages):
                    remainingPackages[pkgUri] = pkgDict
                else:
                    symlink(pkgPath, os.path.join(inProgressPath, pkgDict['packageName']))

            if len(remainingPackages) > 0:
                # now make sure all the packages are downloaded
                try:
                    self._downloadPackages(remainingPackages.keys())
                except AgentException as exc:
                    # check if it is download error, then modify exception appropriately
                    if exc.getCode() == Errors.DC_FAILED_DOWNLOAD:
                        exc = AgentException(Errors.MANIFEST_PACKAGE_DOWNLOAD_FAILED,
                                            'Manifest (%s/%s) failed downloading package - %s'
                                            % (self.__service, self.__manifest, exc.getMsg()))
                    raise exc

            LOG.info('Completed download all packages for (%s/%s)' % (self.__service, self.__manifest))

            # now untar the packages
            import re
            pkgSuffix = '.%s' % re.sub(r"\W", "", self.__manifest)
            self._untarPackages(remainingPackages, self.__service, 
                                manifestutil.installedPkgRootPath(self.__service), 0, self.__forcePackages, pkgSuffix)
            LOG.info('Completed untar all packages for (%s/%s)' % (self.__service, self.__manifest))

            # now create the links
            for pkgDict in remainingPackages.itervalues():
                pkgPath = os.path.join(installedPkgPath, pkgDict['packageName'], pkgDict['packageVersion'])
                linkPath = os.path.join(inProgressPath, pkgDict['packageName'])
                # validate target folder does exist
                if not os.path.exists(pkgPath):
                    raise AgentException(Errors.PACKAGE_PATH_ERROR, 'invalid untarred package at %s' % pkgPath)
                symlink(pkgPath, linkPath)

            # now move the inProgressPath to the final path
            manifestContentPath = manifestutil.manifestContentPath(self.__service, self.__manifest)

            os.rename(inProgressPath, manifestutil.manifestPath(self.__service, self.__manifest))

            mfContentsFile = file(manifestContentPath, 'w')
            for pkgUri in self.__packages:
                mfContentsFile.write(('%s%s') % (pkgUri, os.linesep))
            mfContentsFile.close()
            LOG.info('Completed create manifest for (%s/%s)' % (self.__service, self.__manifest))

            self._updateStatus(progress = 100)

        except AgentException as exc:
            LOG.info(exc.getMsg())
            self._updateStatus(httpStatus = 500, error = exc.getCode(), errorMsg = exc.getMsg())
            
        except Exception as exc:
            errCode = Errors.UNKNOWN_ERROR
            msg = 'Unknown error for (%s/%s) - %s - %s' % (self.__service, self.__manifest,
                                                           str(exc), traceback.format_exc(2))
            LOG.info(msg)
            self._updateStatus(httpStatus = 500, error = errCode, errorMsg = msg)
        finally:
            # clean up intermediate progress
            try:
                shutil.rmtree(inProgressPath)
            except OSError:
                pass
 def testInstalledPkgRootPath(self):
     assert manifestutil.installedPkgRootPath('foo').endswith('foo' + os.path.sep + 'installed-packages')
Esempio n. 8
0
 def testInstalledPkgRootPath(self):
     assert manifestutil.installedPkgRootPath('foo').endswith(
         'foo' + os.path.sep + 'installed-packages')