Esempio n. 1
0
    def test_multiple_manifest_create(self):
        """ when a manifest creation is in progress for a service, another creation should block """
        packages = ["http://repository.qa.ebay.com/cronus/test-data/agent/pkgA-1.2.0.unix.cronus"]
        service = 'foo'
        manifest1 = 'bar'
        manifest2 = 'car'
        try:
            path = ServiceController.manifestPath(service)
            os.makedirs(path)
            path = ServiceController.installedPkgPath(service)
            os.makedirs(path)
        except Exception as excep:
            LOG.warning('got an OS Exception - %s' % str(excep))

        body = json.dumps({'package' : packages})
        response1 = self.app.post(url(controller = 'manifest', action = 'post', service = service, manifest = manifest1),
                                 headers = {'Content-Type' : 'application/json'},
                                 params = body)
        self.assertEquals(response1.status_int, 200, 'Manifest1 Post assert - should go through')

        try:
            response2 = self.app.post(url(controller = 'manifest', action = 'post', service = service, manifest = manifest2),
                                 headers = {'Content-Type' : 'application/json'},
                                 params = body)
            self.assertFalse(True, 'Expected an exception but did not get one!')
        except AppError:
            pass

        checkStatus(self, 'create manifest bar', response1, timeout = 25)
        self.assertTrue(islink(os.path.join(ManifestController.manifestPath('foo', 'bar'), 'pkgA')))
        self.assertFalse(islink(os.path.join(ManifestController.manifestPath('foo', 'car'), 'pkgA')))
Esempio n. 2
0
    def test_multiple_manifest_create(self):
        """ when a manifest creation is in progress for a service, another creation should block """
        packages = ["http://www.stackscaling.com/agentrepo/pkgA-1.2.0.unix.cronus"]
        service = 'foo'
        manifest1 = 'bar'
        manifest2 = 'car'
        try:
            for pkg in packages:
                mockDownloadPkg(pkg)
                
            path = ServiceController.manifestPath(service)
            os.makedirs(path)
            path = ServiceController.installedPkgPath(service)
            os.makedirs(path)
        except Exception as excep:
            LOG.warning('got an OS Exception - %s' % str(excep))

        body = json.dumps({'package' : packages})
        response1 = self.app.post(url(controller = 'manifest', action = 'post', service = service, manifest = manifest1),
                                 headers = {'Content-Type' : 'application/json'},
                                 params = body)
        self.assertEquals(response1.status_int, 200, 'Manifest1 Post assert - should go through')

        try:
            response2 = self.app.post(url(controller = 'manifest', action = 'post', service = service, manifest = manifest2),
                                 headers = {'Content-Type' : 'application/json'},
                                 params = body)
            self.assertFalse(True, 'Expected an exception but did not get one!')
        except AppError:
            pass

        checkStatus(self, 'create manifest bar', response1, timeout = 25)
        self.assertTrue(islink(os.path.join(manifestutil.manifestPath('foo', 'bar'), 'pkgA')))
        self.assertFalse(islink(os.path.join(manifestutil.manifestPath('foo', 'car'), 'pkgA')))
Esempio n. 3
0
    def getAllSymLinks(service):
        """ return all the symlinks from manifests to packages for a given service"""

        LOG.debug('calling getAllSymLinks %s' % service)
        linkedPaths = []
        manPath = ServiceController.manifestPath(service)
        LOG.debug('manifestPath is %s' % manPath)
        for path in os.listdir(manPath):
            LOG.debug('path is %s' % path)
            if not islink(os.path.join(manPath, path)):
                LOG.debug('path is dir not a link')
                pkgPaths = [
                    packageDir
                    for packageDir in os.listdir(os.path.join(manPath, path))
                ]
                LOG.debug('pkgPaths is %s' % pkgPaths)
                for pkgPath in pkgPaths:
                    try:
                        LOG.debug('pkgPath is %s' % pkgPath)
                        if not os.path.isfile(
                                os.path.join(
                                    manPath, path, pkgPath)) and islink(
                                        os.path.join(manPath, path, pkgPath)):
                            LOG.debug('pkgPaths is %s' % pkgPath)
                            targetPath = os.path.abspath(
                                readlink(os.path.join(manPath, path, pkgPath)))
                            linkedPaths.append(targetPath)
                            LOG.debug('targetPath is %s ' % targetPath)
                    except BaseException as exc:
                        LOG.error('failed to read link for the pkg path %s' %
                                  str(exc))
        return linkedPaths
Esempio n. 4
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. 5
0
    def test_post_manifest_inprogress_ok(self):
        service = 'foo'
        manifest = 'blahblah'
        try:
            path = ServiceController.servicePath(service)
            if os.path.exists(path):
                if os.name == 'nt':
                    cmd = 'rm -r %s' % path
                    LOG.debug("running command %s" % cmd)
                    os.system(cmd)
                else:
                    shutil.rmtree(path)
            path = ServiceController.manifestPath(service)
            os.makedirs(path)
            path = ServiceController.installedPkgPath(service)
            os.makedirs(path)
            inProgressPath = ManifestCreate.inProgress(ManifestController.manifestPath(service, manifest))
            os.makedirs(inProgressPath)
            path = ServiceController.downloadedPkgPath(service)
            os.makedirs(path)
        except Exception as excep:
            LOG.warning('got an OS Exception - %s' % str(excep))

        createManifest(self, ["http://github.com/yubin154/cronusagent/blob/master/agent/agent/tests/unit/packages/pkgA-1.2.0.unix.cronus"], manifest = 'blahblah', createDirs = False)
        self.assertTrue(islink(os.path.join(ManifestController.manifestPath('foo', 'blahblah'), 'pkgA')))
    def doRun(self):
        """ Main body of the thread """
        errorMsg = ""
        errorCode = None
        failed = False
        activeManifest = None

        try:
            activePath = manifestutil.manifestPath(self._service, 'active')
            # make sure that the active path exists and it is a link
            # Should we check this again since we already have a check in action controller
            if not os.path.exists(activePath) or not islink(activePath):
                raise AgentException(error = Errors.ACTIVEMANIFEST_MANIFEST_MISSING, errorMsg = 'No active manifest - cannot restart service')

            activeManifest = os.path.basename(readlink(activePath))

            self.__lcmActionManifest(self._service, activeManifest, self.__action)

            self._LOG.info('Done: %s service for (%s/%s)' % (self.__action, self._service, activeManifest))
            self._updateStatus(progress = 100)

        except AgentException as exc:
            failed = True
            errorMsg = '%s Service - Agent Exception - %s' % (self.__action, exc.getMsg())
            errorCode = exc.getCode()
        except Exception as exc:
            failed = True
            errorMsg = '%s Service - Unknown error - (%s/%s) - %s - %s' \
                        % (self.__action, self._service, self._manifest, str(exc), traceback.format_exc(5))
            errorCode = Errors.UNKNOWN_ERROR
        finally:
            if failed:
                self._LOG.error(errorMsg)

                self._updateStatus(httpStatus = 500, error = errorCode, errorMsg = errorMsg)
