def start(self):
CompositeNode.start(self)
self._set_zip_file()
tread = Thread(name="AutoDiscovery",target=self.kick_start_discovery)
scheduler.after(2, tread.start)
self.ad = AutoDiscovery()
self.ad.configure({"parent":self,"name":"AutoDiscover"})
def _output(self, value):
value = value ^ self.reverse_output
if self.enabled and (value is not self._value):
self.DEBUG3("_drive_output: self.output=%s\n", self.output)
if self._output_state == self._SAFETY:
self._waiting_value = value
else:
self.output.set(value)
self._waiting_value = None
self._value = value
if (value == 1) and self.min_on_time > 0:
self._output_state = self._SAFETY
scheduler.after(self.min_on_time,
self._clear_safety,())
self._changes_at = time.time() + self.min_on_time
elif (value == 0) and self.min_off_time > 0:
self._output_state = self._SAFETY
scheduler.after(self.min_off_time,
self._clear_safety,())
self._changes_at = time.time() + self.min_off_time
self.DEBUG2("_drive_output: set:%r, got:%r\n",
value, self.output.get)
else:
self.DEBUG3("_drive_output: No change\n")
self.DEBUG3("_drive_output: return\n")
return
def export(self, alarm, attempt=0):
self._lock.acquire()
try:
if (not self._started):
self._alarm.append(alarm)
# No need to set scheduler here; start() will call
# export_waiting_alarm()...
return
# Even if this node is already started, do not attempt to
# export alarm unless the linked log node and its collector
# object are extant and started:
if (self.log.collector is None):
self._alarm.append(alarm)
if (self._waiting_alarm_sid is
None): # if we're not already scheduled, do it:
# Need to wait long enough for log.start() to finish creating
# and starting collector. ***GUESS*** 10.0 sec. Symptom of not
# waiting long enough: ENotStarted error raised below:
self._waiting_alarm_sid = scheduler.after(
10.0, self.export_waiting_alarm, ())
return
finally:
self._lock.release()
self.log.collector.pause()
try:
try:
if not self.log.collector.running:
raise ENotStarted('Collector not started yet.')
entry = self.log.collector.get_entry()
entry[self.ts_position] = time.time()
# Stamp source, if target log columns support it:
if isinstance(self.trigger_node_url_posn, int):
entry[self.trigger_node_url_posn] = as_node_url(
alarm.source)
if isinstance(self.trigger_node_msg_posn, int):
entry[self.trigger_node_msg_posn] = str(alarm)
self.log.add_entry(entry)
t = time.time()
for child in self.log.get_child('exporters').children_nodes():
child.go(t) # starts threads for long ops
except:
msglog.exception()
if attempt > alarm.source.send_retries:
msglog.log('broadway', msglog.types.WARN,
'Export of alarm failed, aborting send.')
raise MpxException('Log and export failed.')
else:
msglog.log('broadway', msglog.types.WARN,
'Log on alarm failed, delaying 1.0 sec.')
self._lock.acquire()
try:
if self._scheduled != None:
scheduler.cancel(self._scheduled)
self._scheduled = scheduler.after(
1, self.export, (alarm, attempt + 1))
finally:
self._lock.release()
finally:
self.log.collector.play()
return
def start(period=1.0, *args):
global should_run
if not should_run:
should_run = 1
first_time = math.floor(time.time()) + period
scheduler.at(first_time, absolute_callback, (period,first_time,))
scheduler.after(first_time-time.time(),
relative_callback, (period,first_time,))
return
def export(self, alarm, attempt=0):
self._lock.acquire()
try:
if (not self._started):
self._alarm.append(alarm)
# No need to set scheduler here; start() will call
# export_waiting_alarm()...
return
# Even if this node is already started, do not attempt to
# export alarm unless the linked log node and its collector
# object are extant and started:
if (self.log.collector is None):
self._alarm.append(alarm)
if (self._waiting_alarm_sid is None): # if we're not already scheduled, do it:
# Need to wait long enough for log.start() to finish creating
# and starting collector. ***GUESS*** 10.0 sec. Symptom of not
# waiting long enough: ENotStarted error raised below:
self._waiting_alarm_sid = scheduler.after(10.0, self.export_waiting_alarm, ())
return
finally:
self._lock.release()
self.log.collector.pause()
try:
try:
if not self.log.collector.running:
raise ENotStarted('Collector not started yet.')
entry = self.log.collector.get_entry()
entry[self.ts_position] = time.time()
# Stamp source, if target log columns support it:
if isinstance(self.trigger_node_url_posn, int):
entry[self.trigger_node_url_posn] = as_node_url(alarm.source)
if isinstance(self.trigger_node_msg_posn, int):
entry[self.trigger_node_msg_posn] = str(alarm)
self.log.add_entry(entry)
t = time.time()
for child in self.log.get_child('exporters').children_nodes():
child.go(t) # starts threads for long ops
except:
msglog.exception()
if attempt > alarm.source.send_retries:
msglog.log('broadway',msglog.types.WARN,
'Export of alarm failed, aborting send.')
raise MpxException('Log and export failed.')
else:
msglog.log('broadway',msglog.types.WARN,
'Log on alarm failed, delaying 1.0 sec.')
self._lock.acquire()
try:
if self._scheduled != None:
scheduler.cancel(self._scheduled)
self._scheduled = scheduler.after(1,self.export,
(alarm,attempt+1))
finally:
self._lock.release()
finally:
self.log.collector.play()
return
def scan(self):
print 'scan'
try:
if self.running:
self.scan_nodes_for_changes()
self.scan_spread_sheet_for_changes()
scheduler.after(self.period, self.scan)
except:
msglog.exception()
scheduler.after(self.period, self.restart)
def _schedule(self):
try:
float(self.DELAY)
except:
print "WARNING: Bad DELAY (%r), setting to 1.0" % self.DELAY
self.DELAY=1.0
if self.DELAY > 0.0:
scheduler.after(self.DELAY, self._queue)
else:
self._queue()
return
def relative_callback(period,*args):
global should_run
this_time = time.time()
if should_run:
next_time = math.floor(time.time()) + period
scheduler.after(next_time-time.time(),
relative_callback, (period,next_time,))
print 'R: %s %s' % (this_time, args)
else:
print 'R: %s %s - STOPPED' % (this_time, args)
return
def handle_propogation_failure(self, notifier):
cloudevent = notifier.cloudevent
target_peer = notifier.peer
# TODO: generate comm failure error to propogate as well.
# Progpogate event to Cloud Managers target_peer would have notified.
'''
The target_peer can be portal or a peer.
If it is a portal then we will not put it in unreachables and also
we do not propogate the event.
Log if we are not connecting to the portal
'''
portal=self.nformation.get_portal()
if((portal != None ) and (utils.same_host(target_peer,portal))):
msg='Portal %s is not reachable .' % portal
self.message(msg)
return
scheduled = self.unreachable.get(target_peer)
if scheduled is not None:
scheduled.cancel()
self.message('Host %s already listed unreachable, reset scheduled retry.' % target_peer)
self.unreachable[target_peer] = scheduler.after(5 * 60, self._remove_from_unreachable, (target_peer,))
self.message('Host %s added to list of unreachable peers.' % target_peer)
self.propogate(cloudevent, target_peer)
def _dispatch(self, event):
if self.hysteresis != 0:
comparison = self._comparison_operator
if isinstance(event, TriggerActivated):
# Comarpsion is True
if comparison == '>':
# Input is > constant
self.set_constant(self._constant - self.hysteresis)
elif comparison == '<':
# Input is < constant
self.set_constant(self._constant + self.hysteresis)
else: raise ValueError('Operator %s uknnown.' % comparison)
elif isinstance(event, TriggerCleared):
# Comparison is False, clear hysteresis
self.set_constant(self._constant)
else: raise TypeError('Event of unknown type.')
if self.alarm_delay:
self.synclock.acquire()
try:
if isinstance(event, TriggerActivated):
self.deferred = scheduler.after(self.alarm_delay,
self._deferred_dispatch,
(event,))
elif isinstance(event, TriggerCleared) and self.deferred:
scheduled, self.deferred = self.deferred, None
if scheduled:
scheduled.cancel()
else:
super(ComparisonTrigger, self)._dispatch(event)
finally: self.synclock.release()
else:
super(ComparisonTrigger, self)._dispatch(event)
def _setup_formation(self, formation,portal):
scheduled, self._scheduled = self._scheduled, None
if scheduled is not None:
try: scheduled.cancel()
except: pass
else: self.message('Canceled pending dispatch of formation update.')
self.nformation.set_portal(portal)
self.nformation.set_formation(formation)
self.target_formation = self.nformation.compute_targets()
self.message('Resetting unreachables during Cloud setup.')
self.reset_unreachables()
(dispatch,delay)=self.nformation.compute_dispatch_info()
if (dispatch):
self._scheduled = scheduler.after(delay, self.dispatcher.dispatch, (FormationUpdated(self),))
self.message('Scheduled dispatch in %s seconds.' % delay)
else: self.message('Formation of one peer, no Updated event generated.')
# Save the PDO, if the formation or portal has changed
if((self._pdo.formation != formation) or (self._pdo.portal != portal) or (self._pdo.peer != self.peer)):
self.message('New formation/portal found , hence pickling. New Formation is :%s portal is %s' %(str(formation),portal))
self._pdo.formation=formation[:]
self._pdo.portal=portal
self._pdo.peer=self.peer
tstart = time.time()
self._pdo.save()
tend = time.time()
self.message('New formation pickled and saved in %s seconds.' % (tend - tstart))
else:
self.message('Formation/Portal has not changed. Not pickling it. ' )
def note_modified(self, persistent):
self.lock.acquire()
try:
super(TimedPolicy, self).notify_modified(persistent, modified)
if self.scheduled is None:
self.scheduled = scheduler.after(self.seconds, self.commit)
finally: self.lock.release()
def _dispatch(self, event):
if self.hysteresis != 0:
comparison = self._comparison_operator
if isinstance(event, TriggerActivated):
# Comarpsion is True
if comparison == '>':
# Input is > constant
self.set_constant(self._constant - self.hysteresis)
elif comparison == '<':
# Input is < constant
self.set_constant(self._constant + self.hysteresis)
else:
raise ValueError('Operator %s uknnown.' % comparison)
elif isinstance(event, TriggerCleared):
# Comparison is False, clear hysteresis
self.set_constant(self._constant)
else:
raise TypeError('Event of unknown type.')
if self.alarm_delay:
self.synclock.acquire()
try:
if isinstance(event, TriggerActivated):
self.deferred = scheduler.after(self.alarm_delay,
self._deferred_dispatch,
(event, ))
elif isinstance(event, TriggerCleared) and self.deferred:
scheduled, self.deferred = self.deferred, None
if scheduled:
scheduled.cancel()
else:
super(ComparisonTrigger, self)._dispatch(event)
finally:
self.synclock.release()
else:
super(ComparisonTrigger, self)._dispatch(event)
def note_modified(self, persistent):
self.lock.acquire()
try:
super(TimedPolicy, self).notify_modified(persistent, modified)
if self.scheduled is None:
self.scheduled = scheduler.after(self.seconds, self.commit)
finally:
self.lock.release()
def _schedule(self):
self.DEBUG3("_schedule():\n")
self._cancel_polling()
if self.__running:
self._poll_event = scheduler.after(self._period,
self._lock_and_poll_input)
self.DEBUG3("_schedule: return\n")
return
def __schedule_discover(self):
delay = self.__discover_delays[min(self.__discover_attempts,
len(self.__discover_delays)-1)]
msglog.log("SNMP", msglog.types.INFO,
"Discover of %r scheduled in %r seconds." %
(self.as_node_url(), delay))
self.__discover_event = scheduler.after(delay, self.__queue_discover)
return
def application_change_detector(self, starting=0):
try:
if self.check_and_load_application_files(starting):
self._status = 'Starting control applications'
msglog.log(self.as_node_url(), msglog.types.INFO,
'Stage 5: Start Application templates.')
self._start()
self._status = 'Running'
msglog.log(self.as_node_url(), msglog.types.INFO,
'Application templates started.')
self.prune_orphaned_schedules()
# schedule manager must see control service as running to work
scheduler.after(13, self.application_change_detector)
except:
self._status = 'ERROR: check message log'
msglog.exception()
scheduler.after(60, self.application_change_detector)
def _schedule(self):
self.DEBUG3("_schedule():\n")
self._cancel_polling()
if self.__running:
self._poll_event = scheduler.after(
self._period, self._lock_and_poll_input)
self.DEBUG3("_schedule: return\n")
return
def application_change_detector(self, starting=0):
try:
if self.check_and_load_application_files(starting):
self._status = 'Starting control applications'
msglog.log(self.as_node_url(),msglog.types.INFO,
'Stage 5: Start Application templates.')
self._start()
self._status = 'Running'
msglog.log(self.as_node_url(),msglog.types.INFO,
'Application templates started.')
self.prune_orphaned_schedules()
# schedule manager must see control service as running to work
scheduler.after(13, self.application_change_detector)
except:
self._status = 'ERROR: check message log'
msglog.exception()
scheduler.after(60, self.application_change_detector)
def poll_alarms(self):
if not self._running:
return
ret_alarms = []
new_alarms = self.h_alarms.get_new_alarms()
if new_alarms:
for rsp in new_alarms:
if rsp.is_critical():
al_type = "Critical"
else:
al_type = "Non-Critical"
a = Alarm(
id=rsp.unitnum(),
type=al_type,
source=rsp.unitnum(),
data=rsp.message(),
state=rsp.code(),
timestamp=rsp.time(),
)
ret_alarms.append(a)
if self.generatebogus:
# Generate bogus alarms roughly 1/16 of the time
roll = self.rand.randint(1, 16)
if roll == 16:
how_many = 1
do_multiple = self.rand.randint(0, 1)
if do_multiple:
how_many = self.rand.randint(1, 10)
if self.debug:
print "%f: Generating %d random alarm(s)." % (time.time(), how_many)
for i in range(0, how_many):
is_not_crit = self.rand.randint(0, 4)
if is_not_crit == 0:
al_type = "Critical"
else:
al_type = "Non-Critical"
a = Alarm(
id="test_%.2d" % (i + 1),
type=al_type,
source=1,
data="This is test alarm #%d." % (i + 1),
state=i,
timestamp=time.time(),
)
ret_alarms.append(a)
if ret_alarms:
ae = NewAlarmsEvent(self, ret_alarms)
self.parent.event_generate(ae)
# While we are at it, acknowledge any critical alarms.
self.h_alarms.ack_critical_alarms()
self.sid = scheduler.after(15, self.poll_alarms)
def check_startup(self):
self.synclock.acquire()
try:
if self.manager.is_running():
self.scheduled_startup = None
NORMAL.queue_noresult(self._initialize)
else:
self.scheduled_startup = scheduler.after(5,self.check_startup)
finally:
self.synclock.release()
def start(self):
if self.is_running():
self.stop()
self.synclock.acquire()
try:
self.manager = as_node("/services/Alarm Manager")
self.scheduled_startup = scheduler.after(0, self.check_startup)
finally:
self.synclock.release()
return super(EventStore, self).start()
def reschedule(self, delay=None):
scheduled, self.scheduled = self.scheduled, None
if scheduled:
scheduled.cancel()
if self._running.isSet():
if delay is None:
delay = self.poll_period
self.scheduled = scheduler.after(delay, self.manager.queue_trigger,
(self, ))
return self.scheduled
def reschedule(self, delay = None):
scheduled, self.scheduled = self.scheduled, None
if scheduled:
scheduled.cancel()
if self._running.isSet():
if delay is None:
delay = self.poll_period
self.scheduled = scheduler.after(
delay, self.manager.queue_trigger, (self,))
return self.scheduled
def _reschedule(self):
self._schedule_lock.acquire()
try:
if (self._scheduled is None or
self._scheduled.executing() or
self._scheduled.expired()):
self._scheduled = scheduler.after(
self.poll_period,self._manager.queue_alarm_check,(self,))
finally:
self._schedule_lock.release()
return
def propagate(self, data):
"""
To be called by asyncore-polling loop. Use
notify to trigger the propagate event.
"""
self.message("%s propagate creating socket." % self)
self.create_socket(socket.AF_INET,socket.SOCK_STREAM)
self.message("%s propagate connecting %s:%d" % (self, self.peer, self.port))
self.connect((self.peer,self.port))
self.scheduled_timeout = scheduler.after(30, self.handle_timeout)
self.ac_out_buffer = data
def _reschedule(self):
self._schedule_lock.acquire()
try:
if (self._scheduled is None or self._scheduled.executing()
or self._scheduled.expired()):
self._scheduled = scheduler.after(
self.poll_period, self._manager.queue_alarm_check,
(self, ))
finally:
self._schedule_lock.release()
return
def poll_alarms(self):
if not self._running:
return
ret_alarms = []
new_alarms = self.h_alarms.get_new_alarms()
if new_alarms:
for rsp in new_alarms:
if rsp.is_critical():
al_type = 'Critical'
else:
al_type = 'Non-Critical'
a = Alarm(id=rsp.unitnum(),
type=al_type,
source=rsp.unitnum(),
data=rsp.message(),
state=rsp.code(),
timestamp=rsp.time())
ret_alarms.append(a)
if self.generatebogus:
# Generate bogus alarms roughly 1/16 of the time
roll = self.rand.randint(1, 16)
if roll == 16:
how_many = 1
do_multiple = self.rand.randint(0, 1)
if do_multiple:
how_many = self.rand.randint(1, 10)
if self.debug:
print '%f: Generating %d random alarm(s).' % (time.time(),
how_many)
for i in range(0, how_many):
is_not_crit = self.rand.randint(0, 4)
if is_not_crit == 0:
al_type = 'Critical'
else:
al_type = 'Non-Critical'
a = Alarm(id='test_%.2d' % (i + 1),
type=al_type,
source=1,
data='This is test alarm #%d.' % (i + 1),
state=i,
timestamp=time.time())
ret_alarms.append(a)
if ret_alarms:
ae = NewAlarmsEvent(self, ret_alarms)
self.parent.event_generate(ae)
# While we are at it, acknowledge any critical alarms.
self.h_alarms.ack_critical_alarms()
self.sid = scheduler.after(15, self.poll_alarms)
def restart(self):
self.shutdown() #start from a known state
if self.open_socket():
if self.login():
if self.debug: print 'login successful - start polling'
self.service_thread = threading.ImmortalThread(None, self.poll_screens, 'CPC', reincarnate=self.poll_error)
self.service_thread.start()
self.__running = 1
return 1
self.shutdown()
self.retry_schedule = scheduler.after(60.0,self.restart)
msglog.log(INFO, 'CPC', 'retry starting CPC device in 60 seconds')
return 0
def poll_alarms(self):
if not self._running:
return
if debug > 1:
print '%f: In poll_alarms().' % time.time()
alarms = self.get_alarms()
ret_alarms = []
for x in alarms:
if not x in self.old_alarms:
if debug:
print 'Found a new alarm: %s' % str(x)
# Note: @fixme: At some point we will probably do some filtering
# on the "alarms" we get back from the BCU because apparently
# they may include some event type information for which we
# don't want to create an Alarm Event. FredD apparently
# has the information for differentiating between events
# and real alarms from a BCU.
# Note: x looks like:
# {'priority': '', 'ack': 'No', 'from': 'BCU-01', 'SN': 0,
# 'date': 1068221677.0, 'type': 'Watchdog Timeout',
# 'detail': ''
# }
a = Alarm(id=x['SN'],
type=x['type'],
source=x['from'],
timestamp=x['date'],
data=x['detail'],
priority=x['priority'],
acked=x['ack'])
if debug:
print 'Got new alarm: %s.' % str(a)
ret_alarms.append(a)
else:
if debug:
print 'Ignoring alarm, it has already been raised reported'
if ret_alarms:
self.parent.put_alarms(ret_alarms)
# Note: @fixme: old_alarms should be a PDO so that we don't resend alarms
# that have already been seen every time we start up. For now this
# behavior may actually be useful for testing but probably will
# not be a "feature" in the real world.
self.old_alarms = alarms
self.sid = scheduler.after(15, self.poll_alarms)
def poll_alarms(self):
if not self._running:
return
if debug > 1:
print '%f: In poll_alarms().' % time.time()
alarms = self.get_alarms()
ret_alarms = []
for x in alarms:
if not x in self.old_alarms:
if debug:
print 'Found a new alarm: %s' % str(x)
# Note: @fixme: At some point we will probably do some filtering
# on the "alarms" we get back from the BCU because apparently
# they may include some event type information for which we
# don't want to create an Alarm Event. FredD apparently
# has the information for differentiating between events
# and real alarms from a BCU.
# Note: x looks like:
# {'priority': '', 'ack': 'No', 'from': 'BCU-01', 'SN': 0,
# 'date': 1068221677.0, 'type': 'Watchdog Timeout',
# 'detail': ''
# }
a = Alarm(id=x['SN'],
type=x['type'],
source=x['from'],
timestamp=x['date'],
data=x['detail'],
priority=x['priority'],
acked=x['ack'])
if debug:
print 'Got new alarm: %s.' % str(a)
ret_alarms.append(a)
else:
if debug:
print 'Ignoring alarm, it has already been raised reported'
if ret_alarms:
self.parent.put_alarms(ret_alarms)
# Note: @fixme: old_alarms should be a PDO so that we don't resend alarms
# that have already been seen every time we start up. For now this
# behavior may actually be useful for testing but probably will
# not be a "feature" in the real world.
self.old_alarms = alarms
self.sid = scheduler.after(15, self.poll_alarms)
def _output(self, value):
value = value ^ self.reverse_output
if self.enabled and (value is not self._value):
self.DEBUG3("_drive_output: self.output=%s\n", self.output)
if self._output_state == self._SAFETY:
self._waiting_value = value
else:
self.output.set(value)
self._waiting_value = None
self._value = value
if (value == 1) and self.min_on_time > 0:
self._output_state = self._SAFETY
scheduler.after(self.min_on_time, self._clear_safety, ())
self._changes_at = time.time() + self.min_on_time
elif (value == 0) and self.min_off_time > 0:
self._output_state = self._SAFETY
scheduler.after(self.min_off_time, self._clear_safety, ())
self._changes_at = time.time() + self.min_off_time
self.DEBUG2("_drive_output: set:%r, got:%r\n", value,
self.output.get)
else:
self.DEBUG3("_drive_output: No change\n")
self.DEBUG3("_drive_output: return\n")
return
def wait(self, timeout=None):
if not self._lock.locked():
raise AssertionError('wait called on un-acquire()d lock')
lock = _ThreadWrapper(_allocate_lock())
lock.acquire()
id = None
if timeout is not None:
id = scheduler.after(timeout, self._timeout, (lock,))
lock.set_id(id)
self._locks.append(lock)
self.release()
try:
lock.acquire()
finally:
self.acquire()
def wait(self, timeout=None):
if not self._lock.locked():
raise AssertionError('wait called on un-acquire()d lock')
lock = _ThreadWrapper(_allocate_lock())
lock.acquire()
id = None
if timeout is not None:
id = scheduler.after(timeout, self._timeout, (lock, ))
lock.set_id(id)
self._locks.append(lock)
self.release()
try:
lock.acquire()
finally:
self.acquire()
def restart(self):
self.shutdown() #start from a known state
if self.open_socket():
if self.login():
if self.debug: print 'login successful - start polling'
self.service_thread = threading.ImmortalThread(
None,
self.poll_screens,
'CPC',
reincarnate=self.poll_error)
self.service_thread.start()
self.__running = 1
return 1
self.shutdown()
self.retry_schedule = scheduler.after(60.0, self.restart)
msglog.log(INFO, 'CPC', 'retry starting CPC device in 60 seconds')
return 0
def _tz_change_detector(self):
sched_after = 13
try:
if os.path.islink(P.TIMEZONE_FILE):
mtime = os.lstat(P.TIMEZONE_FILE)[8]
if mtime != self._tz_mtime:
time.tzset()
self._tz_mtime = mtime
self._in_err = False
except:
if not self._in_err:
msglog.log(self.as_node_url(), msglog.types.WARN,
'Error monitoring TZ file')
msglog.exception()
self._in_err = True
sched_after = 61
self._scheduled = scheduler.after(sched_after, self.tz_change_detector)
class GetViaCOV(EventConsumerAbstract):
def __init__(self, source_node, timeout=960):
EventConsumerAbstract.__init__(self)
self.__node = as_internal_node(source_node)
self.__cond = Condition()
self.__event = None
self.__sched = None #scheduled action to unsubscribe the point
self.__timeout = timeout #number of seconds to maintain subscription
self._event_received = False
return
def get_event(self, **keywords):
if self.__node._pruned_url:
try:
self.__node = as_internal_node(self.__node._pruned_url)
except ENoSuchName, e:
raise ENoSuchNode(self.__node._pruned_url)
self.__cond.acquire()
try:
if self.__event is None:
self.__node.event_subscribe(self, ChangeOfValueEvent)
#@todo add a way to get subscription started without blocking - ie return a value of None - based on keyword?
do_not_wait = keywords.get('do_not_wait', None)
if do_not_wait:
#create a dummy event and put None in the value and return that
self.__event = ChangeOfValueEvent(self.__node, None, None)
else:
self.__cond.wait() #block until the value shows up
elif not self._event_received: #if event not nil and no event received it means 'do_not_wait' was used on first call
do_not_wait = keywords.get('do_not_wait', None)
if not do_not_wait:
self.__cond.wait(
) #if do_not_wait was used on last call, now we wait for cov
if self.__sched:
sched = self.__sched.reset(
) #if it's too late to reschedule, this returns None
if sched is None: #too late
self.__sched.cancel() #try to cancel it
self.__sched = sched
if self.__sched is None: #first time or after expiration
self.__sched = scheduler.after(self.__timeout,
self.unsubscribe)
return self.__event
finally:
self.__cond.release()
def export_waiting_alarm(self):
if (self._started == 1) \
and (not self.log.collector is None):
if not self._waiting_alarm_sid is None:
try:
scheduler.remove(self._waiting_alarm_sid)
except: # SID may already have expired and been removed...
msglog.exception()
self._waiting_alarm_sid = None
while len(self._alarm) > 0:
init_len = len(self._alarm)
alarm = self._alarm.pop(0)
self.export(alarm) # should leave alarm off of list...
if init_len <= len(self._alarm):
break # failed to keep alarm off the list
elif (len(self._alarm) > 0):
self._waiting_alarm_sid = scheduler.after(10.0, self.export_waiting_alarm, ())
return
def export_waiting_alarm(self):
if (self._started == 1) \
and (not self.log.collector is None):
if not self._waiting_alarm_sid is None:
try:
scheduler.remove(self._waiting_alarm_sid)
except: # SID may already have expired and been removed...
msglog.exception()
self._waiting_alarm_sid = None
while len(self._alarm) > 0:
init_len = len(self._alarm)
alarm = self._alarm.pop(0)
self.export(alarm) # should leave alarm off of list...
if init_len <= len(self._alarm):
break # failed to keep alarm off the list
elif (len(self._alarm) > 0):
self._waiting_alarm_sid = scheduler.after(
10.0, self.export_waiting_alarm, ())
return
def _tz_change_detector(self):
sched_after = 13
try:
if os.path.islink(P.TIMEZONE_FILE):
mtime = os.lstat(P.TIMEZONE_FILE)[8]
if mtime != self._tz_mtime:
time.tzset()
self._tz_mtime = mtime
self._in_err = False
except:
if not self._in_err:
msglog.log(
self.as_node_url(),
msglog.types.WARN,
'Error monitoring TZ file'
)
msglog.exception()
self._in_err = True
sched_after = 61
self._scheduled = scheduler.after(sched_after, self.tz_change_detector)
def _heartbeat_action(self):
self._safe_log('Scheduler Heartbeat')
try:
self._sid = scheduler.after(self.heartbeat_period,self._heartbeat_action)
except Exception, e:
self._safe_log('Failed to re-schedule Scheduler Heartbeat: %s' % str(e))
def restart(self):
print 'restart'
SpreadSheet.restart(self) #connect
scheduler.after(self.period, self.resync)
def start(self):
self._sid = scheduler.after(self.heartbeat_period,self._heartbeat_action)
assert not self._sid is None, 'SchedHeartbeat.start(): Failed to get non-None sid from scheduler'
CompositeNode.start(self)
self._running = 1
return
def start(self):
# Bad self IP Address
if(self.peer == '127.0.0.1' ):
msg='Cloud facility will not function properly because of local IP address being 127.0.0.1'
self.message(msg,msglog.types.WARN)
return
if not self.channel_monitor.is_running():
self.channel_monitor.start_monitor()
self._pdo=PersistentDataObject(self)
self.message('The Cloud Manager Persistent Object is in the file :%s' %str(self._pdo.filename()),msglog.types.INFO)
migration=False
if(os.path.exists(self._pdo.filename())):
# Already Migrated
self._pdo.formation=[self.peer]
self._pdo.portal=None
self._pdo.peer=self.peer
self._pdo.load()
else:
# We save a 'default' formation and expect the Cloud Configurator to
# update the _pdo.formation via update_information API.
# The _setup_formation gets called internally from update_information
self._pdo.portal=None
self._pdo.formation=[self.peer]
self._pdo.peer=self.peer
self._pdo.save()
self._pdo.load()
migration=True
#Bad formation/peer in the PDO
if( not self._pdo.peer in self._pdo.formation ):
#Bad formation/peer
self.message('The Cloud Manager PDO in the file :%s is corrupted. Defaulting to safe configuration' %str(self._pdo.filename()),msglog.types.WARN)
self._pdo.portal=None
self._pdo.formation=[self.peer]
self._pdo.peer=self.peer
self._pdo.save()
self._pdo.load()
self.message('Hosts are :%s portal=%s self=%s' %(str(self._pdo.formation),self._pdo.portal,self._pdo.peer),msglog.types.INFO)
self.nformation=NFormation(self._pdo.formation,self.peer)
self.nformation.set_portal(self._pdo.portal)
# IP Address Change Case
if(not utils.same_host(self.peer,self._pdo.peer)):
self.message('Self address change detected old=%s new=%s. Fixing the Cloud Formation accordingly' %(str(self._pdo.peer),self.peer),msglog.types.INFO)
formation = self.nformation.get_formation()
norm_form=self.nformation.normalize_formation(formation)
# IP Address Swap
self_index=norm_form.index(self._pdo.peer)
formation.pop(self_index)
formation.insert(0,self.peer)
self.nformation.set_formation(formation)
'''
In the Case of Migration, the update_formation() API is called
by the Cloud Configurator. In the already migrated case, we call the
update_formation() with the PDO formation and Portal
'''
self.target_formation = self.nformation.compute_targets()
if(migration == False):
self.update_formation(self.nformation.get_formation(), self.nformation.get_portal())
if self.subscription is None:
self.subscription = self.add_listener(
self.handle_formation_update, 'CloudFormation')
# Send Cloud Event to all the Hosts for re-sending the alarm events
# over to the Portal again - if we are nbmm
if(self.is_host_nbmm()):
scheduler.after(10, self.request_for_resending_alarm_events)
super(CloudManager, self).start()
def schedule(self, delay, callback, args=()):
return scheduler.after(delay, self.queue, (callback, args))
def start(self):
Client.start(self)
self.h_node = as_node(self.node)
self.h_alarms = self.h_node.get_child("tracer_alarm_points")
self.sid = scheduler.after(15, self.poll_alarms)
def start(self):
Client.start(self)
self.h_node = as_node(self.node)
self.h_alarms = self.h_node.get_child('tracer_alarm_points')
self.sid = scheduler.after(15, self.poll_alarms)
def schedule(self):
self.scheduled = scheduler.after(15, self.trigger)
def start(self):
Client.start(self)
self.h_node = as_node(self.node)
self.sid = scheduler.after(15, self.poll_alarms)
def _schedule_print(self):
self._scheduled = scheduler.after(60,self._print,(self._stack,))
def reschedule(self, period = None):
if period is None:
period = self.period
if self._running.isSet():
self._next_run = scheduler.after(period, self._queue_refresh)
def start(self):
Client.start(self)
self.h_node = as_node(self.node)
self.sid = scheduler.after(15, self.poll_alarms)
def reschedule(self, period=None):
if period is None:
period = self.period
if self._running.isSet():
self._next_run = scheduler.after(period, self._queue_refresh)
