def test_d(self):
files = ['file1_2']
# Create bogus persistent files
for f in files:
self._create_file(self._build_path(f))
self._dm.register('/test1/test2/test3', self._build_path('file1_2'),
GC_ONDELETE)
self._dm.set_faillist([])
# Now simulate a restart
self._local_restart()
# Create an actual node for test1
test1 = CompositeNode()
test1.configure({'parent': self.root, 'name': 'test1'})
test2 = CompositeNode()
test2.configure({'parent': test1, 'name': 'test2'})
test3 = CompositeNode()
test3.configure({'parent': test2, 'name': 'test3'})
# Register on test3's behalf
self._dm.register('/test1/test2/test3', self._build_path('file1_2'),
GC_ONDELETE)
self._dm.set_faillist([])
self._check_for_existance(['file1_2'])
def setUp(self):
DefaultTestFixture.setUp(self)
self.root = as_internal_node('/')
self.input = CompositeNode()
self.output = CompositeNode()
self.input.configure({'parent': self.root, 'name': 'input'})
self.output.configure({'parent': self.root, 'name': 'output'})
self.input_value = SimpleValue()
self.output_value = SimpleValue()
self.input_value.configure({'parent': self.input, 'name': 'value'})
self.output_value.configure({'parent': self.output, 'name': 'value'})
self.aliases = Aliases()
self.aliases.configure({'parent': self.root, 'name': 'aliases'})
self.alias_input = Alias()
self.alias_input.configure({
'parent': self.aliases,
'name': 'input',
'node_url': '/input/value'
})
self.alias_output = Alias()
self.alias_output.configure({
'parent': self.aliases,
'name': 'output',
'node_url': '/output/value'
})
self.input_value.set(1)
self.output_value.set(0)
return
def _setup(self):
ckts_svc_node = self.get_child('Circuits')
racks_svc_node = self.get_child('Racks')
dev_nodes = self._cpc_uhp_node.children_nodes()
has_CircuitStatus_node = 0
for dev_node in dev_nodes:
ckt_svc_nodes = []
if dev_node.has_child('Circuit'):
ckts_dev_node = dev_node.get_child('Circuit')
ckt_dev_nodes = ckts_dev_node.children_nodes()
for ckt_dev_node in ckt_dev_nodes:
ckt_name = ckt_dev_node.get_child('Name').get()
ckt_svc_node = CktStatusXltrNode(ckt_dev_node)
cd = {'parent': ckts_svc_node, 'name': ckt_dev_node.name}
ckt_svc_node.configure(cd)
ckt_svc_nodes.append(ckt_svc_node)
num_temps_node = ckt_dev_node.get_child(
'NumberOfTempSensors')
num_temps = num_temps_node.get()
if (num_temps is None) or isinstance(num_temps, Exception):
num_temps = 6
for i in range(num_temps):
case_temp_dev_node = ckt_dev_node.get_child(
'CaseTemps' + str(i))
case_temp_svc_node = CompositeNode()
cd = {
'parent': ckt_svc_node,
'name': str(case_temp_dev_node._obj_inst_num)
}
case_temp_svc_node.configure(cd)
status_svc_node = CktCaseTempsStatusXltrNode(
ckt_svc_node, case_temp_dev_node)
cd = {'parent': case_temp_svc_node, 'name': 'Status'}
status_svc_node.configure(cd)
descr_svc_node = SingleAttrNode('Not initialized')
cd = {
'parent': case_temp_svc_node,
'name': 'Description'
}
descr_svc_node.configure(cd)
self._cases.append([ckt_name, \
case_temp_dev_node._obj_inst_num, \
as_node_url(case_temp_dev_node), \
as_node_url(status_svc_node),
as_node_url(descr_svc_node)],)
rack_svc_node = CompositeNode()
cd = {'parent': racks_svc_node, 'name': dev_node.name}
rack_svc_node.configure(cd)
rack_status_node = RackStatusXltrNode(dev_node, ckt_svc_nodes)
cd = {'parent': rack_svc_node, 'name': 'Status'}
rack_status_node.configure(cd)
dev_name = dev_node._dev.get_name()
self._racks.append([dev_name, as_node_url(rack_status_node)])
return
def test_configure_sequence(self):
p = PeriodicLog()
p.configure({'name': 'log', 'parent': None, 'period': 1})
h = CompositeNode()
h.configure({'name': 'columns', 'parent': p})
c = PeriodicAverageColumn()
c.configure({
'position': 0,
'name': '2',
'parent': h,
'function': self._next
})
p.start()
try:
l = []
v = []
for i in range(0, 100):
l.append(c._evaluate())
v.append(i - 0.5)
if l.pop(0) != None:
raise 'First delta not None.'
v.pop(0)
for i in l:
j = v.pop(0)
if i != j:
raise 'Incorrect average of %s should be %s.' % (i, j)
finally:
p.stop()
return
def _setup_alarm_nodes(self):
services = as_node('/services')
if not services.has_child('External Alarms'):
alarms_node = CompositeNode()
alarms_node.configure({
'name': 'External Alarms',
'parent': services
})
alarms_node = as_node('/services/External Alarms')
alarm_node = alarms.Manager()
alarm_node.configure({'name': 'CPC Alarm', 'parent': alarms_node})
cpc_client_node = cpc_client.CpcClient(self._cpc_uhp_node)
cpc_client_node.configure({
'name': 'CPC Client',
'parent': alarm_node,
'node': ''
})
ewebconnect_client_node = ewebconnect.EWebConnectAlarmClient()
ewebconnect_client_node.configure({
'name': 'eWebConnect Alarm Client',
'parent': alarm_node,
'host': '10.0.1.88', #'mother.envenergy.com',
'port': 16161,
'enabled': 1,
})
alarms_node.start()
return
def setUp(self):
self._server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self._server_connection = None
self._bind()
self._parent = CompositeNode()
self._parent.configure({'name': 'parent', 'parent': None})
self._transporter = smtp_transporter.SMTPTransporter()
def test_configure_sequence_get(self):
p = PeriodicLog()
p.configure({'name': 'log', 'parent': None, 'period': 1})
h = CompositeNode()
h.configure({'name': 'columns', 'parent': p})
c = PeriodicDeltaColumn()
c.configure({
'position': 0,
'name': '2',
'parent': h,
'function': self._next
})
p.start()
try:
l = []
if c.get() != None:
raise 'Get didn\'t return None on first get'
if c.get() != None:
raise 'Get didn\'t return None on second get'
self.seq.value = 0
c.function()
self._next()
self._next()
self._next()
if c.get() != self.seq.value - 1:
raise 'Got incorrect value after incrementing'
finally:
p.stop()
return
def test_configure_sequence(self):
p = PeriodicLog()
p.configure({'name': 'log', 'parent': None, 'period': 1})
h = CompositeNode()
h.configure({'name': 'columns', 'parent': p})
c = PeriodicDeltaColumn()
c.configure({
'position': 0,
'name': '2',
'parent': h,
'function': self._next
})
p.start()
try:
l = []
for i in range(0, 100):
l.append(c.function())
if l.pop(0) != None:
raise 'First delta not None.'
for i in l:
if i != 1:
raise 'Incoreect delta of %s should be %s.' % (i, 1)
finally:
p.stop()
return
def start(self):
if self.__running:
return
if self.debug:
msglog.log('EnergywiseManager :', msglog.types.INFO,
'Inside start')
CompositeNode.start(self)
# start_node = as_node('/services/EnergywiseManager/')
# self.configure_trend_in_switches(start_node, 60)
self.__running = True
self._pdo_lock.acquire()
self._pdo = PersistentDataObject(self, dmtype=GC_NEVER)
self._pdo.trends = {}
self._pdo.load()
self._pdo_lock.release()
if self.has_child('trends'):
self.trends = self.get_child('trends')
else:
self.trends = CompositeNode()
self.trends.configure({'parent': self, 'name': 'trends'})
self.trends.start()
# start trending for saved domains
for domain, freq in self._pdo.trends.items():
try:
start_node = as_node(domain)
# self.configure_trend_in_switches( start_node,freq )
start_node.new_trend(freq)
except:
self.delete_trend_configuration(domain)
return
def _helper_test_interfaces(self, name):
F = 'mpx.ion.host.mediator_%s' % name
host = factory(F)
n = CompositeNode()
n.configure({'name':name, 'parent':None})
host.configure({'name':'interfaces', 'parent':n})
_dump_cd(n) # Compare this...
return
def _start_thread(self):
# Create a CPC_UHP node under proper COM port:
com_port_node = as_node('/interfaces/' + self.com_port)
self._cpc_uhp_node = CpcNode()
cd = {'parent': com_port_node, 'name': 'CPC_UHP'}
self._cpc_uhp_node.configure(cd)
self._cpc_uhp_node.start()
# Create Circuits and Racks children:
ckts_svc_node = CompositeNode()
cd = {'parent': self, 'name': 'Circuits'}
ckts_svc_node.configure(cd)
racks_svc_node = CompositeNode()
cd = {'parent': self, 'name': 'Racks'}
racks_svc_node.configure(cd)
# Force complete autodiscovery to create CPC node subtree:
start_time = time.time()
dev_nodes = self._cpc_uhp_node.children_nodes()
for dev_node in dev_nodes:
item_type_nodes = dev_node.children_nodes()
for item_type_node in item_type_nodes:
item_nodes = item_type_node.children_nodes()
for item_node in item_nodes:
obj_nodes = item_node.children_nodes()
for obj_node in obj_nodes:
prop_nodes = obj_node.children_nodes()
self.debug_print(
'%s: Finished autodiscover of CPC_UHP nodetree' % time.time(), 1)
# Scan CPC_UHP subnodetree for nodes needed for Vista handler clients:
self._setup()
self.debug_print('%s: Finished _setup()' % time.time(), 1)
ckts_svc_node.start() # starts all children as well
racks_svc_node.start() # starts all children as well
self.debug_print(
'%s: Finished starting Circuits and Racks children of vista_cpc node'
% time.time(), 1)
##
# Create a CpcClient at proper place in nodetree:
self._setup_alarm_nodes()
self.debug_print('%s: Finished creating Alarm CpcClient' % time.time(),
1)
self._start_thread_inst = None
self._ready = 1
return
def start(self):
try:
self._pdo_lock.acquire()
try:
if self.__running:
return
self.__running = True
self._trendconfig = PersistentDictionary(filename(self),
encode=None,
decode=None)
if not self._trendconfig:
pdodata = PersistentDataObject(self, dmtype=GC_NEVER)
if os.path.exists(pdodata.filename()):
msglog.log('broadway', msglog.types.INFO,
"Migrating previous trend data")
pdodata.trends = {}
pdodata.load()
self._trendconfig.update(pdodata.trends)
del (pdodata)
finally:
self._pdo_lock.release()
super(TrendManager, self).start()
self.logger = node.as_internal_node(self.logger_url)
if self.has_child('trends'):
self.trends = self.get_child('trends')
else:
self.trends = CompositeNode()
self.trends.configure({'parent': self, 'name': 'trends'})
self.trends.start()
corrupt_trends = []
for trendname, trenddump in self._trendconfig.items():
msg = "Loading trend: %s" % trendname
msglog.log('trendmanager', msglog.types.INFO, msg)
try:
trend = unmarshal(trenddump)
except:
corrupt_trends.append(trendname)
msg = "Failed to load trend: %s" % trendname
msglog.log('trendmanager', msglog.types.ERR, msg)
msglog.exception(prefix='Handled')
for trendname in corrupt_trends:
try:
msg = "Deleting trend information: %s" % trendname
msglog.log('trendmanager', msglog.types.INFO, msg)
self._delete_trend_configuration(trendname)
if self.trends.has_child(trendname):
trend = self.trends.get_child(trendname)
trend.prune(force=True)
except:
msglog.exception(prefix='Handled')
except:
self.__running = False
raise
return
def test_configure_1(self):
p = PeriodicLog()
p.configure({'name':'log','parent':None, 'period':1})
h = CompositeNode()
h.configure({'name':'columnholder','parent':p})
c = PeriodicColumn()
c.configure({'position':0, 'name':'0', 'parent':h,
'function':self._random, 'args':()})
c.start()
try:
c.function()
finally:
c.stop()
return
def _test_e(self):
files = ['file1_2']
# Create bogus persistent files
for f in files:
self._create_file(self._build_path(f))
self._dm.register('/test1/test2/test3', self._build_path('file1_2'),
GC_ONDELETE)
self._dm.set_faillist([])
# Now simulate a restart
self._local_restart()
# Create an actual node for test1
test1 = CompositeNode()
test2 = CompositeNode()
test3 = CompositeNode()
test1.configure({'parent': self.root, 'name': 'test1'})
test2.configure({'parent': test1, 'name': 'test2'})
test3.configure({'parent': test2, 'name': 'test3'})
self.root.start()
x = as_node('/test1/test2/test3')
# Skip Registering on test3's behalf
self._dm.set_faillist([])
# The persistent file should still be there because the node exists,
# even though it didn't register. It should be kept because the node
# definitely has not been deleted, but probably had a failure on
# startup (and the purging policy was GC_ONDELETE).
self._check_for_existance(['file1_2'])
def test_configure_2(self):
p = PeriodicLog()
p.configure({'name':'log','parent':None, 'period':1})
h = CompositeNode()
h.configure({'name':'columnholder','parent':p})
c = PeriodicColumn()
c.configure({'position':1, 'name':'1', 'parent':h,
'context':'import random', 'function':'random.uniform',
'args':'(0,100)'})
c.start()
try:
c.function()
finally:
c.stop()
return
def test_configure_3(self):
p = PeriodicLog()
p.configure({'name':'log','parent':None, 'period':1})
h = CompositeNode()
h.configure({'name':'columnholder','parent':p})
c = PeriodicColumn()
c.configure({'position':2, 'name':'2', 'parent':h,
'context':'',
'function':'mpx.lib.node.as_node("/").configuration',
'args':'()','conversion':'none'})
c.start()
try:
c.function()
finally:
c.stop()
return
def setUp(self):
self._server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self._server_connection = None
self._bind()
parent = CompositeNode()
parent.configure({'name': 'parent', 'parent': None})
self._transporter = http_post_transporter.HTTPPostTransporter()
self._transporter.configure({
'name':
'transporter',
'parent':
parent,
'post_url':
'http://localhost:%s/test' % self._port,
'timeout':
'1'
})
def __init__(self, name, poll_all):
self._name = name
self._run = 0
self._running = 0
self._sid = 0
self._changed_values = {}
self._values = {}
self._poll_all = poll_all
self.DELAY = 0.0
self.__doc['DELAY'] = 'Delay in seconds between polling for values.'
root = as_internal_node('/')
if not root.has_child(name):
anchor = CompositeNode()
anchor.configure({'name':name,'parent':root})
self._anchor = anchor
t = Time()
t.configure({'name':'time', 'parent':anchor})
t.start()
return
def test_configure_random(self):
p = PeriodicLog()
p.configure({'name': 'log', 'parent': None, 'period': 1})
h = CompositeNode()
h.configure({'name': 'columns', 'parent': p})
c = PeriodicAverageColumn()
c.configure({
'position': 0,
'name': '0',
'parent': h,
'function': self._random,
'args': ()
})
p.start()
try:
for i in range(0, 1000):
c.function()
finally:
p.stop()
return
def test_configure_context_random(self):
p = PeriodicLog()
p.configure({'name': 'log', 'parent': None, 'period': 1})
h = CompositeNode()
h.configure({'name': 'columns', 'parent': p})
c = PeriodicDeltaColumn()
c.configure({
'position': 0,
'name': '1',
'parent': h,
'context': 'import random',
'function': 'random.uniform',
'args': '(0,100)'
})
p.start()
try:
for i in range(0, 1000):
c.function()
finally:
p.stop()
return
def start(self):
if not self.has_child('WS Response'):
self.wsresponse = CompositeNode()
self.wsresponse.configure({'parent': self, 'name': 'WS Response'})
self.xmlnodes = xmldata.XMLDataNode()
self.xmlnodes.configure({
'name': 'XML Nodes',
'parent': self.wsresponse
})
self.soapnodes = soapdata.SOAPDataNode()
self.soapnodes.configure({
'name': 'SOAP Nodes',
'parent': self.wsresponse
})
else:
self.wsresponse = self.get_child('WS Response')
self.xmlnodes = self.wsresponse.get_child('XML Nodes')
self.soapnodes = self.wsresponse.get_child('SOAP Nodes')
self.setup()
super(CNEPricing, self).start()
def start(self):
if not self.has_child('WS Response'):
self.wsresponse = CompositeNode()
self.wsresponse.configure({'parent': self, 'name': 'WS Response'})
self.xmlnodes = xmldata.XMLDataNode()
self.xmlnodes.configure({
'name': 'XML Nodes',
'parent': self.wsresponse
})
self.soapnodes = soapdata.SOAPDataNode()
self.soapnodes.configure({
'name': 'SOAP Nodes',
'parent': self.wsresponse
})
else:
self.wsresponse = self.get_child('WS Response')
self.xmlnodes = self.wsresponse.get_child('XML Nodes')
self.soapnodes = self.wsresponse.get_child('SOAP Nodes')
if not self.has_child('Start time'):
nodepath = path.join(as_node_url(self.soapnodes),
'GetAlertsResult/disp/emralert')
self.startnode = AttributeNode()
self.startnode.configure({
'name': 'Start time',
'nodeurl': nodepath,
'attribute': 'start',
'parent': self
})
self.endnode = AttributeNode()
self.endnode.configure({
'name': 'End time',
'nodeurl': nodepath,
'attribute': 'end',
'parent': self
})
self.setup()
super(CNEDispatch, self).start()
def _configure(self):
p = PeriodicLog()
p.configure({'name': 'log', 'parent': None, 'period': 1})
h = CompositeNode()
h.configure({'name': 'columnholder', 'parent': p})
# Add a compiled function with compile arguments.
c = PeriodicColumn()
c.configure({
'position': 0,
'name': '0',
'parent': h,
'function': self._random,
'args': ()
})
self.collector.add_column(c)
# Add a string function, context and arguments.
c = PeriodicColumn()
c.configure({
'position': 1,
'name': '1',
'parent': h,
'context': 'import random',
'function': 'random.uniform',
'args': '()'
})
self.collector.add_column(c)
# Add a node column.
c = PeriodicColumn()
c.configure({
'position': 2,
'name': '2',
'parent': h,
'context': '',
'function': 'mpx.lib.node.as_node("/").configuration',
'args': '()'
})
self.collector.add_column(c)
def test_add_entry_event(self):
class Consumer(EventConsumerAbstract):
def __init__(self, *args, **kw):
EventConsumerAbstract.__init__(self, *args, **kw)
self.entries = []
self.errors = []
self.lock = Lock()
def event_thread(self,event):
# The values returned in the event:
values = event.values
# The column as read from the source Log instance:
column_dict = event.source[event.seq]
# A map of COLUMN_DICT keys to VALUES indexes.
column_value_map = {
'c0':0,
}
# Validate that the list of values matches the actual column in
# the log:
for key,index in column_value_map.items():
if not column_dict.has_key(key):
self.errors.append('column_dict has no %r key.' % key)
return
if index >= len(values):
self.errors.append('Index(%r) >= len(values:%r).' %
(index, len(values)))
return
if column_dict[key] != values[index]:
self.errors.append(
'column_dict[%r]:%r != values[%r]:%r' % (
key, column_dict[key], index, values[index]))
return
self.lock.acquire()
try:
# If any entries are left, the test will fail.
self.entries.remove(values)
except:
# Also, if errors is not empty the test will fail.
self.errors.append("Failed to find %r in entries." %
values)
self.lock.release()
def event_handler(self,event):
t = Thread(target=self.event_thread, args=(event,))
t.start()
return
consumer = Consumer()
p = PeriodicLog()
p.configure({'name':'log','parent':None, 'period':0})
h = CompositeNode()
h.configure({'name':'columns','parent':p})
c = PeriodicColumn()
c.configure({'position':0, 'name':'c0', 'parent':h,
'function':'None',})
p.event_subscribe(consumer, LogAddEntryEvent)
p.start()
try:
for c0 in range(0,10):
entry = [c0,]
consumer.entries.append(entry)
p.add_entry(entry)
t1 = time.time()
while consumer.entries:
if (time.time() - t1) >= 1.0:
msgs = [
"Failed to recieve matching events after 1 second."
]
msgs.extend(consumer.errors)
self.fail('\n'.join(msgs))
pause(0.1)
finally:
p.stop()
return
def test_f(self):
files = ['file1_2', 'file1_3']
# Create bogus persistent files
for f in files:
self._create_file(self._build_path(f))
# Our node tree is going to look like:
# /test1/
# /test2
# /test1
# /services
# /garbage_collector
# Simulate first startup, everything happy
test1 = CompositeNode()
test2 = CompositeNode()
test3 = CompositeNode()
test1.configure({'parent': self.root, 'name': 'test1'})
test2.configure({'parent': test1, 'name': 'test2'})
test3.configure({'parent': test2, 'name': 'test1'})
self._dm.register('/test1/test2', self._build_path('file1_2'),
GC_ONDELETE)
self._dm.register('/test1/test2/test1', self._build_path('file1_3'),
GC_ONDELETE)
self._dm.set_faillist([])
# Now simulate a restart
self._local_restart()
# Simulate second startup, /test1/test2 fails to config and
# /test1/test2/test1 has been deleted. At this point, the persistent
# data for /test1/test2/test1 should still exist.
test1 = CompositeNode()
test2 = CompositeNode()
test3 = CompositeNode()
test1.configure({'parent': self.root, 'name': 'test1'})
test2.configure({'parent': test1, 'name': 'test2'})
self._dm.set_faillist([{
'name': 'test2',
'parent': '/test1',
'type': 'config'
}])
self._check_for_existance(files)
# Now simulate a restart
self._local_restart()
# OK, finally simulate a third startup, /test1/test2 comes up happily.
# At this point, the Garbage Collector should figure out that
# /test1/test2/test1 has been deleted and get rid of it's persistent
# data.
test1 = CompositeNode()
test2 = CompositeNode()
test3 = CompositeNode()
test1.configure({'parent': self.root, 'name': 'test1'})
test2.configure({'parent': test1, 'name': 'test2'})
self._dm.register('/test1/test2', self._build_path('file1_2'),
GC_ONDELETE)
self._dm.set_faillist([])
self._check_for_non_existance(['file1_3'])
self._check_for_existance(['file1_2'])
dr2 = dispatch.GetAlerts.getResponseData()
##
# Invoke pricing using timestamp of alerts example
tspricing = '01/11/2008'
pricing.GetPrice(zone, tspricing, username, password)
pr2 = pricing.GetPrice.getResponse()
##
# Create DOM document objects from responses
drdom = asDom(dr2)
prdom = asDom(pr2)
from mpx.lib.node import CompositeNode
results = CompositeNode()
results.configure({'name': 'Results', 'parent': '/services/network'})
results.start()
def setupnodes(*elements):
for childnode in results.children_nodes():
if isinstance(childnode, form.ElementNode):
childnode.prune()
reload(form)
domnodes = []
for element in elements:
domnode = form.ElementNode()
domnode.configure({'element': element, 'parent': results})
domnode.start()
domnodes.append(domnode)