Esempio n. 7
0
def activateManifest(testController, manifest = 'bar', service = 'foo'):

    body = json.dumps({'manifest':manifest})

    response = testController.app.post(url(controller = 'manifest', action = 'activate', service = service, manifest = manifest),
                                       headers = {'Content-Type' : 'application/json'},
                                       params = body)

    assert response.status_int == 200, 'Action get assert'

    body = json.loads(response.body)

    tm = time.time()
    while (tm + 120 > time.time()):
        response = testController.app.get(body['status'])
        body = json.loads(response.body)

        LOG.debug("activateManifest ********** progress = %s" % body['progress'])
        if (int(body['progress']) == 100):
            break
        time.sleep(0.1)

    LOG.debug('status = ' + str(response.status_int))
    assert response.status_int == 200, "HTTP response != 200"
    LOG.debug ('Status response body = %s' % str(body))
    assert body['progress'] == 100

    # let's make sure the link is there correctly
    activePath = os.path.join(ServiceController.manifestPath(service), 'active')
    LOG.debug ('active path = ' + activePath)
    assert islink(activePath)

    link = readlink(activePath)
    LOG.debug ('link = ' + link)
    assert link == manifest
Esempio n. 8
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(ServiceController.installedPkgPath('foo'), 'perlserver', '1.0.0.unix',
                                           'cronus', 'scripts', 'activate')))
        self.assertTrue(islink(os.path.join(ManifestController.manifestPath('foo', 'bar'), 'perlserver')))
Esempio n. 9
0
    def test_package_reuse(self):
        createManifest(self)
        body = json.dumps({'package' : ['/packages/perlserver']})
        body = self.app.post(url(controller = 'manifest', action = 'post', service = "foo", manifest = "baz"),
                                 headers = {'Content-Type' : 'application/json'},
                                 params = body, expect_errors = True)

        self.assertTrue(os.path.exists(os.path.join(PackageMgr.packagePath(), 'perlserver-1.0.0.unix.cronus')))
        self.assertTrue(os.path.exists(os.path.join(ServiceController.installedPkgPath('foo'), 'perlserver', '1.0.0.unix',
                                           'cronus', 'scripts', 'activate')))
        self.assertTrue(islink(os.path.join(ManifestController.manifestPath('foo', 'bar'), 'perlserver')))

        for _ in range(10):
            if islink(os.path.join(ManifestController.manifestPath('foo', 'baz'), 'perlserver')):
                break
            time.sleep(1)

        self.assertTrue(islink(os.path.join(ManifestController.manifestPath('foo', 'baz'), 'perlserver')))
Esempio n. 10
0
    def test_package_reuse(self):
        createManifest(self)
        body = json.dumps({'package' : ['/packages/perlserver']})
        body = self.app.post(url(controller = 'manifest', action = 'post', service = "foo", manifest = "baz"),
                                 headers = {'Content-Type' : 'application/json'},
                                 params = body, expect_errors = True)

        self.assertTrue(os.path.exists(os.path.join(PackageMgr.packagePath(), 'perlserver-1.0.0.unix.cronus')))
        self.assertTrue(os.path.exists(os.path.join(ServiceController.installedPkgPath('foo'), 'perlserver', '1.0.0.unix',
                                           'cronus', 'scripts', 'activate')))
        self.assertTrue(islink(os.path.join(manifestutil.manifestPath('foo', 'bar'), 'perlserver')))

        for _ in range(10):
            if islink(os.path.join(manifestutil.manifestPath('foo', 'baz'), 'perlserver')):
                break
            time.sleep(1)

        self.assertTrue(islink(os.path.join(manifestutil.manifestPath('foo', 'baz'), 'perlserver')))
Esempio n. 11
0
    def doRun(self):
        """ Main body of the thread """
        errorMsg = ""
        errorCode = None
        failed = False
        try:

            activePath = os.path.join(
                ServiceController.manifestPath(self._service), 'active')
            oldManifest = None

            # make sure that if the active path exists, it's a link
            # if not log that and delete the link
            if (os.path.exists(activePath) and not os.name == 'nt'
                    and not islink(activePath)):
                self.__LOG.error('%s is not a link.  Attempted to delete' %
                                 activePath)
                shutil.rmtree(activePath)

            if (os.path.exists(activePath)):
                oldManifest = os.path.basename(readlink(activePath))
            else:
                raise AgentException(
                    error=Errors.ACTIVEMANIFEST_MANIFEST_MISSING,
                    errorMsg='No active manifest - cannot deactivate service')

            self.__deactivateManifest(self._service, oldManifest)
            self.__removeSymlink(self._service)

        except SystemExit as exc:
            failed = True
            if (len(exc.args) == 2):
                # ok we got {err code, err msg}
                errorCode = exc.args[0]
                errorMsg = exc.args[1]
            raise exc
        except AgentException as exc:
            failed = True
            errorMsg = 'Deactivate Manifest - Agent Exception - %s' % exc.getMsg(
            )
            errorCode = exc.getCode()
        except Exception as exc:
            failed = True
            errorMsg = 'Deactivate Manifest - Unknown error - (%s) - %s - %s' \
                        % (self._service, str(exc), traceback.format_exc(5))
            errorCode = Errors.UNKNOWN_ERROR
        finally:
            if failed:
                self.__LOG.warning(errorMsg)
                self._updateStatus(httpStatus=500,
                                   error=errorCode,
                                   errorMsg=errorMsg)
            self.__LOG.debug('Done: activate manifest for (%s)' %
                             (self._service))
            self._updateProgress(100)
