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'])
Ejemplo n.º 2
0
 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
Ejemplo n.º 3
0
 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
Ejemplo n.º 4
0
 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
Ejemplo n.º 5
0
 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
Ejemplo n.º 6
0
 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()
Ejemplo n.º 7
0
 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
Ejemplo n.º 8
0
 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
Ejemplo n.º 9
0
 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
Ejemplo n.º 10
0
 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
Ejemplo n.º 11
0
 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
Ejemplo n.º 12
0
 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
Ejemplo n.º 17
0
 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
Ejemplo n.º 19
0
 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
Ejemplo n.º 20
0
 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
Ejemplo n.º 21
0
    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()
Ejemplo n.º 22
0
    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()
Ejemplo n.º 23
0
 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)
Ejemplo n.º 24
0
 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'])
Ejemplo n.º 26
0
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)