def recommender_get_ips():
topology = CIMI.get_topology()
agent_res, res_id = CIMI.getAgentResource()
if res_id != '' and 'device_ip' in agent_res:
self_device_ip = agent_res['device_ip']
else:
self_device_ip = None
response = [{'ipaddress': ip[1]} for ip in topology]
if self_device_ip is not None:
response.append({'ipaddress': self_device_ip})
LOG.debug('Recommender API response: \"{}\"'.format(response))
return jsonify(response), 200
def deleteBackupOnAgentResource(backupIP):
try:
agent_resource, agent_resource_id = CIMI.getAgentResource()
ar = AgentResource.load(agent_resource)
if ar.backupIP != backupIP:
LOG.warning(
'Backup [{}] does not match [{}] stored in Agent Resource'.
format(backupIP, ar.backupIP))
ar2 = AgentResource(None, None, None, None, None, backupIP='')
LOG.debug(
'Removing backup [{}] in Agent Resource. Updated agent resource: {}'
.format(backupIP, ar2.getCIMIdicc()))
CIMI.modify_resource(agent_resource_id, ar2.getCIMIdicc())
except:
LOG.exception('Add backup in Agent resource failed')
def cimi(key, default=None):
value = default
if key == 'leader':
value = CPARAMS.LEADER_FLAG
elif key == 'topology':
value = []
# 1. Try to get the real topology
cimi_topology = CIMI.get_topology()
if len(cimi_topology) > 0:
used_topology = cimi_topology
# used_topology = list()
# for item in cimi_topology: # TODO: Dataclay doesnt sync device static information to the leader
# qdeviceID = CIMI.get_deviceID_from_IP(item[1])
# if qdeviceID != '':
# used_topology.append((qdeviceID, item[1]))
else:
used_topology = CPARAMS.TOPOLOGY_FLAG
try:
for item in used_topology:
i = {'deviceID': item[0], 'deviceIP': item[1]}
value.append(i)
except:
LOG.exception(
'Topology Environment variable format is not correct.')
value = []
return value
def addBackupOnAgentResource(backupIP):
try:
agent_resource, agent_resource_id = CIMI.getAgentResource()
ar = AgentResource.load(agent_resource)
if ar.backupIP is not None or (ar.backupIP != ''
and ar.backupIP is not None):
LOG.warning(
'Non-empty backupIP value when adding a new backup! Agent resource: {}'
.format(ar.getCIMIdicc()))
ar2 = AgentResource(None,
None,
None,
None,
None,
backupIP='{}'.format(backupIP))
LOG.debug(
'Adding backup [{}] in Agent Resource. Updated agent resource: {}'.
format(backupIP, ar2.getCIMIdicc()))
CIMI.modify_resource(agent_resource_id, ar2.getCIMIdicc())
except:
LOG.exception('Add backup in Agent resource failed')
def __cloud_flow(self):
LOG.info(self.TAG + 'Cloud flow started.')
# 0. Cloud Agent is Leader by definition
self.imLeader = self.imCloud
# 1. Discovery
LOG.debug(self.TAG + 'Discovery trigger ignored in Cloud flow.')
self.discovery_failed = False
self.discovery_leader_failed = False
self.detectedLeaderID = self.deviceID
# 2. Start CAU-client
if self._connected:
self.cauclient_failed = True
LOG.debug(self.TAG + 'Sending trigger to CAU client...')
attempt = 0
r = False
while self._connected and not r and attempt < self.MAX_CAUCLIENT_FAILURES:
try:
r = self.__trigger_triggerCAUclient()
self.cauclient_failed = not r
except Exception:
LOG.exception(self.TAG + 'CAUclient failed.')
self.cauclient_failed = True
finally:
attempt += 1
if not r:
sleep(self.WAIT_TIME_CAUCLIENT)
LOG.info(self.TAG +
'CAU client Trigger Done in {} attempts and ok={}.'.
format(attempt, r))
else:
return
if not CPARAMS.DEBUG_FLAG and self.cauclient_failed:
LOG.critical(self.TAG +
'CAU-Client failed, interrupting agent start.')
return
# 3. VPN get IP
attempt = 0
while self._connected and self.vpnIP is None and attempt < self.MAX_VPN_FAILURES:
vpn_ip = VPN.getIPfromFile()
self.vpnIP = vpn_ip if vpn_ip != '' else None
if self.vpnIP is None:
LOG.debug(self.TAG +
'VPN IP cannot be obtained... Retry in {}s'.format(
self.WAIT_TIME_VPN))
sleep(self.WAIT_TIME_VPN)
attempt += 1
if self.vpnIP is None:
LOG.warning(self.TAG + 'VPN IP cannot be obtained.')
if not CPARAMS.DEBUG_FLAG:
LOG.critical(
self.TAG +
'Policies module cannot continue its activity without VPN IP'
)
exit(4)
else:
LOG.info(self.TAG + 'VPN IP: [{}]'.format(self.vpnIP))
# 4. Switch leader categorization (or start if not started)
if self._connected and not self.categorization_started:
self.categorization_failed = True
LOG.debug(self.TAG + 'Sending start trigger to Categorization...')
try:
self.__trigger_startCategorization()
self.categorization_failed = False
self.categorization_started = True
except Exception:
LOG.exception(self.TAG + 'Categorization failed')
self.categorization_failed = True
LOG.info(self.TAG + 'Categorization Start Trigger Done.')
elif not self._connected:
return
if not CPARAMS.DEBUG_FLAG and self.categorization_failed:
LOG.critical(self.TAG +
'Categorization failed, interrupting agent start.')
return
# 5. Area Resilience
LOG.debug(self.TAG + 'Area Resilience trigger ignored in Cloud flow.')
self.policies_failed = False
# Print summary
self.__print_summary()
# Create Agent Resource
self.deviceIP = self.vpnIP
self.leaderIP = None
self._cimi_agent_resource = AgentResource(self.deviceID, self.deviceIP,
True, True, self.imLeader)
LOG.debug(self.TAG + 'CIMI Agent Resource payload: {}'.format(
self._cimi_agent_resource.getCIMIdicc()))
if self._cimi_agent_resource_id is None:
# Create agent resource
self._cimi_agent_resource_id = CIMI.createAgentResource(
self._cimi_agent_resource.getCIMIdicc())
if self._cimi_agent_resource_id == '':
LOG.warning(self.TAG + 'Agent resource creation failed.')
if not CPARAMS.DEBUG_FLAG:
LOG.error(
'Stopping Policies module due to resource creation failure.'
)
exit(4)
else:
# Agent resource already exists
status = CIMI.modify_resource(
self._cimi_agent_resource_id,
self._cimi_agent_resource.getCIMIdicc())
self.isCompleted = True
return
def __leader_switch_flow(self):
"""
Agent become leader
:return:
"""
# 1. Start sending beacons
if self._connected:
self.discovery_leader_failed = True
self.discovery_failed = True
LOG.debug(self.TAG + 'Sending Broadcast trigger to discovery...')
try:
r = self.__trigger_switch_discovery()
self.detectedLeaderID = self.deviceID
self.discovery_leader_failed = not r
except Exception as ex:
LOG.exception(self.TAG + 'Discovery broadcast trigger failed!')
self.detectedLeaderID = self.deviceID
LOG.info(self.TAG + 'Discovery Broadcast Trigger Done.')
else:
return
if not CPARAMS.DEBUG_FLAG and self.discovery_leader_failed:
LOG.critical(
self.TAG +
'Discovery broadcast failed, interrupting leader switch.')
return
self.discovery_failed = self.discovery_leader_failed
# 2. Start CAU-client
if self._connected:
self.cauclient_failed = True
LOG.debug(self.TAG + 'Sending trigger to CAU client...')
attempt = 0
r = False
while self._connected and not r and attempt < self.MAX_CAUCLIENT_FAILURES:
try:
r = self.__trigger_triggerCAUclient()
self.cauclient_failed = not r
except Exception:
LOG.exception(self.TAG + 'CAUclient failed.')
self.cauclient_failed = True
finally:
attempt += 1
if not r:
sleep(self.WAIT_TIME_CAUCLIENT)
LOG.info(self.TAG +
'CAU client Trigger Done in {} attempts and ok={}.'.
format(attempt, r))
else:
return
if not CPARAMS.DEBUG_FLAG and self.cauclient_failed:
LOG.critical(self.TAG +
'CAU-Client failed, interrupting agent start.')
return
# 3. VPN get IP
attempt = 0
while self._connected and self.vpnIP is None and attempt < self.MAX_VPN_FAILURES:
vpn_ip = VPN.getIPfromFile()
self.vpnIP = vpn_ip if vpn_ip != '' else None
if self.vpnIP is None:
LOG.debug(self.TAG +
'VPN IP cannot be obtained... Retry in {}s'.format(
self.WAIT_TIME_VPN))
sleep(self.WAIT_TIME_VPN)
attempt += 1
if self.vpnIP is None:
LOG.warning(self.TAG + 'VPN IP cannot be obtained.')
if not CPARAMS.DEBUG_FLAG:
LOG.critical(
self.TAG +
'Policies module cannot continue its activity without VPN IP'
)
exit(4)
else:
LOG.info(self.TAG + 'VPN IP: [{}]'.format(self.vpnIP))
# 4. Switch leader categorization (or start if not started)
if self.categorization_started:
self.categorization_leader_failed = True
# Switch!
LOG.debug(self.TAG + 'Sending switch trigger to Categorization...')
try:
self.__trigger_switch_categorization()
self.categorization_leader_failed = False
except Exception:
LOG.exception(self.TAG +
'Categorization switch to leader failed')
LOG.info(self.TAG + 'Categorization Switch Trigger Done.')
else:
# Start as leader!
LOG.debug(self.TAG + 'Sending start trigger to Categorization...')
try:
self.__trigger_startCategorization()
self.categorization_leader_failed = False
self.categorization_started = True
except Exception:
LOG.exception(self.TAG + 'Categorization failed')
LOG.info(self.TAG + 'Categorization Start Trigger Done.')
if not CPARAMS.DEBUG_FLAG and self.categorization_leader_failed:
LOG.critical(self.TAG +
'Categorization failed, interrupting leader switch.')
return
self.categorization_failed = self.categorization_leader_failed
# 5. Start Area Resilience (if not started)
if not self.arearesilience_started:
self.policies_failed = True
LOG.debug(self.TAG + 'Sending start trigger to Policies...')
try:
self.__trigger_startLeaderProtectionPolicies()
self.policies_failed = False
self.arearesilience_started = True
except Exception:
LOG.exception(self.TAG + 'Policies Area Resilience failed!')
LOG.info(self.TAG + 'Policies Area Resilience Start Trigger Done.')
if not CPARAMS.DEBUG_FLAG and self.policies_failed:
LOG.critical(
self.TAG +
'Policies Area Resilience failed, interrupting agent start.')
return
# 8. Watch Leader
if self._connected and not self.discovery_failed:
LOG.debug(self.TAG + 'Start Discovery Leader Watch...')
try:
self.__trigger_startDiscoveryWatchLeader()
except Exception:
LOG.exception(self.TAG + 'Watch Discovery Start Fail.')
LOG.info(self.TAG + 'Watch Discovery Start Trigger Done.')
elif self.discovery_failed:
LOG.warning(
self.TAG +
'Discovery Watch cancelled due Discovery Trigger failed')
# Create/Modify Agent Resource
# IF static IP configuration setup
self.deviceIP = CPARAMS.DEVICE_IP_FLAG
self.leaderIP = CPARAMS.LEADER_IP_FLAG
if self.deviceIP is None or self.leaderIP is None:
LOG.debug(
self.TAG +
'No static configuration was detected. Applying VPN values')
self.deviceIP = self.vpnIP
self.leaderIP = self.cloudIP
LOG.info(
self.TAG +
'deviceIP={}, leaderIP={}'.format(self.deviceIP, self.leaderIP))
# Print summary
self.__print_summary()
self._cimi_agent_resource = AgentResource(self.deviceID,
self.deviceIP,
True,
True,
self.imLeader,
leaderIP=self.leaderIP)
# deprecated: real values of Auth and Conn (as now are None in the Leader)
if self._cimi_agent_resource_id is None:
# Create agent resource
self._cimi_agent_resource_id = CIMI.createAgentResource(
self._cimi_agent_resource.getCIMIdicc())
else:
# Agent resource already exists
status = CIMI.modify_resource(
self._cimi_agent_resource_id,
self._cimi_agent_resource.getCIMIdicc())
# 6. Finish
self.isCompleted = True
return
def __agent_startup_flow(self):
while self._connected:
# 0. Init
self.detectedLeaderID, self.MACaddr, self.bssid = None, None, None
# 0.1 Check CIMI is UP
CIMIon = False
while self._connected and not CIMIon:
CIMIon = CIMI.checkCIMIstarted()
if not CIMIon:
LOG.debug(self.TAG +
'CIMI is not ready... Retry in {}s'.format(
self.WAIT_TIME_CIMI))
sleep(self.WAIT_TIME_CIMI)
LOG.info(self.TAG + 'CIMI is ready!')
# 1. Identification
if self._connected:
self.identification_failed = True # Reset variable to avoid false positives
LOG.debug(self.TAG + 'Sending trigger to Identification...')
try:
self.__trigger_requestID()
self.identification_failed = False
except Exception:
LOG.exception(self.TAG + 'Identification trigger failed!')
self.identification_failed = True
LOG.info(self.TAG + 'Identification Trigger Done.')
else:
return
if not CPARAMS.DEBUG_FLAG and self.identification_failed:
LOG.critical(
self.TAG +
'Identification failed, interrupting agent start.')
return
# 2.1. Check if im Cloud Agent
if self.imCloud:
# start cloud flow
self.__cloud_flow()
return
# 2.2. Check if im a Leader - PLE
if self.imLeader:
# switch to leader
self.__leader_switch_flow()
return
# remain as agent
# 3. Scan for Leaders
count = 0
self.discovery_failed = True
while self._connected and count < self.MAX_MISSING_SCANS and self.detectedLeaderID is None and self.MACaddr is None: # TODO: new protocol required
LOG.debug(self.TAG + 'Sending SCAN trigger to Discovery...')
try:
self.__trigger_startScan()
self.discovery_failed = False
except Exception:
LOG.debug(self.TAG +
'Discovery failed on attepmt {}.'.format(count))
self.discovery_failed = True
if self.detectedLeaderID is not None and self.MACaddr is not None and self.bssid is not None:
LOG.info(self.TAG + 'Discovery Scan Trigger Done.')
count += 1
LOG.info(
self.TAG +
'Discovery trigger finished in #{} attempts and ok={}'.format(
count, self.detectedLeaderID is not None
and self.MACaddr is not None and self.bssid is not None))
if not self._connected:
return
if not CPARAMS.DEBUG_FLAG and self.discovery_failed:
LOG.critical(self.TAG +
'Discovery failed, interrupting agent start.')
return
# 4.1. If no leader detected, switch to leader IF policy and capable - ALE
if not self.discovery_failed and self.detectedLeaderID is None and self.MACaddr is None and self.bssid is None and self.ALE_ENABLED:
self.__leader_switch_flow() # TODO: imCapable?
return
# 4.2 If detected, join to the Leader
if not self.discovery_failed and self.bssid is not None and self._connected:
LOG.debug(self.TAG + 'Sending JOIN trigger to discovery...')
try:
r = self.__trigger_joinDiscovery()
self.discovery_failed = not r
self.discovery_joined = r
if not self.discovery_failed:
self.leaderIP = CPARAMS.LEADER_DISCOVERY_IP
except Exception:
LOG.exception(self.TAG + 'Discovery JOIN trigger failed.')
self.discovery_failed = True
self.discovery_joined = False
LOG.debug(self.TAG + 'Discovery JOIN trigger Done.')
# 4.3 If not detected or failed, static configuration if setup
if self.discovery_failed or (self.detectedLeaderID is None
and self.MACaddr is None
and self.bssid is None):
LOG.debug(
self.TAG +
'Discovery failed or leader was not detected. Fetching deviceIP and leaderIP from env variables.'
)
self.deviceIP = CPARAMS.DEVICE_IP_FLAG
self.leaderIP = CPARAMS.LEADER_IP_FLAG
# 5. CAU client
if self._connected:
self.cauclient_failed = True
LOG.debug(self.TAG + 'Sending trigger to CAU client...')
attempt = 0
r = False
while self._connected and not r and attempt < self.MAX_CAUCLIENT_FAILURES:
try:
r = self.__trigger_triggerCAUclient()
self.cauclient_failed = not r
except Exception:
LOG.exception(self.TAG + 'CAUclient failed.')
self.cauclient_failed = True
finally:
attempt += 1
if not r:
sleep(self.WAIT_TIME_CAUCLIENT)
LOG.info(self.TAG +
'CAU client Trigger Done in {} attempts and ok={}.'.
format(attempt, r))
else:
return
if not CPARAMS.DEBUG_FLAG and self.cauclient_failed:
LOG.critical(self.TAG +
'CAU-Client failed, interrupting agent start.')
return
# 5.1. VPN get IP
attempt = 0
while self._connected and self.vpnIP is None and attempt < self.MAX_VPN_FAILURES:
vpn_ip = VPN.getIPfromFile()
self.vpnIP = vpn_ip if vpn_ip != '' else None
if self.vpnIP is None:
LOG.debug(self.TAG +
'VPN IP cannot be obtained... Retry in {}s'.
format(self.WAIT_TIME_VPN))
sleep(self.WAIT_TIME_VPN)
attempt += 1
if self.vpnIP is None:
LOG.warning(self.TAG + 'VPN IP cannot be obtained.')
if not CPARAMS.DEBUG_FLAG:
LOG.critical(
self.TAG +
'Policies module cannot continue its activity without VPN IP'
)
exit(4)
else:
LOG.info(self.TAG + 'VPN IP: [{}]'.format(self.vpnIP))
# 5.2 If not static configuration and no leader detected, VPN configuration
if self.deviceIP is None and self.leaderIP is None:
LOG.debug(
self.TAG +
'Static configuration for deviceIP and leaderIP not found. Using VPN values'
)
self.deviceIP = self.vpnIP
self.leaderIP = self.cloudIP
LOG.info(self.TAG + 'deviceIP={}, leaderIP={}'.format(
self.deviceIP, self.leaderIP))
# 6. Categorization
if self._connected and not self.categorization_started:
self.categorization_failed = True
LOG.debug(self.TAG +
'Sending start trigger to Categorization...')
try:
self.__trigger_startCategorization()
self.categorization_failed = False
self.categorization_started = True
except Exception:
LOG.exception(self.TAG + 'Categorization failed')
self.categorization_failed = True
LOG.info(self.TAG + 'Categorization Start Trigger Done.')
elif not self._connected:
return
if not CPARAMS.DEBUG_FLAG and self.categorization_failed:
LOG.critical(
self.TAG +
'Categorization failed, interrupting agent start.')
return
# 7. Area Resilience
if self._connected and not self.arearesilience_started:
self.policies_failed = True
LOG.debug(self.TAG + 'Sending start trigger to Policies...')
try:
success = self.__trigger_startLeaderProtectionPolicies()
self.policies_failed = not success
self.arearesilience_started = success
except Exception:
LOG.exception(self.TAG +
'Policies Area Resilience failed!')
LOG.info(self.TAG +
'Policies Area Resilience Start Trigger Done.')
elif not self._connected:
return
if not CPARAMS.DEBUG_FLAG and self.policies_failed:
LOG.critical(
self.TAG +
'Policies Area Resilience failed, interrupting agent start.'
)
return
# Print summary
self.__print_summary()
# Create/Modify Agent Resource
self.deviceIP = '' if self.deviceIP is None else self.deviceIP
self._cimi_agent_resource = AgentResource(self.deviceID,
self.deviceIP,
self.isAuthenticated,
self.secureConnection,
self.imLeader)
LOG.debug(self.TAG + 'CIMI Agent Resource payload: {}'.format(
self._cimi_agent_resource.getCIMIdicc()))
if self._cimi_agent_resource_id is None:
# Create agent resource
self._cimi_agent_resource_id = CIMI.createAgentResource(
self._cimi_agent_resource.getCIMIdicc())
sleep(.1)
self._cimi_agent_resource = AgentResource(
self.deviceID,
self.deviceIP,
self.isAuthenticated,
self.secureConnection,
self.imLeader,
leaderIP=self.leaderIP)
LOG.debug(self.TAG + 'CIMI Agent Resource payload: {}'.format(
self._cimi_agent_resource.getCIMIdicc()))
status = CIMI.modify_resource(
self._cimi_agent_resource_id,
self._cimi_agent_resource.getCIMIdicc())
if self._cimi_agent_resource_id == '':
LOG.warning(self.TAG + 'Agent resource creation failed.')
if not CPARAMS.DEBUG_FLAG:
LOG.error(
'Stopping Policies module due to resource creation failure.'
)
exit(4)
else:
# Agent resource already exists
status = CIMI.modify_resource(
self._cimi_agent_resource_id,
self._cimi_agent_resource.getCIMIdicc())
sleep(.1)
self._cimi_agent_resource = AgentResource(
self.deviceID,
self.deviceIP,
self.isAuthenticated,
self.secureConnection,
self.imLeader,
leaderIP=self.leaderIP)
LOG.debug(self.TAG + 'CIMI Agent Resource payload: {}'.format(
self._cimi_agent_resource.getCIMIdicc()))
status = CIMI.modify_resource(
self._cimi_agent_resource_id,
self._cimi_agent_resource.getCIMIdicc())
# 8. Watch Leader
if self._connected and not self.discovery_failed:
LOG.debug(self.TAG + 'Start Discovery Leader Watch...')
try:
self.__trigger_startDiscoveryWatch()
except Exception:
LOG.exception(self.TAG + 'Watch Discovery Start Fail.')
LOG.info(self.TAG + 'Watch Discovery Start Trigger Done.')
elif self.discovery_failed:
LOG.warning(
self.TAG +
'Discovery Watch cancelled due Discovery Trigger failed')
else:
return
self.isCompleted = True
alive = True
while self._connected and not self.discovery_failed and alive:
# 6 Check if discovery connection is alive
LOG.debug(self.TAG + 'Discovery Alive Start Trigger.')
try:
alive = not self.__trigger_aliveDiscovery(
) # not disconnected
except Exception:
LOG.exception(self.TAG + 'Discovery Alive failed')
alive = False
if self._connected:
sleep(CPARAMS.TIME_WAIT_ALIVE)
LOG.info(self.TAG + 'Discovery Alive Start Trigger Done.')
if not self._connected:
return
if CPARAMS.DEBUG_FLAG and self.discovery_failed:
LOG.debug(self.TAG + 'No rescan available. Stoping activity')
return
def __leader_switch_flow(self):
"""
Agent become leader
:return:
"""
# 1. Start sending beacons
if self._connected:
self.discovery_leader_failed = True
LOG.debug(self.TAG + 'Sending Broadcast trigger to discovery...')
try:
self.__trigger_switch_discovery(
) # TODO: Send deviceID when broadcasting
self.detectedLeaderID = self.deviceID
self.discovery_leader_failed = False
except Exception as ex:
LOG.exception(self.TAG + 'Discovery broadcast trigger failed!')
LOG.info(self.TAG + 'Discovery Broadcast Trigger Done.')
else:
return
if not CPARAMS.DEBUG_FLAG and self.discovery_leader_failed:
LOG.critical(
self.TAG +
'Discovery broadcast failed, interrupting leader switch.')
return
# 2. Start LeaderCAU (Not implemented)
pass # TODO: Review this in IT-2
# 3. Switch leader categorization (or start if not started)
if self.categorization_started:
self.categorization_leader_failed = True
# Switch!
LOG.debug(self.TAG + 'Sending switch trigger to Categorization...')
try:
self.__trigger_switch_categorization()
self.categorization_leader_failed = False
except Exception:
LOG.exception(self.TAG +
'Categorization switch to leader failed')
LOG.info(self.TAG + 'Categorization Switch Trigger Done.')
else:
# Start as leader!
LOG.debug(self.TAG + 'Sending start trigger to Categorization...')
try:
self.__trigger_startCategorization()
self.categorization_leader_failed = False
self.categorization_started = True
except Exception:
LOG.exception(self.TAG + 'Categorization failed')
LOG.info(self.TAG + 'Categorization Start Trigger Done.')
if not CPARAMS.DEBUG_FLAG and self.categorization_leader_failed:
LOG.critical(self.TAG +
'Categorization failed, interrupting leader switch.')
return
# 4. Start Area Resilience (if not started)
if not self.arearesilience_started:
self.policies_failed = True
LOG.debug(self.TAG + 'Sending start trigger to Policies...')
try:
self.__trigger_startLeaderProtectionPolicies()
self.policies_failed = False
self.arearesilience_started = True
except Exception:
LOG.exception(self.TAG + 'Policies Area Resilience failed!')
LOG.info(self.TAG + 'Policies Area Resilience Start Trigger Done.')
if not CPARAMS.DEBUG_FLAG and self.policies_failed:
LOG.critical(
self.TAG +
'Policies Area Resilience failed, interrupting agent start.')
return
# Create/Modify Agent Resource # TODO.
self.deviceIP = '' # TODO: Real value here (from categorization)
self._cimi_agent_resource = AgentResource(self.deviceID,
self.deviceIP,
self.isAuthenticated,
self.secureConnection,
self.imLeader,
leaderIP=self.leaderIP)
if self._cimi_agent_resource_id is None:
# Create agent resource
self._cimi_agent_resource_id = CIMI.createAgentResource(
self._cimi_agent_resource.getCIMIdicc())
else:
# Agent resource already exists
status = CIMI.modify_resource(
self._cimi_agent_resource_id,
self._cimi_agent_resource.getCIMIdicc())
# 5. Finish
return # TODO: Return something?
def __agent_startup_flow(self):
while self._connected:
# 0. Init
self.detectedLeaderID, self.MACaddr = None, None
# 0.1 Check CIMI is UP
CIMIon = False
while self._connected and not CIMIon:
CIMIon = CIMI.checkCIMIstarted()
if not CIMIon:
LOG.debug(self.TAG +
'CIMI is not ready... Retry in {}s'.format(
self.WAIT_TIME_CIMI))
sleep(self.WAIT_TIME_CIMI)
LOG.info(self.TAG + 'CIMI is ready!')
# 1. Identification
if self._connected:
self.identification_failed = True # Reset variable to avoid false positives
LOG.debug(self.TAG + 'Sending trigger to Identification...')
try:
self.__trigger_requestID()
self.identification_failed = False
except Exception:
LOG.exception(self.TAG + 'Identification trigger failed!')
self.identification_failed = True
LOG.info(self.TAG + 'Identification Trigger Done.')
else:
return
if not CPARAMS.DEBUG_FLAG and self.identification_failed:
LOG.critical(
self.TAG +
'Identification failed, interrupting agent start.')
return
# 2. Check if im a Leader - PLE
if self.imLeader:
# switch to leader
self.__leader_switch_flow() # TODO: imCapable?
return
# remain as agent
# 3. Scan for Leaders
count = 0
self.discovery_failed = True
while self._connected and count < self.MAX_MISSING_SCANS and self.detectedLeaderID is None and self.MACaddr is None: # TODO: new protocol required
LOG.debug(self.TAG + 'Sending scan trigger to Discovery...')
try:
self.__trigger_startScan()
self.discovery_failed = False
except Exception:
LOG.debug(self.TAG +
'Discovery failed on attepmt {}.'.format(count))
self.discovery_failed = True
if self.detectedLeaderID is not None and self.MACaddr is not None:
LOG.info(self.TAG + 'Discovery Scan Trigger Done.')
count += 1
LOG.info(
self.TAG +
'Discovery trigger finished in #{} attempts and ok={}'.format(
count, self.detectedLeaderID is not None
and self.MACaddr is not None))
if not self._connected:
return
if not CPARAMS.DEBUG_FLAG and self.discovery_failed:
LOG.critical(self.TAG +
'Discovery failed, interrupting agent start.')
return
# 4. If no leader detected, switch to leader IF policy and capable - ALE
if not self.discovery_failed and self.detectedLeaderID is None and self.MACaddr is None and self.ALE_ENABLED:
self.__leader_switch_flow() # TODO: imCapable?
return
# 5. CAU client
if self._connected:
self.cauclient_failed = True
LOG.debug(self.TAG + 'Sending trigger to CAU client...')
try:
self.__trigger_triggerCAUclient()
self.cauclient_failed = False
except Exception:
LOG.exception(self.TAG + 'CAUclient failed.')
self.cauclient_failed = True
LOG.info(self.TAG + 'CAU client Trigger Done.')
else:
return
if not CPARAMS.DEBUG_FLAG and self.cauclient_failed:
LOG.critical(self.TAG +
'CAU-Client failed, interrupting agent start.')
return
# 5. Categorization
if self._connected and not self.categorization_started:
self.categorization_failed = True
LOG.debug(self.TAG +
'Sending start trigger to Categorization...')
try:
self.__trigger_startCategorization()
self.categorization_failed = False
self.categorization_started = True
except Exception:
LOG.exception(self.TAG + 'Categorization failed')
self.categorization_failed = True
LOG.info(self.TAG + 'Categorization Start Trigger Done.')
elif not self._connected:
return
if not CPARAMS.DEBUG_FLAG and self.categorization_failed:
LOG.critical(
self.TAG +
'Categorization failed, interrupting agent start.')
return
# 6. Area Resilience
if self._connected and not self.arearesilience_started:
self.policies_failed = True
LOG.debug(self.TAG + 'Sending start trigger to Policies...')
try:
success = self.__trigger_startLeaderProtectionPolicies()
self.policies_failed = not success
self.arearesilience_started = success
except Exception:
LOG.exception(self.TAG +
'Policies Area Resilience failed!')
LOG.info(self.TAG +
'Policies Area Resilience Start Trigger Done.')
elif not self._connected:
return
if not CPARAMS.DEBUG_FLAG and self.policies_failed:
LOG.critical(
self.TAG +
'Policies Area Resilience failed, interrupting agent start.'
)
return
# Print summary
self.__print_summary()
# Create/Modify Agent Resource # TODO.
self.deviceIP = '' # TODO: Real value here (from categorization)
self._cimi_agent_resource = AgentResource(self.deviceID,
self.deviceIP,
self.isAuthenticated,
self.secureConnection,
self.imLeader,
leaderIP=self.leaderIP)
if self._cimi_agent_resource_id is None:
# Create agent resource
self._cimi_agent_resource_id = CIMI.createAgentResource(
self._cimi_agent_resource.getCIMIdicc())
else:
# Agent resource already exists
status = CIMI.modify_resource(
self._cimi_agent_resource_id,
self._cimi_agent_resource.getCIMIdicc())
# 7. Watch Leader
if self._connected and not self.discovery_failed:
LOG.debug(self.TAG + 'Start Discovery Leader Watch...')
try:
self.__trigger_startDiscoveryWatch()
except Exception:
LOG.exception(self.TAG + 'Watch Discovery Start Fail.')
LOG.info(self.TAG + 'Watch Discovery Start Trigger Done.')
elif self.discovery_failed:
LOG.warning(
self.TAG +
'Discovery Watch cancelled due Discovery Trigger failed')
else:
return
alive = True
while self._connected and not self.discovery_failed and alive:
# 6 Check if discovery connection is alive
LOG.debug(self.TAG + 'Discovery Alive Start Trigger.')
try:
alive = not self.__trigger_aliveDiscovery(
) # not disconnected
except Exception:
LOG.exception(self.TAG + 'Discovery Alive failed')
alive = False
if self._connected:
sleep(CPARAMS.TIME_WAIT_ALIVE)
LOG.info(self.TAG + 'Discovery Alive Start Trigger Done.')
if not self._connected:
return
if CPARAMS.DEBUG_FLAG and self.discovery_failed:
# TODO: Delete this in future versions
LOG.debug(self.TAG + 'No rescan available. Stoping activity')
return