Esempio n. 12
0
    def test_same_pkg_download_parallel(self):
        packages = ['http://www.stackscaling.com/agentrepo/pkgA-1.2.0.unix.cronus']
        manifest1 = 'bar'
        manifest2 = 'blah'
        service1 = 'foo'
        service2 = 'lah'
        try:
            for pkg in packages:
                mockDownloadPkg(pkg)
            
            path = ServiceController.manifestPath(service1)
            os.makedirs(path)
            path = ServiceController.installedPkgPath(service1)
            os.makedirs(path)
            path = ServiceController.downloadedPkgPath(service1)
            os.makedirs(path)
            path = ServiceController.manifestPath(service2)
            os.makedirs(path)
            path = ServiceController.installedPkgPath(service2)
            os.makedirs(path)
            path = ServiceController.downloadedPkgPath(service2)
            os.makedirs(path)
        except Exception as excep:
            LOG.warning('got an OS Exception - %s' % str(excep))

        body = json.dumps({'package' : packages})
        response1 = self.app.post(url(controller = 'manifest', action = 'post', service = service1, manifest = manifest1),
                                 headers = {'Content-Type' : 'application/json'},
                                 params = body)
        assert response1.status_int == 200, 'Manifest Post assert'

        response2 = self.app.post(url(controller = 'manifest', action = 'post', service = service2, manifest = manifest2),
                                 headers = {'Content-Type' : 'application/json'},
                                 params = body)
        assert response2.status_int == 200, 'Manifest Post assert'

        checkStatus(self, 'create manifest bar', response1, timeout = 25)
        checkStatus(self, 'create manifest baz', response2, timeout = 25)

        self.assertTrue(os.path.exists(os.path.join(PackageMgr.packagePath(), 'pkgA-1.2.0.unix.cronus')))
        self.assertTrue(islink(os.path.join(manifestutil.manifestPath('foo', 'bar'), 'pkgA')))
        self.assertTrue(islink(os.path.join(manifestutil.manifestPath('lah', 'blah'), 'pkgA')))
Esempio n. 13
0
    def doRun(self):
        """ Main body of the thread """
        errorMsg = ""
        errorCode = None
        failed = False
        activeManifest = None

        try:
            activePath = manifestutil.manifestPath(self._service, 'active')
            
            # make sure that the active path exists and it is a link
            # Should we check this again since we already have a check in action controller
            if not os.path.exists(activePath) or not islink(activePath):
                raise AgentException(error = Errors.ACTIVEMANIFEST_MANIFEST_MISSING, 
                                     errorMsg = 'Service %s has no active manifest' % self._service)

            activeManifest = os.path.basename(readlink(activePath))

            if self.__action == StartStopService.ACTION_SHUTDOWN:
                self._shutdownManifest(self._service, activeManifest, 50, 90)
            elif self.__action == StartStopService.ACTION_STARTUP:
                self._startupManifest(self._service, activeManifest, 50, 90)
            elif self.__action == StartStopService.ACTION_RESTART:
                self._restartManifest(self._service, activeManifest, 10, 90)
            else:
                raise AgentException(error = Errors.INVALID_LIFECYCLE_ACTION, 
                                     errorMsg = 'Invalid life cycle action - %s' % self.__action)

            self._LOG.info('Done: %s service for (%s/%s)' % (self.__action, self._service, activeManifest))
            self._updateStatus(progress = 100)

        except AgentException as exc:
            failed = True
            errorMsg = '%s Service - Agent Exception - %s' % (self.__action, exc.getMsg())
            errorCode = exc.getCode()
            
        except Exception as exc:
            failed = True
            errorMsg = '%s Service - Unknown error - (%s/%s) - %s - %s' \
                        % (self.__action, self._service, self._manifest, str(exc), traceback.format_exc(5))
            errorCode = Errors.UNKNOWN_ERROR
            
        finally:
            if failed:
                self._LOG.error(errorMsg)

                if not self._skipCleanupOnFailure() and self.__action != StartStopService.ACTION_SHUTDOWN and self._service and activeManifest:
                    try:
                        self._LOG.info('%s Service %s failed, shutdown to cleanup' % (self.__action, self._service))
                        self._shutdownManifest(self._service, activeManifest, 91, 99)
                    except BaseException as excep:
                        self._LOG.error('Cleanup failed - %s' % str(excep))

                self._updateStatus(httpStatus = 500, error = errorCode, errorMsg = errorMsg)
Esempio n. 14
0
    def doRun(self):
        """ Main body of the thread """
        errorMsg = ""
        errorCode = None
        failed = False
        activeManifest = None
        try:
            activePath = os.path.join(
                ServiceController.manifestPath(self._service), 'active')
            # make sure that the active path exists and it is a link
            # Should we check this again since we already have a check in action controller
            if not os.path.exists(activePath) or not islink(activePath):
                raise AgentException(
                    error=Errors.ACTIVEMANIFEST_MANIFEST_MISSING,
                    errorMsg='No active manifest - cannot reset service')

            activeManifest = os.path.basename(readlink(activePath))

            self.__shutdownManifest(self._service, activeManifest)
            self.__deactivateManifest(self._service, activeManifest)
            self.__activateManifest(self._service, activeManifest)
            self.__startupManifest(self._service, activeManifest)

            self.__LOG.info('Done: reset service for (%s/%s)' %
                            (self._service, activeManifest))
            self._updateStatus(progress=100)

        except AgentException as exc:
            failed = True
            errorMsg = 'Activate Manifest - Agent Exception - %s' % exc.getMsg(
            )
            errorCode = exc.getCode()
        except Exception as exc:
            failed = True
            errorMsg = 'Activate Manifest - Unknown error - (%s/%s) - %s - %s' \
                        % (self._service, self._manifest, str(exc), traceback.format_exc(5))
            errorCode = Errors.UNKNOWN_ERROR
        finally:
            if failed:
                self.__LOG.error(errorMsg)

                if self._service and activeManifest:
                    try:
                        self.__LOG.info(
                            'Reset service %s failed, shutdown to cleanup' %
                            self._service)
                        self.__shutdownManifest(self._service, activeManifest)
                    except BaseException as excep:
                        self.__LOG.error('Cleanup failed - %s' % str(excep))

                self._updateStatus(httpStatus=500,
                                   error=errorCode,
                                   errorMsg=errorMsg)
