def checkHostStates(self):
"""Check Host State deltas."""
# Checking all active host states and set to cancel only ones which deltas are in:
# for addition deltas - only removed state
# for reduction deltas - remove and removed
# ===========================================================================================
states = self.getHostStates('active')
for state in states:
if state['state'] != 'active':
continue
deltaInfo = self.getDeltaInfo(state['deltaid'])
if not deltaInfo:
self.logger.debug('FE did not return anything for %s' %
state['deltaid'])
continue
if deltaInfo[0]['state'] in [
'remove', 'removed'
] and deltaInfo[0]['deltat'] in ['addition', 'modify']:
self.cancelResources(
evaldict(deltaInfo[0]['addition'])[0], state['deltaid'])
self.setHostState('cancel', state['deltaid'])
elif deltaInfo[0]['state'] in [
'remove', 'removed'
] and deltaInfo[0]['deltat'] == 'reduction':
self.cancelResources(
evaldict(deltaInfo[0]['reduction'])[0], state['deltaid'])
self.setHostState('cancel', state['deltaid'])
elif deltaInfo[0]['state'] in [
'activated'
] and deltaInfo[0]['deltat'] == 'reduction':
self.setHostState('activated', state['deltaid'])
def _deltaAddition(self, dbObj, delta, mainGraphName, updateState=True):
"""Delta addition lookup."""
delta['content'] = evaldict(delta['content'])
self.logger.info('Working on %s delta addition in state' %
delta['uid'])
mainGraph = Graph()
mainGraph.parse(mainGraphName, format='turtle')
addition = delta['content']['addition']
tmpFile = tempfile.NamedTemporaryFile(delete=False, mode="w+")
tmpFile.write(addition)
tmpFile.close()
tmpGraph = Graph()
tmpGraph.parse(tmpFile.name, format='turtle')
os.unlink(tmpFile.name)
self.logger.info('Main Graph len: %s Addition Len: %s', len(mainGraph),
len(tmpGraph))
mainGraph += tmpGraph
# Add delta states for that specific delta
mainGraph = self._addDeltaStatesInModel(mainGraph, delta['state'],
evaldict(delta['addition']))
if updateState:
dbObj.update('deltasmod', [{
'uid': delta['uid'],
'updatedate': getUTCnow(),
'modadd': 'added'
}])
return mainGraph
def getData(self, url):
""" Get data from FE """
self.logger.info('Query: %s%s' % (self.fullURL, url))
out = getDataFromSiteFE({}, self.fullURL, url)
if out[2] != 'OK':
msg = 'Received a failure getting information from Site Frontend %s' % str(out)
self.logger.critical(msg)
return {}
if self.debug:
self.pretty.pprint(evaldict(out[0]))
self.logger.info('End function checkdeltas')
return evaldict(out[0])
def getData(self, url):
"""Get data from FE."""
self.logger.info('Query: %s%s' % (self.fullURL, url))
out = getDataFromSiteFE({}, self.fullURL, url)
if out[2] != 'OK':
msg = 'Received a failure getting information from Site Frontend %s' % str(
out)
self.logger.critical(msg)
return {}
if self.config.getboolean('general', "debug"):
pretty = pprint.PrettyPrinter(indent=4)
self.logger.debug(pretty.pprint(evaldict(out[0])))
return evaldict(out[0])
def committed(self, dbObj):
"""Committing state Check."""
for delta in dbObj.get('deltas', search=[['state', 'committed']]):
if delta['deltat'] in ['addition', 'modify'] and delta['addition']:
delta['addition'] = evaldict(delta['addition'])
# Check the times...
delayStart = False
for connDelta in delta['addition']:
try:
if 'timestart' in list(connDelta.keys()):
timeleft = int(
connDelta['timestart']) - getUTCnow()
self.logger.info(
'CurrentTime %s TimeStart %s. Seconds Left %s'
% (getUTCnow(), connDelta['timestart'],
timeleft))
if connDelta['timestart'] < getUTCnow():
self.logger.info(
'This delta already passed timestart mark. \
Setting state to activating')
delayStart = not delayStart
else:
self.logger.info(
'This delta %s did not passed timestart mark. \
Leaving state as it is' %
delta['uid'])
delayStart = True
except:
self.logger.info(
'This delta %s had an error checking starttime. \
Leaving state as it is.' %
delta['uid'])
if not delayStart:
self._stateChangerDelta(dbObj, 'activating', **delta)
self.connMgr.activating(dbObj, delta)
else:
self.logger.info(
'This delta %s is in committed. Setting state to activating.'
% delta['uid'])
self._stateChangerDelta(dbObj, 'activating', **delta)
if delta['deltat'] in ['reduction']:
for connid in evaldict(delta['connectionid']):
for dConn in dbObj.get(
'delta_connections',
search=[['connectionid', connid]]):
self.logger.info(
'This connection %s belongs to this delta: %s. Cancel delta'
% (connid, dConn['deltaid']))
deltaRem = {'uid': dConn['deltaid']}
self._stateChangerDelta(dbObj, 'remove',
**deltaRem)
def startwork(config=None, logger=None):
"""Main start """
errors = []
agents = getDataFromSiteFE({}, "http://localhost/",
"/sitefe/json/frontend/getdata")
if agents[2] != 'OK':
print 'Received a failure getting information from Site Frontend %s' % str(
agents)
return
workDir = CONFIG.get('frontend', 'privatedir') + "/notificationService/"
mailingSender = CONFIG.get('NotificationService', 'mailingSender')
mailingList = CONFIG.get('NotificationService', 'mailingList').split(',')
createDirs(workDir)
jOut = {}
try:
jOut = evaldict(agents[0])
except FailedToParseError as ex:
print 'Server returned not a json loadable object. Raising error. Output %s. Errors: %s' % (
str(agents), ex)
return
# We start with simple error messages
for ipaddr, values in jOut.items():
# Check if there is any error first
checkPluginErrors(ipaddr, values, errors)
checkCertLifeTime(ipaddr, values, errors)
warningsFromMonComponent(ipaddr, values, errors)
# Compare errors with previous run and send email only if there is something new...
lastErrors = readFile(str(workDir + "lastRunErrors.json"))
if lastErrors:
try:
lastErrors = evaldict(lastErrors[0])
except FailedToParseError as ex:
print 'Loaded object from the system is not evaluable. Raising error. \
Output %s. Errors: %s' % (str(lastErrors), ex)
print 'Ignoring and continue as there was no errors before'
lastErrors = []
newErrors = []
if lastErrors and errors:
newErrors = compareErrors(lastErrors, errors)
elif errors:
# Means there is no previous errors.
print errors
elif lastErrors and not errors:
print 'All errors were resolved...'
print lastErrors, errors, newErrors
if newErrors:
prepareMailSend(newErrors, mailingSender, mailingList)
writeNewFile(errors, workDir)
return
def activating(self, dbObj):
"""Check on all deltas in state activating."""
for delta in dbObj.get('deltas', search=[['state', 'activating']]):
hostStates = {}
delta['addition'] = evaldict(delta['addition'])
delta['reduction'] = evaldict(delta['reduction'])
for actionKey in ['reduction', 'addition']:
if actionKey not in list(delta.keys()):
self.logger.info(
'This delta %s does not have yet actionKey %s defined.'
% (delta['uid'], actionKey))
continue
if not isinstance(delta[actionKey], list):
self.logger.info(
'This delta %s does not have yet actionKey defined.' %
delta['uid'])
continue
for connDelta in delta[actionKey]:
hostStates = {}
if 'hosts' not in list(connDelta.keys()):
self.logger.info(
'This delta %s does not have yet hosts defined.' %
delta['uid'])
continue
for hostname in list(connDelta['hosts'].keys()):
host = dbObj.get('hoststates',
search=[['deltaid', delta['uid']],
['hostname', hostname]])
if host:
hostStates[host[0]['state']] = hostname
else:
self._newhoststate(
dbObj, **{
'hostname': hostname,
'state': 'activating',
'deltaid': delta['uid']
})
hostStates['unset'] = hostname
self.logger.info('Delta %s host states are: %s' %
(delta['uid'], hostStates))
if timeendcheck(delta, self.logger):
self._stateChangerDelta(dbObj, 'cancel', **delta)
self.modelstatecancel(dbObj, **delta)
if list(hostStates.keys()) == ['active']:
self._stateChangerDelta(dbObj, 'activated', **delta)
self.connMgr.activated(dbObj, delta)
elif 'failed' in list(hostStates.keys()):
self._stateChangerDelta(dbObj, 'failed', **delta)
def start(self):
"""Start execution and get new requests from FE."""
allWork = self.getAllAssignedtoHost()
out, err, exitCode = "", "", 0
for item in allWork:
self.logger.debug("Work on: %s" % item)
try:
item['requestdict'] = evaldict(item['requestdict'])
if item['requestdict']['type'] == 'rapidping':
out, err, exitCode = rapidping(item['requestdict'])
elif item['requestdict']['type'] == 'tcpdump':
out, err, exitCode = tcpdump(item['requestdict'])
elif item['requestdict']['type'] == 'arptable':
out, err, exitCode = arptable(item['requestdict'])
elif item['requestdict']['type'] == 'iperf':
out, err, exitCode = iperf(item['requestdict'])
elif item['requestdict']['type'] == 'iperfserver':
out, err, exitCode = iperfserver(item['requestdict'])
else:
err = "Unknown Request"
exitCode = 500
except:
err = traceback.format_exc()
exitCode = 501
output = {'out': out, 'err': err, 'exitCode': exitCode}
item['output'] = json.dumps(output)
if exitCode != 0:
item['state'] = 'failed'
else:
item['state'] = 'finished'
self.logger.debug("Finish work on: %s" % item)
self.publishToFE(item)
def modify(self, deltaInfo, state, informFE=True):
"""Modify of resources."""
# TODO: For now - this is very basic modify. Tier down what reduction told us to do
# And do addition for new resources. In future we should check if it is same vlan
# or what are the changes. Possible changes I can think of now are:
# Change routes;
# Change IP;
# Change VLAN - this will require to tier down and bring new interface;
# Change QoS
# First we try to identify which delta must be set into state remove
# This means that with a new state modify - agents can also change delta states
# while it was not possible before and was always done at FE Level.
reduct = evaldict(deltaInfo[0]['reduction'])
allProvisioned = self.vlansProvisioned()
for item in allProvisioned:
if item['connectionID'] == reduct[0]['connectionID']:
# Means vlan is still present; do remove in FE
# And return False, no further actions until previous delta removed
# TODO: Later it will do smarter things depending on action:
# Idea will be:
# if same vlan, remove file, set delta state remove and host state - removed and apply changes
# if diff vlan, set only delta state to remove, and wait for tier down of resources
self.logger.info(
'Main delta based on conn ID is still active. Setting it to Remove state'
)
self.setHostState('remove', item['uid'])
return
self.addition(deltaInfo, state)
def checkConflicts(dbObj, delta):
"""Check conflicting resources and not allow them"""
delta['addition'] = evaldict(delta['addition'])
for connDelta in delta['addition']:
deltaIN = getdeltaInfo(connDelta, delta)
checkNewDelta(deltaIN)
for state in ['committing', 'committed', 'activating', 'activated']:
for deltat in ['addition', 'modify']:
for dbdelta in dbObj.get('deltas',
search=[['state', state],
['deltat', deltat]]):
print(dbdelta)
dbdelta['addition'] = evaldict(dbdelta['addition'])
for connDelta1 in dbdelta['addition']:
deltaInDB = getdeltaInfo(connDelta1, delta)
compareTwoDeltaTimes(deltaInDB, deltaIN)
def checkAllFiles(self):
"""Check All deltas active on the host."""
self.logger.info('Started function checkAllFiles start')
for fileName in glob.glob("%s/*.json" % self.workDir):
inputDict = getFileContentAsJson(fileName)
if 'uid' not in inputDict.keys():
self.logger.info(
'Seems this dictionary is custom delta. Ignoring it.')
continue
deltaInfo = self.getDeltaInfo(inputDict['uid'])
if not deltaInfo:
self.logger.debug('FE did not return anything for %s' %
inputDict['uid'])
continue
if deltaInfo[0]['state'] in [
'remove', 'removing', 'removed', 'cancel', 'failed'
]:
if os.path.isfile(fileName):
os.remove(fileName)
elif deltaInfo[0]['state'] in [
'activating', 'activated'
] and deltaInfo[0]['deltat'] in ['addition', 'modify']:
deltaInfo[0]['addition'] = evaldict(deltaInfo[0]['addition'])
self.checkResources(deltaInfo[0]['addition'][0],
inputDict['uid'])
else:
self.logger.warning("Delta is unknown: %s" % deltaInfo)
def startwork(config=None, logger=None):
"""Main start """
fullURL = getFullUrl(config)
agents = getDataFromSiteFE({}, fullURL, "/sitefe/json/frontend/ips")
if agents[2] != 'OK':
print 'Received a failure getting information from Site Frontend %s' % str(
agents)
return
workDir = config.get('frontend', 'privatedir') + "/forwardingService/"
createDirs(workDir)
copy2("/etc/httpd/conf.d/sitefe-httpd.conf",
str(workDir + "httpd-copy.conf"))
httpdCopy = readFile(str(workDir + "httpd-copy.conf"))
try:
newDict = evaldict(agents[0])
except FailedToParseError as ex:
print 'Server returned not a json loadable object. Raising error. Output %s. Errors: %s' % (
str(agents), ex)
return
if not newDict:
print 'Seems server returned empty dictionary. Exiting.'
return
newOut, changed = prepareNewHTTPDConfig(newDict, httpdCopy)
if changed:
writeNewConfig(newOut, workDir)
copy2(str(workDir + "httpd-new.conf"),
"/etc/httpd/conf.d/sitefe-httpd.conf")
stdout = externalCommand("service httpd restart")
print stdout
# Restart apache...
return
def reduction(self, deltaInfo, state, informFE=True):
"""Reduction of resouces."""
deltaInfo[0]['reduction'] = evaldict(deltaInfo[0]['reduction'])
for connDelta in deltaInfo[0]['reduction']:
self.cancelResources(connDelta, state['deltaid'])
if informFE:
self.setHostState('active', state['deltaid'])
return True
def getdeltaAll(sitename):
dbI = getDBConn('listalldeltas')
dbobj = getVal(dbI, sitename=sitename)
for delta in dbobj.get('deltas'):
delta['addition'] = evaldict(delta['addition'])
delta['reduction'] = evaldict(delta['reduction'])
print '='*80
print 'Delta UID : ', delta['uid']
print 'Delta RedID: ', delta['reductionid']
print 'Delta State: ', delta['state']
print 'Delta ModAdd: ', delta['modadd']
print 'Delta InsDate:', delta['insertdate']
print 'Delta Update: ', delta['updatedate']
print 'Delta Model: ', delta['modelid']
print 'Delta connID: ', delta['connectionid']
print 'Delta Deltatype: ', delta['deltat']
print '-'*20
print 'Delta times'
for deltatimes in dbobj.get('states', search=[['deltaid', delta['uid']]]):
print 'State: %s Date: %s' % (deltatimes['state'], deltatimes['insertdate'])
if delta['deltat'] not in ['reduction', 'addition']:
print 'SOMETHING WRONG WITH THIS DELTA. It does not have any type defined. Was not parsed properly'
continue
if not isinstance(delta[delta['deltat']], list):
conns = [delta[delta['deltat']]]
else:
conns = delta[delta['deltat']]
for conn in conns:
if 'hosts' not in conn.keys():
print 'SOMETHING WRONG WITH THIS DELTA. It does not have any hosts defined.'
continue
for hostname in conn['hosts'].keys():
print '-'*20
print 'Host States %s' % hostname
for hoststate in dbobj.get('hoststates', search=[['deltaid', delta['uid']], ['hostname', hostname]]):
print 'Host %s State %s' % (hostname, hoststate['state'])
print 'Insertdate %s UpdateDate %s' % (hoststate['insertdate'], hoststate['updatedate'])
print '-'*20
print 'Host State History'
for hstatehistory in dbobj.get('hoststateshistory', search=[['deltaid', delta['uid']], ['hostname', hostname]]):
print 'State: %s, Date: %s' % (hstatehistory['state'], hstatehistory['insertdate'])
print '-'*20
print 'Connection details'
for conn in conns:
for dConn in dbobj.get('delta_connections', search=[['connectionid', conn['connectionID']]]):
print dConn
def getData(self, fullURL, URLPath):
""" Get data from FE """
agents = getDataFromSiteFE({}, fullURL, URLPath)
if agents[2] != 'OK':
msg = 'Received a failure getting information from Site Frontend %s' % str(
agents)
self.logger.debug(msg)
return {}
return evaldict(agents[0])
def nodeinfo(self):
"""put all node information from node reported stats."""
for _, nodeDict in list(self.nodesInfo.items()):
hostinfo = evaldict(nodeDict['hostinfo'])
for intfKey, intfDict in list(
hostinfo['NetInfo']["interfaces"].items()):
breakLoop = False
for key in [
'switch_port', 'switch', 'vlan_range',
'available_bandwidth'
]:
if key not in list(intfDict.keys()):
breakLoop = True
if breakLoop:
continue
if intfDict['switch'] in list(self.output['switches'].keys()):
if intfDict['switch_port'] not in list(
self.output['switches'][
intfDict['switch']].keys()):
self.logger.debug(
'Frontend Config is not configured to use this Port %s',
intfDict['switch_port'])
continue
switch = intfDict['switch']
switchp = intfDict['switch_port']
self.output['switches'][switch][switchp] = nodeDict[
'hostname']
self.output['vlans'][switch][switchp] = {}
self.output['vlans'][switch][switchp]['destport'] = intfKey
self.output['vlans'][switch][switchp][
'hostname'] = nodeDict['hostname']
self.output['vlans'][switch][switchp][
'desttype'] = 'server'
self.output['vlans'][switch][switchp][
'vlan_range'] = intfDict['vlan_range']
self.output['vlans'][switch][switchp][
'capacity'] = intfDict['available_bandwidth']
if 'isAlias' in list(intfDict.keys()):
self.output['vlans'][switch][switchp][
'isAlias'] = intfDict['isAlias']
if self.config.has_option(self.site, "l3_routing_map"):
routingMap = self.config.get(self.site, "l3_routing_map")
self.output['l3_routing'] = evaldict(routingMap)
def activating(dbObj, delta):
"""Change specific delta connection id state to commited."""
if delta['deltat'] in ['addition', 'modify']:
for connid in evaldict(delta['connectionid']):
dbOut = {
'deltaid': delta['uid'],
'connectionid': connid,
'state': 'activating'
}
dbObj.update('delta_connections', [dbOut])
def activating(self, dbObj):
""" Check on all deltas in state activating. """
for delta in dbObj.get('deltas', search=[['state', 'activating']]):
delta['addition'] = evaldict(delta['addition'])
delta['reduction'] = evaldict(delta['reduction'])
for actionKey in ['reduction', 'addition']:
if delta[actionKey].keys() and delta['deltat'] == 'addition':
hostStates = {}
for hostname in delta[actionKey]['hosts'].keys():
host = dbObj.get('hoststates',
search=[['deltaid', delta['uid']],
['hostname', hostname]])
if host:
hostStates[host[0]['state']] = hostname
else:
self._newhoststate(
dbObj, **{
'hostname': hostname,
'state': 'activating',
'deltaid': delta['uid']
})
hostStates['unset'] = hostname
if actionKey == 'reduction' and delta['deltat'] == 'reduction':
tmpID = delta['reductionid']
self.logger.info('Reduction for %s....' % tmpID)
for delta1 in dbObj.get('deltas',
search=[['uid', tmpID]],
limit=1):
currentState = delta1["state"]
if currentState not in [
'removing', 'remove', 'cancel'
]:
self._stateChangerDelta(dbObj, 'removing',
**delta1)
self._stateChangerDelta(dbObj, 'activated', **delta)
elif actionKey == 'addition' and delta['deltat'] == 'addition':
if timeendcheck(delta, self.logger):
self._stateChangerDelta(dbObj, 'cancel', **delta)
self.modelstatecancel(dbObj, **delta)
if hostStates.keys() == ['active']:
self._stateChangerDelta(dbObj, 'activated', **delta)
elif 'failed' in hostStates.keys():
self._stateChangerDelta(dbObj, 'failed', **delta)
def committed(dbObj, delta):
""" Change specific delta connection id state to commited """
if delta['deltat'] == 'addition':
for connid in evaldict(delta['connectionid']):
dbOut = {
'deltaid': delta['uid'],
'connectionid': connid,
'state': 'committed'
}
dbObj.update('delta_connections', [dbOut])
return
def accepted(dbObj, delta):
""" If delta addition and accepted - add connection entry in DB """
if delta['deltat'] in ['addition', 'modify'] and delta['state'] in [
'accepting', 'accepted'
]:
for connid in evaldict(delta['connectionid']):
dbOut = {
'deltaid': delta['uid'],
'connectionid': connid,
'state': 'accepted'
}
dbObj.insert('delta_connections', [dbOut])
def startwork(self):
"""Start Provisioning Service main worker."""
fullURL = getFullUrl(self.config, sitename=self.sitename)
jOut = self.getData(fullURL, "/sitefe/json/frontend/getdata")
workDir = self.config.get('general',
'privatedir') + "/ProvisioningService/"
createDirs(workDir)
if not jOut:
self.logger.info(
'Seems server returned empty dictionary. Exiting.')
return
# Get switch information...
switchPlugin = self.config.get(self.sitename, 'plugin')
self.logger.info('Will load %s switch plugin' % switchPlugin)
method = importlib.import_module(
"SiteFE.ProvisioningService.Plugins.%s" % switchPlugin.lower())
switchruler = method.mainCaller()
topology = method.topology()
switches = topology.getTopology()
alliases = self.getAllAliases(switches)
outputDict = {}
allDeltas = self.getData(fullURL, "/sitefe/v1/deltas?oldview=true")
for switchName in list(list(switches['switches'].keys()) + alliases):
newDeltas = self.checkdeltas(switchName, allDeltas)
for newDelta in newDeltas:
outputDict.setdefault(newDelta['ID'])
for actionKey in ['reduction', 'addition']:
try:
newvlan = self.getnewvlan(newDelta, newDelta['ID'],
switchName, actionKey)
if actionKey == 'reduction' and newDelta[
'ParsedDelta'][actionKey]:
self.deltaRemoval(newDelta, newDelta['ID'],
newvlan, switchName, switchruler,
fullURL)
elif actionKey == 'addition' and newDelta[
'ParsedDelta'][actionKey]:
if newDelta['State'] in ['cancel']:
newDelta['ReductionID'] = newDelta['ID']
self.deltaRemoval(newDelta, newDelta['ID'],
newvlan, switchName,
switchruler, fullURL)
else:
self.deltaCommit(newDelta, newDelta['ID'],
newvlan, switchName,
switchruler, fullURL)
else:
self.logger.warning('Unknown delta state')
pretty = pprint.PrettyPrinter(indent=4)
pretty.pprint(evaldict(newDelta))
except IOError as ex:
print(ex)
raise Exception('Received IOError')
def getdeltainfo(sitename, deltaUID):
"""Get all delta information.
INPUT: sitename - str mandatory
deltaUID - str mandatory
"""
dbI = getDBConn('acceptdelta')
dbobj = getVal(dbI, sitename=sitename)
for delta in dbobj.get('deltas'):
if delta['uid'] != deltaUID:
continue
delta['addition'] = evaldict(delta['addition'])
delta['reduction'] = evaldict(delta['reduction'])
LOGGER.info('=' * 80)
LOGGER.info('Delta UID : %s', delta['uid'])
LOGGER.info('Delta RedID: %s', delta['reductionid'])
LOGGER.info('Delta State: %s', delta['state'])
LOGGER.info('Delta ModAdd: %s', delta['modadd'])
LOGGER.info('Delta InsDate: %s', delta['insertdate'])
LOGGER.info('Delta Update: %s', delta['updatedate'])
LOGGER.info('Delta Model: %s', delta['modelid'])
LOGGER.info('Delta connID: %s', delta['connectionid'])
LOGGER.info('Delta Deltatype: %s', delta['deltat'])
LOGGER.info('-' * 20)
LOGGER.info('Delta times')
for deltatimes in dbobj.get('states', search=[['deltaid', delta['uid']]]):
LOGGER.info('State: %s Date: %s', deltatimes['state'], deltatimes['insertdate'])
if delta['deltat'] in ['reduction', 'addition']:
for hostname in list(delta[delta['deltat']]['hosts'].keys()):
LOGGER.info('-' * 20)
LOGGER.info('Host States %s', hostname)
for hoststate in dbobj.get('hoststates', search=[['deltaid', delta['uid']], ['hostname', hostname]]):
LOGGER.info('Host %s State %s', hostname, hoststate['state'])
LOGGER.info('Insertdate %s UpdateDate %s', hoststate['insertdate'], hoststate['updatedate'])
LOGGER.info('-' * 20)
LOGGER.info('Host State History')
for hstatehistory in dbobj.get('hoststateshistory',
search=[['deltaid', delta['uid']], ['hostname', hostname]]):
LOGGER.info('State: %s, Date: %s', hstatehistory['state'], hstatehistory['insertdate'])
return delta, dbobj
def activated(self, dbObj):
"""Check on all activated state deltas."""
for delta in dbObj.get('deltas', search=[['state', 'activated']]):
# Reduction
if delta['deltat'] in ['reduction']:
if delta['updatedate'] < int(getUTCnow() - 600):
self._stateChangerDelta(dbObj, 'removing', **delta)
continue
# Addition
delta['addition'] = evaldict(delta['addition'])
if timeendcheck(delta, self.logger):
self._stateChangerDelta(dbObj, 'cancel', **delta)
self.modelstatecancel(dbObj, **delta)
def activated(dbObj, delta):
""" Change specific delta connection id state to activated. Reduction - cancelled """
if delta['deltat'] == 'addition':
for connid in evaldict(delta['connectionid']):
dbOut = {
'deltaid': delta['uid'],
'connectionid': connid,
'state': 'activated'
}
dbObj.update('delta_connections', [dbOut])
elif delta['deltat'] == 'reduction':
for connid in evaldict(delta['connectionid']):
for dConn in dbObj.get('delta_connections',
search=[['connectionid', connid],
['state', 'activated']]):
dbOut = {
'deltaid': dConn['deltaid'],
'connectionid': dConn['connectionid'],
'state': 'cancelled'
}
dbObj.update('delta_connections', [dbOut])
return
def pushInternalAction(self, url, state, deltaID, hostname):
""" Push Internal action and return dict """
newState = ""
restOut = {}
restOut = getDataFromSiteFE(
{}, url, "/sitefe/v1/deltas/%s/internalaction/%s/%s" %
(deltaID, hostname, state))
if restOut[1] >= 400:
msg = "Failed to set new state in database for %s delta and %s hostname. Error %s " \
% (deltaID, hostname, restOut)
self.logger.debug(msg)
raise FailedInterfaceCommand(msg)
restOutHIDs = getDataFromSiteFE({}, url,
"/sitefe/v1/hostnameids/%s" % hostname)
tmpOut = evaldict(restOutHIDs[0])
newState = tmpOut[deltaID]
msg = 'New State on the rest is %s and requested %s' % (newState,
state)
self.logger.debug(msg)
if newState != state:
time.sleep(4)
return evaldict(restOut)
def checkActivatingDeltas(self):
""" Check all deltas in activating states """
states = self.getHostStates('activating')
for state in states:
# Check delta State;
deltaInfo = self.getDeltaInfo(state['deltaid'])
if not deltaInfo:
self.logger.debug('FE did not return anything for %s' %
state['deltaid'])
continue
if deltaInfo[0]['deltat'] == 'reduction':
deltaInfo[0]['reduction'] = evaldict(deltaInfo[0]['reduction'])
for connDelta in deltaInfo[0]['reduction']:
self.cancelResources(connDelta, state['deltaid'])
self.setHostState('active', state['deltaid'])
elif deltaInfo[0]['deltat'] == 'addition':
deltaInfo[0]['addition'] = evaldict(deltaInfo[0]['addition'])
if deltaInfo[0]['state'] in ['activating', 'activated']:
self.logger.info('Activating delta %s' % state['deltaid'])
if not deltaInfo[0]['addition']:
self.logger.info(
'Failing delta %s. No addition parsed' %
state['deltaid'])
self.logger.info(deltaInfo[0])
# self.setHostState('failed', state['deltaid'])
continue
outExit = False
for connDelta in deltaInfo[0]['addition']:
outExit, message = self.activateResources(
connDelta, state['deltaid'])
self.logger.info("Exit: %s, Message: %s" %
(outExit, message))
if outExit:
self.setHostState('active', state['deltaid'])
else:
# TODO. Have ability to save message in Frontend.
self.setHostState('failed', state['deltaid'])
def get_json_post_form(environ):
try:
request_body_size = int(environ.get('CONTENT_LENGTH', 0))
except ValueError:
request_body_size = 0
request_body = environ['wsgi.input'].read(request_body_size)
try:
params = json.loads(request_body)
except:
print 'Reached except in data load'
params = evaldict(request_body)
if not isinstance(params, dict):
params = json.loads(params)
environ.setdefault('params', {})
for key in params.keys():
environ['params'][key] = params[key]
return environ['params']
def _deltaReduction(self, dbObj, delta, mainGraphName):
""" Delta reduction """
delta['content'] = evaldict(delta['content'])
self.logger.info('Working on %s delta reduction in state' % delta['uid'])
mainGraph = Graph()
mainGraph.parse(mainGraphName, format='turtle')
reduction = delta['content']['reduction']
tmpFile = tempfile.NamedTemporaryFile(delete=False)
tmpFile.write(reduction)
tmpFile.close()
tmpGraph = Graph()
tmpGraph.parse(tmpFile.name, format='turtle')
os.unlink(tmpFile.name)
self.logger.info('Main Graph len: %s Reduction Len: %s', len(mainGraph), len(tmpGraph))
mainGraph -= tmpGraph
dbObj.update('deltasmod', [{'uid': delta['uid'], 'updatedate': getUTCnow(), 'modadd': 'removed'}])
return mainGraph
def committed(self, dbObj):
""" Committing state Check """
for delta in dbObj.get('deltas', search=[['state', 'committed']]):
if delta['deltat'] == 'addition' and delta['addition']:
delta['addition'] = evaldict(delta['addition'])
# Check the times...
delayStart = False
for connDelta in delta['addition']:
try:
if 'timestart' in connDelta.keys():
timeleft = int(
connDelta['timestart']) - getUTCnow()
self.logger.info(
'CurrentTime %s TimeStart %s. Seconds Left %s'
% (getUTCnow(), connDelta['timestart'],
timeleft))
if connDelta['timestart'] < getUTCnow():
self.logger.info(
'This delta already passed timestart mark. \
Setting state to activating')
delayStart = False if delayStart is not True else True
else:
self.logger.info(
'This delta %s did not passed timestart mark. \
Leaving state as it is' %
delta['uid'])
delayStart = True
except:
self.logger.info(
'This delta %s had an error checking starttime. \
Leaving state as it is.' %
delta['uid'])
if not delayStart:
self._stateChangerDelta(dbObj, 'activating', **delta)
self.connMgr.activating(dbObj, delta)
else:
self.logger.info(
'This delta %s is in committed. Setting state to activating.'
% delta['uid'])
self._stateChangerDelta(dbObj, 'activating', **delta)
def addition(self, deltaInfo, state, informFE=True):
"""Addition of resources."""
retState = True
deltaInfo[0]['addition'] = evaldict(deltaInfo[0]['addition'])
if deltaInfo[0]['state'] in ['activating', 'activated']:
self.logger.info('Activating delta %s' % state['deltaid'])
if not deltaInfo[0]['addition']:
self.logger.info('Failing delta %s. No addition parsed' %
state['deltaid'])
self.logger.info(deltaInfo[0])
return retState
outExit = False
for connDelta in deltaInfo[0]['addition']:
outExit, message = self.activateResources(
connDelta, state['deltaid'])
self.logger.info("Exit: %s, Message: %s" % (outExit, message))
saveState = 'active' if outExit else 'failed'
if not outExit:
retState = False
# TODO: Have ability to save message in the Frontend;
if informFE:
self.setHostState(saveState, state['deltaid'])
return retState
