def checkOsManagerRelated(self):
osManager = self.userServiceInstance.osmanager()
state = State.USABLE
# and make this usable if os manager says that it is usable, else it pass to configuring state
# This is an "early check" for os manager, so if we do not have os manager, or os manager
# already notifies "ready" for this, we
if osManager is not None and State.isPreparing(self.userService.os_state):
logger.debug('Has valid osmanager for {}'.format(self.userService.friendly_name))
stateOs = osManager.checkState(self.userService)
else:
stateOs = State.FINISHED
logger.debug('State {}, StateOS {} for {}'.format(State.toString(state), State.toString(stateOs), self.userService.friendly_name))
if stateOs == State.RUNNING:
self.userService.setOsState(State.PREPARING)
else:
# If state is finish, we need to notify the userService again that os has finished
# This will return a new task state, and that one will be the one taken into account
self.userService.setOsState(State.USABLE)
rs = self.userServiceInstance.notifyReadyFromOsManager('')
if rs != State.FINISHED:
self.checkLater()
state = self.userService.state # No not alter current state if after notifying os manager the user service keeps working
else:
self.logIp()
return state
def checkOsManagerRelated(self):
osManager = self.userServiceInstance.osmanager()
state = State.USABLE
# and make this usable if os manager says that it is usable, else it pass to configuring state
# This is an "early check" for os manager, so if we do not have os manager, or os manager
# already notifies "ready" for this, we
if osManager is not None and State.isPreparing(
self.userService.os_state):
logger.debug('Has valid osmanager for {}'.format(
self.userService.friendly_name))
stateOs = osManager.checkState(self.userService)
else:
stateOs = State.FINISHED
logger.debug('State {}, StateOS {} for {}'.format(
State.toString(state), State.toString(stateOs),
self.userService.friendly_name))
if stateOs == State.RUNNING:
self.userService.setOsState(State.PREPARING)
else:
# If state is finish, we need to notify the userService again that os has finished
# This will return a new task state, and that one will be the one taken into account
self.userService.setOsState(State.USABLE)
rs = self.userServiceInstance.notifyReadyFromOsManager('')
if rs != State.FINISHED:
self.checkLater()
state = self.userService.state # No not alter current state if after notifying os manager the user service keeps working
else:
self.logIp()
return state
def checkAndUpdateState(userService, userServiceInstance, state):
'''
Checks the value returned from invocation to publish or checkPublishingState, updating the servicePoolPub database object
Return True if it has to continue checking, False if finished
'''
try:
prevState = userService.state
userService.unique_id = userServiceInstance.getUniqueId() # Updates uniqueId
userService.friendly_name = userServiceInstance.getName() # And name, both methods can modify serviceInstance, so we save it later
if State.isFinished(state):
checkLater = False
userServiceInstance.finish()
if State.isPreparing(prevState):
if userServiceInstance.service().publicationType is None or userService.publication == userService.deployed_service.activePublication():
userService.setState(State.USABLE)
# and make this usable if os manager says that it is usable, else it pass to configuring state
if userServiceInstance.osmanager() is not None and userService.os_state == State.PREPARING: # If state is already "Usable", do not recheck it
stateOs = userServiceInstance.osmanager().checkState(userService)
# If state is finish, we need to notify the userService again that os has finished
if State.isFinished(stateOs):
state = userServiceInstance.notifyReadyFromOsManager('')
userService.updateData(userServiceInstance)
else:
stateOs = State.FINISHED
if State.isRuning(stateOs):
userService.setOsState(State.PREPARING)
else:
userService.setOsState(State.USABLE)
else:
# We ignore OsManager info and if userService don't belong to "current" publication, mark it as removable
userService.setState(State.REMOVABLE)
elif State.isRemoving(prevState):
if userServiceInstance.osmanager() is not None:
userServiceInstance.osmanager().release(userService)
userService.setState(State.REMOVED)
else:
# Canceled,
logger.debug("Canceled us {2}: {0}, {1}".format(prevState, State.toString(state), State.toString(userService)))
userService.setState(State.CANCELED)
userServiceInstance.osmanager().release(userService)
userService.updateData(userServiceInstance)
elif State.isErrored(state):
checkLater = False
userService.updateData(userServiceInstance)
userService.setState(State.ERROR)
else:
checkLater = True # The task is running
userService.updateData(userServiceInstance)
userService.save()
if checkLater:
UserServiceOpChecker.checkLater(userService, userServiceInstance)
except Exception as e:
logger.exception('Checking service state')
log.doLog(userService, log.ERROR, 'Exception: {0}'.format(e), log.INTERNAL)
userService.setState(State.ERROR)
userService.save()
def checkAndUpdateState(servicePoolPub, pi, state):
"""
Checks the value returned from invocation to publish or checkPublishingState, updating the servicePoolPub database object
Return True if it has to continue checking, False if finished
"""
try:
prevState = servicePoolPub.state
checkLater = False
if State.isFinished(state):
# Now we mark, if it exists, the previous usable publication as "Removable"
if State.isPreparing(prevState):
for old in servicePoolPub.deployed_service.publications.filter(
state=State.USABLE):
old.setstate(State.REMOVABLE)
osm = servicePoolPub.deployed_service.osmanager
# If os manager says "machine is persistent", do not tray to delete "previous version" assigned machines
doPublicationCleanup = True if osm is None else not osm.getInstance(
).isPersistent()
if doPublicationCleanup:
pc = PublicationOldMachinesCleaner(old.id)
pc.register(
GlobalConfig.SESSION_EXPIRE_TIME.getInt(True) *
3600, 'pclean-' + str(old.id), True)
servicePoolPub.setState(State.USABLE)
servicePoolPub.deployed_service.markOldUserServicesAsRemovables(
servicePoolPub)
elif State.isRemoving(prevState):
servicePoolPub.setState(State.REMOVED)
else: # State is canceling
servicePoolPub.setState(State.CANCELED)
# Mark all previous publications deployed services as removables
# and make this usable
pi.finish()
servicePoolPub.updateData(pi)
elif State.isErrored(state):
servicePoolPub.updateData(pi)
servicePoolPub.setState(State.ERROR)
else:
checkLater = True # The task is running
servicePoolPub.updateData(pi)
if checkLater:
PublicationFinishChecker.checkLater(servicePoolPub, pi)
except Exception:
logger.exception('At checkAndUpdate for publication')
PublicationFinishChecker.checkLater(servicePoolPub, pi)
def checkAndUpdateState(servicePoolPub, pi, state):
"""
Checks the value returned from invocation to publish or checkPublishingState, updating the servicePoolPub database object
Return True if it has to continue checking, False if finished
"""
try:
prevState = servicePoolPub.state
checkLater = False
if State.isFinished(state):
# Now we mark, if it exists, the previous usable publication as "Removable"
if State.isPreparing(prevState):
for old in servicePoolPub.deployed_service.publications.filter(state=State.USABLE):
old.state = State.REMOVABLE
old.save()
osm = servicePoolPub.deployed_service.osmanager
# If os manager says "machine is persistent", do not tray to delete "previous version" assigned machines
doPublicationCleanup = True if osm is None else not osm.getInstance().isPersistent()
if doPublicationCleanup:
pc = PublicationOldMachinesCleaner(old.id)
pc.register(GlobalConfig.SESSION_EXPIRE_TIME.getInt(True) * 3600, 'pclean-' + str(old.id), True)
servicePoolPub.setState(State.USABLE)
servicePoolPub.deployed_service.markOldUserServicesAsRemovables(servicePoolPub)
elif State.isRemoving(prevState):
servicePoolPub.setState(State.REMOVED)
else: # State is canceling
servicePoolPub.setState(State.CANCELED)
# Mark all previous publications deployed services as removables
# and make this usable
pi.finish()
servicePoolPub.updateData(pi)
elif State.isErrored(state):
servicePoolPub.updateData(pi)
servicePoolPub.state = State.ERROR
else:
checkLater = True # The task is running
servicePoolPub.updateData(pi)
servicePoolPub.save()
if checkLater:
PublicationFinishChecker.checkLater(servicePoolPub, pi)
except Exception:
logger.exception('At checkAndUpdate for publication')
PublicationFinishChecker.checkLater(servicePoolPub, pi)
def isPreparing(self):
"""
Returns if this service is in preparation (not ready to use, but in its way to be so...)
"""
return State.isPreparing(self.state)
def isPreparing(self):
'''
Returns if this service is in preparation (not ready to use, but in its way to be so...)
'''
return State.isPreparing(self.state)
def checkAndUpdateState(userService, userServiceInstance, state):
'''
Checks the value returned from invocation to publish or checkPublishingState, updating the servicePoolPub database object
Return True if it has to continue checking, False if finished
'''
try:
prevState = userService.state
userService.unique_id = userServiceInstance.getUniqueId(
) # Updates uniqueId
userService.friendly_name = userServiceInstance.getName(
) # And name, both methods can modify serviceInstance, so we save it later
if State.isFinished(state):
checkLater = False
userServiceInstance.finish()
if State.isPreparing(prevState):
if userServiceInstance.service(
).publicationType is None or userService.publication == userService.deployed_service.activePublication(
):
userService.setState(State.USABLE)
# and make this usable if os manager says that it is usable, else it pass to configuring state
if userServiceInstance.osmanager(
) is not None and userService.os_state == State.PREPARING: # If state is already "Usable", do not recheck it
stateOs = userServiceInstance.osmanager(
).checkState(userService)
# If state is finish, we need to notify the userService again that os has finished
if State.isFinished(stateOs):
state = userServiceInstance.notifyReadyFromOsManager(
'')
userService.updateData(userServiceInstance)
else:
stateOs = State.FINISHED
if State.isRuning(stateOs):
userService.setOsState(State.PREPARING)
else:
userService.setOsState(State.USABLE)
else:
# We ignore OsManager info and if userService don't belong to "current" publication, mark it as removable
userService.setState(State.REMOVABLE)
elif State.isRemoving(prevState):
if userServiceInstance.osmanager() is not None:
userServiceInstance.osmanager().release(userService)
userService.setState(State.REMOVED)
else:
# Canceled,
logger.debug("Canceled us {2}: {0}, {1}".format(
prevState, State.toString(state),
State.toString(userService)))
userService.setState(State.CANCELED)
userServiceInstance.osmanager().release(userService)
userService.updateData(userServiceInstance)
elif State.isErrored(state):
checkLater = False
userService.updateData(userServiceInstance)
userService.setState(State.ERROR)
else:
checkLater = True # The task is running
userService.updateData(userServiceInstance)
userService.save()
if checkLater:
UserServiceOpChecker.checkLater(userService,
userServiceInstance)
except Exception as e:
logger.exception('Checking service state')
log.doLog(userService, log.ERROR, 'Exception: {0}'.format(e),
log.INTERNAL)
userService.setState(State.ERROR)
userService.save()