Esempio n. 15
0
    def test_same_pkg_download_parallel(self):
        packages = ['http://repository.qa.ebay.com/cronus/test-data/agent/perlserver-1.0.0.unix.cronus']
        manifest1 = 'bar'
        manifest2 = 'blah'
        service1 = 'foo'
        service2 = 'lah'
        try:
            path = ServiceController.manifestPath(service1)
            os.makedirs(path)
            path = ServiceController.installedPkgPath(service1)
            os.makedirs(path)
            path = ServiceController.downloadedPkgPath(service1)
            os.makedirs(path)
            path = ServiceController.manifestPath(service2)
            os.makedirs(path)
            path = ServiceController.installedPkgPath(service2)
            os.makedirs(path)
            path = ServiceController.downloadedPkgPath(service2)
            os.makedirs(path)
        except Exception as excep:
            LOG.warning('got an OS Exception - %s' % str(excep))

        body = json.dumps({'package' : packages})
        response1 = self.app.post(url(controller = 'manifest', action = 'post', service = service1, manifest = manifest1),
                                 headers = {'Content-Type' : 'application/json'},
                                 params = body)
        assert response1.status_int == 200, 'Manifest Post assert'

        response2 = self.app.post(url(controller = 'manifest', action = 'post', service = service2, manifest = manifest2),
                                 headers = {'Content-Type' : 'application/json'},
                                 params = body)
        assert response2.status_int == 200, 'Manifest Post assert'

        checkStatus(self, 'create manifest bar', response1, timeout = 25)
        checkStatus(self, 'create manifest baz', response2, timeout = 25)

        self.assertTrue(os.path.exists(os.path.join(PackageMgr.packagePath(), 'perlserver-1.0.0.unix.cronus')))
        self.assertTrue(islink(os.path.join(ManifestController.manifestPath('foo', 'bar'), 'perlserver')))
        self.assertTrue(islink(os.path.join(ManifestController.manifestPath('lah', 'blah'), 'perlserver')))
Esempio n. 16
0
    def doRun(self):
        """ Main body of the thread """
        errorMsg = ""
        errorCode = None
        failed = False
        activeManifest = None

        try:
            activePath = manifestutil.manifestPath(self._service, 'active')
            # make sure that the active path exists and it is a link
            # Should we check this again since we already have a check in action controller
            if not os.path.exists(activePath) or not islink(activePath):
                raise AgentException(error = Errors.ACTIVEMANIFEST_MANIFEST_MISSING, errorMsg = 'No active manifest - cannot restart service')

            activeManifest = os.path.basename(readlink(activePath))

            if self.__action == StartStopService.ACTION_SHUTDOWN:
                self.__shutdownManifest(self._service, activeManifest)
            elif self.__action == StartStopService.ACTION_STARTUP:
                self.__startupManifest(self._service, activeManifest)
            elif self.__action == StartStopService.ACTION_RESTART:
                self.__restartManifest(self._service, activeManifest)
            elif self.__action == StartStopService.ACTION_REBOOT:
                self.__rebootManifest(self._service, activeManifest)
            else:
                raise AgentException(error = Errors.INVALID_LIFECYCLE_ACTION, errorMsg = 'Invalid life cycle action - %s' % self.__action)

            self.__LOG.info('Done: %s service for (%s/%s)' % (self.__action, self._service, activeManifest))
            self._updateStatus(progress = 100)

        except AgentException as exc:
            failed = True
            errorMsg = '%s Service - Agent Exception - %s' % (self.__action, exc.getMsg())
            errorCode = exc.getCode()
        except Exception as exc:
            failed = True
            errorMsg = '%s Service - Unknown error - (%s/%s) - %s - %s' \
                        % (self.__action, self._service, self._manifest, str(exc), traceback.format_exc(5))
            errorCode = Errors.UNKNOWN_ERROR
        finally:
            if failed:
                self.__LOG.error(errorMsg)

                if not self._skipCleanupOnFailure() and self.__action != StartStopService.ACTION_SHUTDOWN and self._service and activeManifest:
                    try:
                        self.__LOG.info('%s Service %s failed, shutdown to cleanup' % (self.__action, self._service))
                        self.__shutdownManifest(self._service, activeManifest)
                    except BaseException as excep:
                        self.__LOG.error('Cleanup failed - %s' % str(excep))

                self._updateStatus(httpStatus = 500, error = errorCode, errorMsg = errorMsg)
Esempio n. 17
0
def getManifests(service):
    """ return the list of services under this agent """
    manifests = []

    rootPath = manifestRootPath(service)
    dirContent = os.listdir(rootPath)

    for item in dirContent:
        path = os.path.join(rootPath, item)
        if (os.path.isdir(path) and not path.endswith('.inprogress')):
            if (not utils.islink(path)):
                manifests.append(item)

    return sorted(manifests)
Esempio n. 18
0
def getManifests(service):
    """ return the list of services under this agent """
    manifests = []

    rootPath = manifestRootPath(service)
    dirContent = os.listdir(rootPath)

    for item in dirContent:
        path = os.path.join(rootPath, item)
        if (os.path.isdir(path) and not path.endswith('.inprogress')):
            if (not utils.islink(path)):
                manifests.append(item)

    return sorted(manifests)
