def __activateManifest(self):
""" activate a manifest
"""
LOG.info("Activate Manifest %s - %s" %
(self.__service, self.__manifest))
# make sure manifest to be activated exist
manifestPath = manifestutil.manifestPath(self.__service,
self.__manifest)
if (not os.path.exists(manifestPath)):
LOG.error('Manifest %s does not exist, fail activation' %
self.__manifest)
raise AgentException(
Errors.MANIFEST_NOT_FOUND,
'Manifest %s does not exist' % self.__manifest)
# check to see if the manifest already active
activeManifest = manifestutil.activeManifestPath(self.__service)
if activeManifest == self.__manifest:
LOG.info('Manifest %s already active, skip activation' %
self.__manifest)
return
from agent.lib.agent_thread.activate_manifest import ActivateManifest
activateThread = ActivateManifest(self._threadMgr, self.__service,
self.__manifest)
contextutils.copycontexts(self, activateThread, contextutils.CTX_NAMES)
activateThread.run()
status = activateThread.getStatus()
if (status.has_key('error') and status['error']):
raise AgentException(status['error'], status['errorMsg'])
def activate(self, service, manifest):
""" activate manifest, if already active then skip """
from agent.lib.agent_thread.activate_manifest import ActivateManifest
LOG.info('activateManifest for service(%s) with body: %s', service, request.body)
try:
appGlobal = config['pylons.app_globals']
if manifestutil.getActiveManifest(service) == manifest:
return doneResult(request, response, controller=self)
else:
if request.body:
pushedData = json.loads(request.body)
serviceutil.updateLcmMeta(service, pushedData)
mf_path = os.path.join(manifestutil.manifestPath(service, manifest))
if (not os.path.exists(mf_path)):
return errorResult(request, response, Errors.ACTIVEMANIFEST_MANIFEST_MISSING,
'Manifest(%s, %s) path missing' % (service, manifest),
controller=self)
LOG.debug('Manifest path exists: %s' % (mf_path))
activateThread = ActivateManifest(appGlobal.threadMgr, service, manifest,
action=ActivateManifest.ACTION_ACTIVATION)
self.injectJobCtx(activateThread)
activateThread.start()
activateThread.threadMgrEvent.wait()
return statusResult(request, response, activateThread, controller=self)
except Exception as excep:
msg = 'Unknown error for activateManifest(%s/%s) - %s - %s' % (service, manifest, str(excep), traceback.format_exc(2))
return errorResult(request, response, error=Errors.UNKNOWN_ERROR,
errorMsg=msg, controller=self)
def __activateManifest(self):
""" activate a manifest
"""
LOG.info("Activate Manifest %s - %s" % (self.__service, self.__manifest))
# make sure manifest to be activated exist
manifestPath = manifestutil.manifestPath(self.__service, self.__manifest)
if (not os.path.exists(manifestPath)):
LOG.error('Manifest %s does not exist, fail activation' % self.__manifest)
raise AgentException(Errors.MANIFEST_NOT_FOUND, 'Manifest %s does not exist' % self.__manifest)
# check to see if the manifest already active
activeManifest = manifestutil.activeManifestPath(self.__service)
if activeManifest == self.__manifest:
LOG.info('Manifest %s already active, skip activation' % self.__manifest)
return
from agent.lib.agent_thread.activate_manifest import ActivateManifest
activateThread = ActivateManifest(self._threadMgr, self.__service, self.__manifest)
contextutils.copycontexts(self, activateThread, contextutils.CTX_NAMES)
activateThread.run()
status = activateThread.getStatus()
if (status.has_key('error') and status['error']):
raise AgentException(status['error'], status['errorMsg'])
def __activateManifest(self):
""" activate a manifest
"""
LOG.info("Activate Manifest %s - %s" % (self.__service, self.__manifest))
# make sure manifest to be activated exist
manifestPath = manifestutil.manifestPath(self.__service, self.__manifest)
if (not os.path.exists(manifestPath)):
LOG.error('Manifest %s does not exist, fail activation' % self.__manifest)
raise AgentException(Errors.MANIFEST_NOT_FOUND, 'Manifest %s does not exist' % self.__manifest)
# check to see if the manifest already active
activeManifest = manifestutil.activeManifestPath(self.__service)
if activeManifest == self.__manifest:
LOG.info('Manifest %s already active, skip activation' % self.__manifest)
return
# activating new agent is going to kill agent process, update progress to 100% and flush all progress now
self._updateProgress(100)
status = self.status2msg()
msg = json.dumps(status)
UUIDLOG.info('%s output start %s %s output end' % (self.getUuid(), msg, self.getUuid()))
from agent.lib.agent_thread.activate_manifest import ActivateManifest
activateThread = ActivateManifest(self._threadMgr, self.__service, self.__manifest, parentId = self.getUuid())
contextutils.copycontexts(self, activateThread, contextutils.CTX_NAMES)
activateThread.run()
self._addChildExeThreadId(activateThread.getChildExeThreadIds())
status = activateThread.getStatus()
if (status.has_key('error') and status['error']):
raise AgentException(status['error'], status['errorMsg'])
def reset(self, service):
''' Controller to reset service '''
LOG.info('reset for service(%s)', service)
try:
appGlobal = config['pylons.app_globals']
if not os.path.exists(manifestutil.manifestPath(service, 'active')):
return errorResult(request, response, Errors.ACTIVEMANIFEST_MANIFEST_MISSING,
'Active Manifest(%s) path missing' % (service),
controller = self)
resetThread = ActivateManifest(appGlobal.threadMgr, service,
manifestutil.ACTIVE_MANIFEST,
action = ActivateManifest.ACTION_RESET)
self.injectJobCtx(resetThread)
resetThread.start()
resetThread.threadMgrEvent.wait()
return statusResult(request, response, resetThread, controller = self)
except Exception as excep:
return errorResult(request, response, error = Errors.UNKNOWN_ERROR,
errorMsg = 'Unknown error for restart service(%s) - %s - %s' %
(service, str(excep), traceback.format_exc(2)),
controller = self)
def rollbackservice(self, service):
""" rollback an existing service """
LOG.info('rollback to last active manifest for service(%s) ', service)
manifest = None
try:
appGlobal = config['pylons.app_globals']
manifest = serviceutil.getPastManifest(service, 1)
if manifest:
activateThread = ActivateManifest(appGlobal.threadMgr, service, manifest,
action=ActivateManifest.ACTION_ACTIVATION)
self.injectJobCtx(activateThread)
activateThread.start()
activateThread.threadMgrEvent.wait()
else:
raise AgentException(Errors.MANIFEST_NOT_FOUND, "No rollback manifest found")
return statusResult(request, response, activateThread, controller=self)
except AgentException as excep:
return errorResult(request, response, error=excep.getCode(), errorMsg=excep.getMsg(), controller=self)
except Exception as excep:
msg = 'Unknown error for rollback service(%s) - %s - %s' % (service, str(excep), traceback.format_exc(2))
return errorResult(request, response, error=Errors.UNKNOWN_ERROR,
errorMsg=msg, controller=self)
def activatemanifest(self, service):
""" activate manifest, if already active then skip """
LOG.info('activateManifest for service(%s) with body: %s', service, request.body)
try:
appGlobal = config['pylons.app_globals']
manifest = ''
requestjson = json.loads(request.body)
manifest = requestjson['manifest']
force = asbool(requestjson['force']) if 'force' in requestjson else False
if not force and manifestutil.getActiveManifest(service) == manifest:
return doneResult(request, response, controller=self)
else:
mf_path = os.path.join(ManifestController.manifestPath(service, manifest))
if (not os.path.exists(mf_path)):
return errorResult(request, response, Errors.ACTIVEMANIFEST_MANIFEST_MISSING,
'Manifest(%s, %s) path missing' % (service, manifest),
controller = self)
LOG.debug('Manifest path exists: %s' % (mf_path))
activateThread = ActivateManifest(appGlobal.threadMgr, service, manifest)
self.injectJobCtx(activateThread)
activateThread.start()
activateThread.threadMgrEvent.wait()
return statusResult(request, response, activateThread, controller = self)
except Exception as excep:
msg = 'Unknown error for activateManifest(%s/%s) - %s - %s' % (service, manifest, str(excep), traceback.format_exc(2))
return errorResult(request, response, error = Errors.UNKNOWN_ERROR,
errorMsg = msg, controller = self)
def activatemanifest(self, service):
""" activate manifest, if already active then skip """
LOG.info('activateManifest for service(%s) with body: %s', service,
request.body)
try:
appGlobal = config['pylons.app_globals']
manifest = ''
requestjson = json.loads(request.body)
manifest = requestjson['manifest']
force = asbool(
requestjson['force']) if 'force' in requestjson else False
if not force and manifestutil.getActiveManifest(
service) == manifest:
return doneResult(request, response, controller=self)
else:
mf_path = os.path.join(
ManifestController.manifestPath(service, manifest))
if (not os.path.exists(mf_path)):
return errorResult(request,
response,
Errors.ACTIVEMANIFEST_MANIFEST_MISSING,
'Manifest(%s, %s) path missing' %
(service, manifest),
controller=self)
LOG.debug('Manifest path exists: %s' % (mf_path))
activateThread = ActivateManifest(appGlobal.threadMgr, service,
manifest)
self.injectJobCtx(activateThread)
activateThread.start()
activateThread.threadMgrEvent.wait()
return statusResult(request,
response,
activateThread,
controller=self)
except Exception as excep:
msg = 'Unknown error for activateManifest(%s/%s) - %s - %s' % (
service, manifest, str(excep), traceback.format_exc(2))
return errorResult(request,
response,
error=Errors.UNKNOWN_ERROR,
errorMsg=msg,
controller=self)
def deactivatemanifest(self, service):
""" deactivate a manifest """
LOG.info('activateManifest for service(%s) with body: %s', service, request.body)
try:
appGlobal = config['pylons.app_globals']
if not os.path.exists(manifestutil.manifestPath(service, 'active')):
return errorResult(request, response, Errors.ACTIVEMANIFEST_MANIFEST_MISSING,
'Deactivate Manifest(%s) path missing' % (service),
controller = self)
deactivateThread = ActivateManifest(appGlobal.threadMgr, service,
manifestutil.ACTIVE_MANIFEST,
action=ActivateManifest.ACTION_DEACTIVATION)
self.injectJobCtx(deactivateThread)
deactivateThread.start()
deactivateThread.threadMgrEvent.wait()
return statusResult(request, response, deactivateThread, controller = self)
except Exception as excep:
msg = 'Unknown error for deactivateManifest(%s) - %s - %s' % (service, str(excep), traceback.format_exc(2))
return errorResult(request, response, error = Errors.UNKNOWN_ERROR,
errorMsg = msg, controller = self)
def doRun(self):
""" Main body of the thread """
self._updateProgress(1)
errorMsg = ""
errorCode = None
failed = False
try:
# create manifest if not already exist
mpath = manifestutil.manifestPath(self._service, self._manifest)
if (not os.path.exists(mpath) or not os.path.isdir(mpath)):
self._LOG.debug('pkgs = %s', self.__packages)
# parse the package list
for idx, package in enumerate(self.__packages):
if package.startswith('/'):
packageRef = package
tokens = package.split('/')
pkgnamePrefix = tokens[-1].rstrip()
fullPkgLoc = manifestutil.getPackageFullLocByName(self._service, manifest = None, pkgnamePrefix = pkgnamePrefix)
if fullPkgLoc is None:
raise AgentException(Errors.MANIFEST_PACKAGE_DOES_NOT_EXIST,
'manifest (%s/%s) package (%s) does not exist' %
(self._service, self._manifest, self.__packages))
else:
self._LOG.info('expanding package reuse ref %s with full package location %s' % (packageRef, fullPkgLoc))
self.__packages[idx] = fullPkgLoc
# start a thread to create the package
manThread = ManifestCreate(self._threadMgr, self._service, self._manifest, self.__packages, parentId = self.getUuid())
contextutils.copyJobContexts(self, manThread)
manThread.run()
self._addChildExeThreadId(manThread.getChildExeThreadIds())
status = manThread.getStatus()
if (status['error'] != None):
raise AgentException(status['error'], status['errorMsg'])
self._updateProgress(60)
if (not os.path.exists(mpath)):
raise AgentException(Errors.ACTIVEMANIFEST_MANIFEST_MISSING,
'Manifest(%s, %s) path missing' % (self._service, self._manifest))
# activate manifest if not already activated
activateThread = ActivateManifest(self._threadMgr, self._service, self._manifest, parentId = self.getUuid())
contextutils.copyJobContexts(self, activateThread)
activateThread.run()
self._addChildExeThreadId(activateThread.getChildExeThreadIds())
status = activateThread.getStatus()
if (status['error'] != None):
raise AgentException(status['error'], status['errorMsg'])
if manifestutil.getActiveManifest(self._service) != self._manifest:
raise AgentException(Errors.ACTIVEMANIFEST_MANIFEST_MISSING,
'Manifest(%s, %s) path missing' % (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]
except AgentException as exc:
failed = True
errorMsg = 'Deploy Service - Agent Exception - %s' % exc.getMsg()
errorCode = exc.getCode()
except Exception as exc:
failed = True
errorMsg = 'Deploy Service - 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.warning(errorMsg)
self._updateStatus(httpStatus = 500, error = errorCode, errorMsg = errorMsg)
else:
self._updateProgress(100)
def testAgentThreadName(self):
activateManifest = ActivateManifest(NullThreadMgr(), 'foo', 'bar')
assert activateManifest.getName() == ActivateManifest.THREAD_NAME
def doRun(self):
""" Main body of the thread """
spath = manifestutil.servicePath(self._service)
self._updateProgress(1)
errorMsg = ""
errorCode = None
failed = False
ctxNames = ['guid', 'service']
try:
# create service if not already exist
if not os.path.exists(spath):
os.makedirs(spath)
os.makedirs(os.path.join(spath, 'manifests'))
os.makedirs(os.path.join(spath, 'installed-packages'))
os.makedirs(os.path.join(spath, 'modules'))
os.makedirs(os.path.join(spath, 'downloaded-packages'))
os.makedirs(os.path.join(spath, '.appdata'))
os.makedirs(os.path.join(spath, '.data'))
import pwd
uname = pylons.config['app_user_account']
uid = pwd.getpwnam(uname).pw_uid
gid = pwd.getpwnam(uname).pw_gid
utils.rchown(os.path.join(spath, '.appdata'), uid, gid)
# verify that the path exists
if (not os.path.isdir(spath)):
raise AgentException(Errors.UNKNOWN_ERROR, "Service(%s) was not created" % self._service)
self._updateProgress(20)
# create manifest if not already exist
mpath = manifestutil.manifestPath(self._service, self._manifest)
if (not os.path.exists(mpath) or not os.path.isdir(mpath)):
self.__LOG.debug('pkgs = %s', self.__packages)
# parse the package list
for idx, package in enumerate(self.__packages):
if package.startswith('/'):
packageRef = package
tokens = package.split('/')
pkgnamePrefix = tokens[-1].rstrip()
fullPkgLoc = manifestutil.getPackageByName(self._service, manifest = None, pkgnamePrefix = pkgnamePrefix)
if fullPkgLoc is None:
raise AgentException(Errors.MANIFEST_PACKAGE_DOES_NOT_EXIST,
'manifest (%s/%s) package (%s) does not exist' %
(self._service, self._manifest, self.__packages))
else:
self.__LOG.info('expanding package reuse ref %s with full package location %s' % (packageRef, fullPkgLoc))
self.__packages[idx] = fullPkgLoc
# start a thread to create the package
manThread = ManifestCreate(threadmgr.NULL_THREADMGR, self._service, self._manifest, self.__packages, skipProp = self.__skipProp)
contextutils.copycontexts(self, manThread, ctxNames)
manThread.run()
status = manThread.getStatus()
if (status['error'] != None):
raise AgentException(status['error'], status['errorMsg'])
self._updateProgress(60)
if (not os.path.exists(mpath)):
raise AgentException(Errors.ACTIVEMANIFEST_MANIFEST_MISSING,
'Manifest(%s, %s) path missing' % (self._service, self._manifest))
if not self.__skipActivation:
activateThread = ActivateManifest(threadmgr.NULL_THREADMGR, self._service, self._manifest)
contextutils.copycontexts(self, activateThread, ctxNames)
activateThread.run()
status = activateThread.getStatus()
if (status['error'] != None):
raise AgentException(status['error'], status['errorMsg'])
# activte manifest if not already activated
if manifestutil.getActiveManifest(self._service) != self._manifest:
raise AgentException(Errors.ACTIVEMANIFEST_MANIFEST_MISSING,
'Manifest(%s, %s) path missing' % (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]
except AgentException as exc:
failed = True
errorMsg = 'Deploy Service - Agent Exception - %s' % exc.getMsg()
errorCode = exc.getCode()
except Exception as exc:
failed = True
errorMsg = 'Deploy Service - 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.warning(errorMsg)
self._updateStatus(httpStatus = 500, error = errorCode, errorMsg = errorMsg)
else:
self._updateProgress(100)