Esempio n. 19
0
    def test_post3_pkg_already_installed(self):
        createManifest(self)

        # now lets remove the manifest path
        path = os.path.join(manifestutil.manifestPath('foo', 'bar'))
        shutil.rmtree(path)

        # now create the manifest again
        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(ServiceController.installedPkgPath('foo'), 'perlserver', '1.0.0.unix',
                                           'cronus', 'scripts', 'activate')))
        self.assertTrue(islink(os.path.join(manifestutil.manifestPath('foo', 'bar'), 'perlserver')))
Esempio n. 20
0
    def getManifests(service):
        """ return the list of manifests under a specific service """
        from agent.lib.agent_thread.manifest_create import ManifestCreate

        manifests = []

        dirContent = os.listdir(ServiceController.manifestPath(service))

        for item in dirContent:
            path = os.path.join(ServiceController.manifestPath(service), item)
            if (os.path.isdir(path) and not ManifestCreate.isInProgress(path)):
                if (not islink(path)):
                    manifests.append(item)

        return sorted(manifests)
Esempio n. 21
0
def getAllSymLinks(service):
    """ return all the symlinks from manifests to packages for a given service"""

    LOG.debug('calling getAllSymLinks %s' % service)
    linkedPaths = []
    manPath = manifestRootPath(service)
    LOG.debug('manifestPath is %s' % manPath)
    for path in os.listdir(manPath):
        LOG.debug('path is %s' % path)
        if not islink(os.path.join(manPath, path)):
            LOG.debug('path is dir not a link')
            pkgPaths = [ packageDir for packageDir in os.listdir(os.path.join(manPath, path)) ]
            LOG.debug('pkgPaths is %s' % pkgPaths)
            for pkgPath in pkgPaths:
                try:
                    LOG.debug('pkgPath is %s' % pkgPath)
                    if not os.path.isfile(os.path.join(manPath, path, pkgPath)) and islink(os.path.join(manPath, path, pkgPath)):
                        LOG.debug('pkgPaths is %s' % pkgPath)
                        targetPath = os.path.abspath(readlink(os.path.join(manPath, path, pkgPath)))
                        linkedPaths.append(targetPath)
                        LOG.debug('targetPath is %s ' % targetPath)
                except BaseException as exc:
                    LOG.error('failed to read link for the pkg path %s' % str(exc))
    return linkedPaths
Esempio n. 22
0
    def getManifests(service):
        """ return the list of manifests under a specific service """
        from agent.lib.agent_thread.manifest_create import ManifestCreate

        manifests = []

        dirContent = os.listdir(ServiceController.manifestPath(service))

        for item in dirContent:
            path = os.path.join(ServiceController.manifestPath(service), item)
            if (os.path.isdir(path) and not ManifestCreate.isInProgress(path)):
                if (not islink(path)):
                    manifests.append(item)

        return sorted(manifests)
Esempio n. 23
0
    def test_post3_already_installed_manifest(self):
        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(ServiceController.installedPkgPath('foo'), 'perlserver', '1.0.0.unix',
                                           'cronus', 'scripts', 'activate')))
        self.assertTrue(islink(os.path.join(ManifestController.manifestPath('foo', 'bar'), 'perlserver')))


        body = json.dumps({'package' : ['http://github.com/yubin154/cronusagent/blob/master/agent/agent/tests/unit/packages/perlserver-1.0.0.unix.cronus']})
        response = self.app.post(url(controller = 'manifest', action = 'post', service = "foo", manifest = "bar"),
                                 headers = {'Content-Type' : 'application/json'},
                                 params = body, expect_errors = True)
        self.assertEquals(201, response.status_int, 'Manifest Post assert')
        body = json.loads(response.body)
        assert response.status_int == 201, 'Manifest Post assert'
Esempio n. 24
0
    def test_post3_already_installed_manifest(self):
        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(ServiceController.installedPkgPath('foo'), 'perlserver', '1.0.0.unix',
                                           'cronus', 'scripts', 'activate')))
        self.assertTrue(islink(os.path.join(manifestutil.manifestPath('foo', 'bar'), 'perlserver')))


        body = json.dumps({'package' : ['http://github.com/yubin154/cronusagent/blob/master/agent/agent/tests/unit/packages/perlserver-1.0.0.unix.cronus']})
        response = self.app.post(url(controller = 'manifest', action = 'post', service = "foo", manifest = "bar"),
                                 headers = {'Content-Type' : 'application/json'},
                                 params = body, expect_errors = True)
        self.assertEquals(201, response.status_int, 'Manifest Post assert')
        body = json.loads(response.body)
        assert response.status_int == 201, 'Manifest Post assert'
Esempio n. 25
0
    def doRun(self):
        """ Main body of the thread """
        errorMsg = ""
        errorCode = None
        failed = False
        try:

            activePath = os.path.join(ServiceController.manifestPath(self._service), 'active')
            oldManifest = None

            # make sure that if the active path exists, it's a link
            # if not log that and delete the link
            if (os.path.exists(activePath) and not os.name == 'nt' and not islink(activePath)):
                self.__LOG.error('%s is not a link.  Attempted to delete' % activePath)
                shutil.rmtree(activePath)

            if (os.path.exists(activePath)):
                oldManifest = os.path.basename(readlink(activePath))
            else:
                raise AgentException(error = Errors.ACTIVEMANIFEST_MANIFEST_MISSING, errorMsg = 'No active manifest - cannot deactivate service')

            self.__deactivateManifest(self._service, oldManifest)
            self.__removeSymlink(self._service)

        except SystemExit as exc:
            failed = True
            if (len(exc.args) == 2):
                # ok we got {err code, err msg}
                errorCode = exc.args[0]
                errorMsg = exc.args[1]
            raise exc
        except AgentException as exc:
            failed = True
            errorMsg = 'Deactivate Manifest - Agent Exception - %s' % exc.getMsg()
            errorCode = exc.getCode()
        except Exception as exc:
            failed = True
            errorMsg = 'Deactivate Manifest - Unknown error - (%s) - %s - %s' \
                        % (self._service, str(exc), traceback.format_exc(5))
            errorCode = Errors.UNKNOWN_ERROR
        finally:
            if failed:
                self.__LOG.warning(errorMsg)
                self._updateStatus(httpStatus = 500, error = errorCode,
                                   errorMsg = errorMsg)
            self.__LOG.debug('Done: activate manifest for (%s)' % (self._service))
            self._updateProgress(100)
Esempio n. 26
0
def getModuleSymLinks(service = 'agent'):
    """ return all the symlinks from manifests to packages for a given service"""

    LOG.debug('calling getAllSymLinks %s' % service)
    linkedPaths = []
    mRootPath = moduleRootPath(service)
    LOG.debug('moduleRootPath is %s' % mRootPath)
    for pkgPath in os.listdir(mRootPath):
        try:
            LOG.debug('pkgPath is %s' % pkgPath)
            if not os.path.isfile(os.path.join(mRootPath, pkgPath)) and islink(os.path.join(mRootPath, pkgPath)):
                targetPath = os.path.abspath(readlink(os.path.join(mRootPath, pkgPath)))
                linkedPaths.append(targetPath)
                LOG.debug('targetPath is %s ' % targetPath)
        except BaseException as exc:
            LOG.error('failed to read link for the pkg path %s' % str(exc))
    return linkedPaths
Esempio n. 27
0
def getModuleSymLinks(service = 'agent'):
    """ return all the symlinks from manifests to packages for a given service"""

    LOG.debug('calling getAllSymLinks %s' % service)
    linkedPaths = []
    mRootPath = moduleRootPath(service)
    LOG.debug('moduleRootPath is %s' % mRootPath)
    for pkgPath in os.listdir(mRootPath):
        try:
            LOG.debug('pkgPath is %s' % pkgPath)
            if not os.path.isfile(os.path.join(mRootPath, pkgPath)) and islink(os.path.join(mRootPath, pkgPath)):
                targetPath = os.path.abspath(readlink(os.path.join(mRootPath, pkgPath)))
                linkedPaths.append(targetPath)
                LOG.debug('targetPath is %s ' % targetPath)
        except BaseException as exc:
            LOG.error('failed to read link for the pkg path %s' % str(exc))
    return linkedPaths
Esempio n. 28
0
    def doRun(self):
        """ Main body of the thread """
        errorMsg = ""
        errorCode = None
        failed = False
        activeManifest = None
        try:
            activePath = os.path.join(ServiceController.manifestPath(self._service), 'active')
            # make sure that the active path exists and it is a link
            # Should we check this again since we already have a check in action controller
            if not os.path.exists(activePath) or not islink(activePath):
                raise AgentException(error = Errors.ACTIVEMANIFEST_MANIFEST_MISSING, errorMsg = 'No active manifest - cannot reset service')

            activeManifest = os.path.basename(readlink(activePath))

            self.__shutdownManifest(self._service, activeManifest)
            self.__deactivateManifest(self._service, activeManifest)
            self.__activateManifest(self._service, activeManifest)
            self.__startupManifest(self._service, activeManifest)

            self.__LOG.info('Done: reset service for (%s/%s)' % (self._service, activeManifest))
            self._updateStatus(progress = 100)

        except AgentException as exc:
            failed = True
            errorMsg = 'Activate Manifest - Agent Exception - %s' % exc.getMsg()
            errorCode = exc.getCode()
        except Exception as exc:
            failed = True
            errorMsg = 'Activate Manifest - Unknown error - (%s/%s) - %s - %s' \
                        % (self._service, self._manifest, str(exc), traceback.format_exc(5))
            errorCode = Errors.UNKNOWN_ERROR
        finally:
            if failed:
                self.__LOG.error(errorMsg)

                if self._service and activeManifest:
                    try:
                        self.__LOG.info('Reset service %s failed, shutdown to cleanup' % self._service)
                        self.__shutdownManifest(self._service, activeManifest)
                    except BaseException as excep:
                        self.__LOG.error('Cleanup failed - %s' % str(excep))

                self._updateStatus(httpStatus = 500, error = errorCode, errorMsg = errorMsg)
Esempio n. 29
0
    def test_inprogress_pkg_download(self):
        service = 'foo'
        try:
            path = ServiceController.manifestPath(service)
            os.makedirs(path)
            path = ServiceController.installedPkgPath(service)
            os.makedirs(path)
            path = ServiceController.downloadedPkgPath(service)
            os.makedirs(path)
            inprogressPath = os.path.join(PackageMgr.packagePath(), 'perlserver-1.0.0.unix.cronus.inprogress')
            inprogressFile = open(inprogressPath, 'w')
            inprogressFile.write('somegarbage')
            inprogressFile.close()
        except Exception as excep:
            LOG.warning('got an OS Exception - %s' % str(excep))

        createManifest(self)
        self.assertTrue(os.path.exists(os.path.join(PackageMgr.packagePath(), 'perlserver-1.0.0.unix.cronus')))
        self.assertTrue(islink(os.path.join(manifestutil.manifestPath('foo', 'bar'), 'perlserver')))
Esempio n. 30
0
    def test_inprogress_pkg_download(self):
        service = 'foo'
        try:
            path = ServiceController.manifestPath(service)
            os.makedirs(path)
            path = ServiceController.installedPkgPath(service)
            os.makedirs(path)
            path = ServiceController.downloadedPkgPath(service)
            os.makedirs(path)
            inprogressPath = os.path.join(PackageMgr.packagePath(), 'perlserver-1.0.0.unix.cronus.inprogress')
            inprogressFile = open(inprogressPath, 'w')
            inprogressFile.write('somegarbage')
            inprogressFile.close()
        except Exception as excep:
            LOG.warning('got an OS Exception - %s' % str(excep))

        createManifest(self)
        self.assertTrue(os.path.exists(os.path.join(PackageMgr.packagePath(), 'perlserver-1.0.0.unix.cronus')))
        self.assertTrue(islink(os.path.join(ManifestController.manifestPath('foo', 'bar'), 'perlserver')))
Esempio n. 31
0
def activateManifest(testController, manifest='bar', service='foo'):

    body = json.dumps({'manifest': manifest})

    response = testController.app.post(
        url(controller='action', action='activatemanifest', service=service),
        headers={'Content-Type': 'application/json'},
        params=body)

    assert response.status_int == 200, 'Action get assert'

    body = json.loads(response.body)

    tm = time.time()
    while (tm + 120 > time.time()):
        response = testController.app.get(body['status'])
        body = json.loads(response.body)

        LOG.debug("activateManifest ********** progress = %s" %
                  body['progress'])
        if (int(body['progress']) == 100):
            break
        time.sleep(0.1)

    LOG.debug('status = ' + str(response.status_int))
    assert response.status_int == 200, "HTTP response != 200"
    LOG.debug('Status response body = %s' % str(body))
    assert body['progress'] == 100

    # let's make sure the link is there correctly
    activePath = os.path.join(ServiceController.manifestPath(service),
                              'active')
    LOG.debug('active path = ' + activePath)
    assert islink(activePath)

    link = readlink(activePath)
    LOG.debug('link = ' + link)
    if os.name == 'nt':
        manifestPath = os.path.join(ServiceController.manifestPath(service),
                                    manifest)
        assert (link == manifestPath or link == manifest)
    else:
        assert link == manifest
Esempio n. 32
0
    def test_post3_pkg_already_installed(self):
        createManifest(self)

        # now lets remove the manifest path
        path = os.path.join(ManifestController.manifestPath('foo', 'bar'))
        if os.name == 'nt':
            cmd = 'rm -r %s' % path
            LOG.debug("running command %s" % cmd)
            os.system(cmd)
        else:
            shutil.rmtree(path)

        # now create the manifest again
        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(ServiceController.installedPkgPath('foo'), 'perlserver', '1.0.0.unix',
                                           'cronus', 'scripts', 'activate')))
        self.assertTrue(islink(os.path.join(ManifestController.manifestPath('foo', 'bar'), 'perlserver')))
Esempio n. 33
0
    def doRun(self):
        """ Main body of the thread """
        errorMsg = ""
        errorCode = None
        symlinkSwitched = False
        failed = False
        try:
            activePath = os.path.join(
                ServiceController.manifestPath(self._service), 'active')
            oldManifest = None

            appGlobal = pylons.config['pylons.app_globals']

            # make sure that if the active path exists, it's a link
            # if not log that and delete the link
            if (os.path.exists(activePath) and not os.name == 'nt'
                    and not islink(activePath)):
                self.__LOG.error('%s is not a link.  Attempted to delete' %
                                 activePath)
                shutil.rmtree(activePath)

            if (os.path.exists(activePath)):
                oldManifest = os.path.basename(readlink(activePath))

            self.__installManifest(self._service, self._manifest)
            self.__deactivateManifest(self._service, oldManifest)
            symlinkSwitched = self.__switchSymlink(self._service,
                                                   self._manifest)

            appGlobal = pylons.config['pylons.app_globals']

            if self._service == 'agent':
                # START Jeff  09 19 2012: save the timestamp and old manifestPath to .recover: only for agent service.
                recoveryInfo = {}
                beforeKillTimeHuman = strftime("%Y-%m-%d %H:%M:%S",
                                               localtime())
                beforeKillTimeStamp = int(time.time())
                recoveryInfo['beforeKillTimeHuman'] = str(beforeKillTimeHuman)
                recoveryInfo['beforeKillTimeStamp'] = str(beforeKillTimeStamp)
                # make sure there is always quote: even if null. easy for json parsing in startup
                if self._manifest:
                    recoveryInfo['newManifest'] = self._manifest
                else:
                    recoveryInfo['newManifest'] = 'null'
                if oldManifest:
                    recoveryInfo['oldManifest'] = oldManifest
                else:
                    recoveryInfo['oldManifest'] = 'null'
                manifestutil.writeJson('agent', '.recovery', recoveryInfo)
                # END Jeff  09 19 2012: save the timestamp and .recover files with

                # persist threads result before shutting down
                if (hasattr(appGlobal, 'threadMgr')
                        and appGlobal.threadMgr != None):
                    killStatus = {}
                    killStatus['httpStatus'] = 500
                    killStatus['error'] = Errors.THREAD_KILLED_AGENT_RESTART
                    killStatus['errorMsg'] = 'thread killed, agent restart'
                    appGlobal.threadMgr.snapshot(killStatus, True)

            self.__activateManifest(self._service, self._manifest)

        except SystemExit as exc:
            failed = True
            if (len(exc.args) == 2):
                # ok we got {err code, err msg}
                errorCode = exc.args[0]
                errorMsg = exc.args[1]
            raise exc

        except AgentException as exc:
            failed = True
            errorMsg = 'Activate Manifest - Agent Exception - %s' % exc.getMsg(
            )
            errorCode = exc.getCode()

        except Exception as exc:
            failed = True
            errorMsg = 'Activate Manifest - Unknown error - (%s/%s) - %s - %s' \
                        % (self._service, self._manifest, str(exc), traceback.format_exc(5))
            errorCode = Errors.UNKNOWN_ERROR

        finally:
            if failed:
                if not self._skipCleanupOnFailure():
                    self.__cleanup(symlinkSwitched, errorMsg, errorCode)

                self.__LOG.warning(errorMsg)
                self._updateStatus(httpStatus=500,
                                   error=errorCode,
                                   errorMsg=errorMsg)
            else:
                self._updateProgress(100)
Esempio n. 34
0
    def doRun(self):
        """ Main body of the thread """
        errorMsg = ""
        errorCode = None
        symlinkSwitched = False
        failed = False
        try:
            activePath = os.path.join(ServiceController.manifestPath(self._service), 'active')
            oldManifest = None
            
            appGlobal = pylons.config['pylons.app_globals']

            # make sure that if the active path exists, it's a link
            # if not log that and delete the link
            if (os.path.exists(activePath) and not os.name == 'nt' and not islink(activePath)):
                self.__LOG.error('%s is not a link.  Attempted to delete' % activePath)
                shutil.rmtree(activePath)

            if (os.path.exists(activePath)):
                oldManifest = os.path.basename(readlink(activePath))

            self.__installManifest(self._service, self._manifest)
            self.__deactivateManifest(self._service, oldManifest)
            symlinkSwitched = self.__switchSymlink(self._service, self._manifest)

            appGlobal = pylons.config['pylons.app_globals']

            if self._service == 'agent':
                # START Jeff  09 19 2012: save the timestamp and old manifestPath to .recover: only for agent service.
                recoveryInfo = {}
                beforeKillTimeHuman = strftime("%Y-%m-%d %H:%M:%S", localtime())
                beforeKillTimeStamp = int(time.time())
                recoveryInfo['beforeKillTimeHuman'] = str(beforeKillTimeHuman) 
                recoveryInfo['beforeKillTimeStamp'] = str(beforeKillTimeStamp) 
                # make sure there is always quote: even if null. easy for json parsing in startup
                if self._manifest:
                    recoveryInfo['newManifest'] = self._manifest
                else:
                    recoveryInfo['newManifest'] = 'null'
                if oldManifest:
                    recoveryInfo['oldManifest'] = oldManifest
                else:
                    recoveryInfo['oldManifest'] = 'null'
                manifestutil.writeJson('agent', '.recovery', recoveryInfo)
                # END Jeff  09 19 2012: save the timestamp and .recover files with

                # persist threads result before shutting down
                if (hasattr(appGlobal, 'threadMgr') and appGlobal.threadMgr != None):
                    killStatus = {}
                    killStatus['httpStatus'] = 500
                    killStatus['error'] = Errors.THREAD_KILLED_AGENT_RESTART
                    killStatus['errorMsg'] = 'thread killed, agent restart'
                    appGlobal.threadMgr.snapshot(killStatus, True)

            self.__activateManifest(self._service, self._manifest)

        except SystemExit as exc:
            failed = True
            if (len(exc.args) == 2):
                # ok we got {err code, err msg}
                errorCode = exc.args[0]
                errorMsg = exc.args[1]
            raise exc
        
        except AgentException as exc:
            failed = True
            errorMsg = 'Activate Manifest - Agent Exception - %s' % exc.getMsg()
            errorCode = exc.getCode()
        
        except Exception as exc:
            failed = True
            errorMsg = 'Activate Manifest - Unknown error - (%s/%s) - %s - %s' \
                        % (self._service, self._manifest, str(exc), traceback.format_exc(5))
            errorCode = Errors.UNKNOWN_ERROR
        
        finally:
            if failed: 
                if not self._skipCleanupOnFailure():
                    self.__cleanup(symlinkSwitched, errorMsg, errorCode)

                self.__LOG.warning(errorMsg)
                self._updateStatus(httpStatus = 500, error = errorCode, errorMsg = errorMsg)
            else:
                self._updateProgress(100)
Esempio n. 35
0
    def doRun(self):
        """ Main body of the thread """
        errorMsg = ""
        errorCode = None
        symlinkSwitched = False
        failed = False
        
        try:
            activePath = manifestutil.manifestPath(self._service)
            oldManifest = None
            
            # make sure that if the active path exists, it's a link
            # if not log that and delete the link
            if (os.path.exists(activePath) and not islink(activePath)):
                self._LOG.error('%s is not a link.  Attempted to delete' % activePath)
                shutil.rmtree(activePath)

            if (os.path.exists(activePath)):
                oldManifest = os.path.basename(readlink(activePath))
            # reset requires a valid active link exist
            else:
                if self.__action == ActivateManifest.ACTION_RESET:
                    raise AgentException(error = Errors.ACTIVEMANIFEST_MANIFEST_MISSING, 
                                         errorMsg = ('No active manifest - cannot %s service' 
                                                     % self.__action))

            if self.__action == ActivateManifest.ACTION_ACTIVATION:
                # install new manifest
                self.__installManifest(self._service, self._manifest)
            
            self._deactivateManifest(self._service, oldManifest, 11, 50)
            
            if self.__action == ActivateManifest.ACTION_ACTIVATION:
                # special logic to handle agent upgrade
                # agent upgrade will not run full activation agent will shutdown before activate exit
                if self._service == 'agent':
                    appGlobal = pylons.config['pylons.app_globals']
                    # persist threads result before shutting down
                    if (hasattr(appGlobal, 'threadMgr') and appGlobal.threadMgr != None):
                        killStatus = {}
                        killStatus['httpStatus'] = 500
                        killStatus['error'] = Errors.THREAD_KILLED_AGENT_RESTART
                        killStatus['errorMsg'] = 'thread killed, agent restart'
                        appGlobal.threadMgr.snapshot(killStatus, True)
            
                # switch active symlink
                symlinkSwitched = self.__switchSymlink(self._service, self._manifest)
                # activate new manifest
                self._activateManifest(self._service, self._manifest, 51, 80)

            elif self.__action == ActivateManifest.ACTION_DEACTIVATION:
                # remove active link on deactivate
                activePath = self.__getSymlinkPath(self._service)
                self.__removeSymlink(activePath)

            else:
                # activate new manifest
                self._activateManifest(self._service, self._manifest, 51, 80)

        except SystemExit as exc:
            failed = True
            if (len(exc.args) == 2):
                # ok we got {err code, err msg}
                errorCode = exc.args[0]
                errorMsg = exc.args[1]
            raise exc
        
        except AgentException as exc:
            failed = True
            errorMsg = '%s manifest - Agent Exception - %s' % (self.__action, exc.getMsg())
            errorCode = exc.getCode()
        
        except Exception as exc:
            failed = True
            errorMsg = '%s manifest - Unknown error - (%s/%s) - %s - %s' \
                        % (self.__action, self._service, self._manifest, 
                           str(exc), traceback.format_exc(5))
            errorCode = Errors.UNKNOWN_ERROR
        
        finally:
            if failed: 
                if not self._skipCleanupOnFailure():
                    self.__cleanup(symlinkSwitched, errorMsg, errorCode)

                self._LOG.warning(errorMsg)
                self._updateStatus(httpStatus = 500, error = errorCode, errorMsg = errorMsg)
            else:
                self._updateProgress(100)