Exemplo n.º 1
0
 def cancel_batch_async(self, sessionID):
   if self._subscriptions.has_key(sessionID):
       try:
         subscription = self._subscriptions[sessionID]
         del self._subscriptions[sessionID]
         del self._qualified_method_list[sessionID]
         del self._services[sessionID]
         del self._methods[sessionID]
         SUBSCRIPTION_MANAGER.destroy(subscription)
       except:
         msglog.log('RNA_XMLRPC_Handler',msglog.types.WARN,
                    "Error destroying subscription %r." % (subscription,))
         msglog.exception()
   return
Exemplo n.º 2
0
 def cancel_batch_async(self, sessionID):
     if self._subscriptions.has_key(sessionID):
         try:
             subscription = self._subscriptions[sessionID]
             del self._subscriptions[sessionID]
             del self._qualified_method_list[sessionID]
             del self._services[sessionID]
             del self._methods[sessionID]
             SUBSCRIPTION_MANAGER.destroy(subscription)
         except:
             msglog.log(
                 'RNA_XMLRPC_Handler', msglog.types.WARN,
                 "Error destroying subscription %r." % (subscription, ))
             msglog.exception()
     return
Exemplo n.º 3
0
 def nodebrowser_handler(self, nb, path, node, node_url):
     # the purpose of this special handler is to get all the points in
     # one subscription instead of individually.  This greatly speeds up
     # the rz net peer driver
     sid = None
     html = ''
     if len(self.children_names()):
         node_table = {}
         for c in self.children_nodes():  #pre AML
             if isinstance(c, PointNode):
                 node_table[id(c)] = c
         if len(node_table):
             sid = SM.create_polled(node_table)
     try:
         html = nb.get_default_view(node, node_url)
     finally:
         if sid:
             SM.destroy(sid)
     return html
Exemplo n.º 4
0
 def nodebrowser_handler(self, nb, path, node, node_url):
     # the purpose of this special handler is to get all the points in 
     # one subscription instead of individually.  This greatly speeds up
     # the rz net peer driver
     sid = None
     html = ''
     if len(self.children_names()):
         node_table = {}
         for c in self.children_nodes(): #pre AML
             if isinstance(c, PointNode):
                 node_table[id(c)]=c
         if len(node_table):
             sid = SM.create_polled(node_table)
     try:
         html = nb.get_default_view(node, node_url)
     finally:
         if sid:
             SM.destroy(sid)
     return html
Exemplo n.º 5
0
 def resync(self):
     try:
         print 'resync'
         new_sheet = self.get_sheet()
         #subscribe to nodes that need to be read
         sub_dict = {} #dictionary to create subscriptions
         for row_index in new_sheet.keys():
             url, mode, value = new_sheet[row_index]
             if mode < 3: #need to subscribe to non-write-only
                 sub_dict[row_index] = url
             #for nodes that need to be set from values in the spreadsheet
             if mode == 2 or mode == 3: #need to set
                 try:
                     as_node(url).set(value) #value is a string or None
                 except:
                     msglog.exception()
         self.sheet = new_sheet
         if sub_dict: #create a new subscription then delete the old one
             sid = SM.create_polled(sub_dict)
             if self.sid:
                 SM.destroy(self.sid)
             self.sid = sid
             sub_dict = SM.poll_all(sid)
             self.node_values = sub_dict
             #update the spread sheet
             for row_index in sub_dict.keys():
                 url, mode, value = new_sheet[row_index]
                 if mode == 0 or mode == 1: #need to write
                     try:
                         self.set_cell(row_index, 3, sub_dict[row_index]['value']) 
                     except:
                         msglog.exception()
         #the spreadsheet and mediator should now be in sync
         self.scan()
     except:
         msglog.exception()
 def test_destroy_batch(self):
     sids = []
     for i in range(2):
         # BatchNodes change "really fast."
         sid = SUBSCRIPTION_MANAGER.create_polled(self.nrtB10)
         # Make sure it comes up.
         t1 = time.time()
         self.__values_changing(sid)
         sids.append(sid)
     # Double check the values are changing.
     for sid in sids:
         self.__values_changing(sid)
     # Now nuke one of the suscriptions and see that the other stays valid.
     sid = sids.pop(0)
     SUBSCRIPTION_MANAGER.destroy(sid)
     try:
         SUBSCRIPTION_MANAGER.destroy(sid)
     except ENoSuchSubscription:
         pass
     else:
         raise "No such subscription not detected."
     # Make sure that the other subscription is valid.
     sid = sids.pop(0)
     self.__values_changing(sid)
     if len(SUBSCRIPTION_MANAGER.diag_get_mnrs()) != 10:
         raise (
             "Bogus test, there should be 10 mnr at this point, not %r." %
             len(SUBSCRIPTION_MANAGER.diag_get_mnrs()))
     if len(SUBSCRIPTION_MANAGER.diag_get_mnbs()) != 1:
         raise (
             "Bogus test, there should be 1 mnb at this point, not %r." %
             len(SUBSCRIPTION_MANAGER.diag_get_mnbs()))
     SUBSCRIPTION_MANAGER.destroy(sid)
     # Make sure that the mnr is removed when the last snr is deleted.
     if len(SUBSCRIPTION_MANAGER.diag_get_mnrs()) != 0:
         raise (
             "There should not be any mnrs at this point,"
             " but there are %r." %
             len(SUBSCRIPTION_MANAGER.diag_get_mnrs()))
     # Finally, make sure that the mnb is removed when the last mnr is
     # deleted.
     if len(SUBSCRIPTION_MANAGER.diag_get_mnbs()) != 0:
         raise (
             "There should not be any mnbs at this point,"
             " but there are %r." %
             len(SUBSCRIPTION_MANAGER.diag_get_mnbs()))
     return
 def test_destroy_batch(self):
     sids = []
     for i in range(2):
         # BatchNodes change "really fast."
         sid = SUBSCRIPTION_MANAGER.create_polled(self.nrtB10)
         # Make sure it comes up.
         t1 = time.time()
         self.__values_changing(sid)
         sids.append(sid)
     # Double check the values are changing.
     for sid in sids:
         self.__values_changing(sid)
     # Now nuke one of the suscriptions and see that the other stays valid.
     sid = sids.pop(0)
     SUBSCRIPTION_MANAGER.destroy(sid)
     try:
         SUBSCRIPTION_MANAGER.destroy(sid)
     except ENoSuchSubscription:
         pass
     else:
         raise "No such subscription not detected."
     # Make sure that the other subscription is valid.
     sid = sids.pop(0)
     self.__values_changing(sid)
     if len(SUBSCRIPTION_MANAGER.diag_get_mnrs()) != 10:
         raise (
             "Bogus test, there should be 10 mnr at this point, not %r." %
             len(SUBSCRIPTION_MANAGER.diag_get_mnrs()))
     if len(SUBSCRIPTION_MANAGER.diag_get_mnbs()) != 1:
         raise ("Bogus test, there should be 1 mnb at this point, not %r." %
                len(SUBSCRIPTION_MANAGER.diag_get_mnbs()))
     SUBSCRIPTION_MANAGER.destroy(sid)
     # Make sure that the mnr is removed when the last snr is deleted.
     if len(SUBSCRIPTION_MANAGER.diag_get_mnrs()) != 0:
         raise ("There should not be any mnrs at this point,"
                " but there are %r." %
                len(SUBSCRIPTION_MANAGER.diag_get_mnrs()))
     # Finally, make sure that the mnb is removed when the last mnr is
     # deleted.
     if len(SUBSCRIPTION_MANAGER.diag_get_mnbs()) != 0:
         raise ("There should not be any mnbs at this point,"
                " but there are %r." %
                len(SUBSCRIPTION_MANAGER.diag_get_mnbs()))
     return
Exemplo n.º 8
0
 def stop(self):
     CompositeNode.stop(self)
     if self._smid:
         SM.destroy(self._smid)
         self._smid = None
Exemplo n.º 9
0
    def invoke_batch_async(self, sessionID, *qualified_method_list):
        subscription = None
        if not self.manager().validate(sessionID, touch=1):
            if self._subscriptions.has_key(sessionID):
                try:
                    subscription = self._subscriptions[sessionID]
                    del self._subscriptions[sessionID]
                    del self._qualified_method_list[sessionID]
                    del self._services[sessionID]
                    del self._methods[sessionID]
                    SUBSCRIPTION_MANAGER.destroy(subscription)
                except:
                    msglog.log(
                        'RNA_XMLRPC_Handler', msglog.types.WARN,
                        "Error destroying subscription %r on stale session %r."
                        % (subscription, sessionID))
                    msglog.exception()
            raise EInvalidSession('Invalid session')

        if self._subscriptions.has_key(sessionID):
            subscription = self._subscriptions[sessionID]
            if (self._qualified_method_list[sessionID] !=
                    qualified_method_list):
                # New batch, destroy the out of date subscription.
                try:
                    del self._subscriptions[sessionID]
                    del self._qualified_method_list[sessionID]
                    del self._services[sessionID]
                    del self._methods[sessionID]
                    SUBSCRIPTION_MANAGER.destroy(subscription)
                except:
                    msglog.log(
                        'RNA_XMLRPC_Handler', msglog.types.WARN,
                        "Error destroying previous subscription %r." %
                        (subscription, ))
                    msglog.exception()
                subscription = None

        if subscription is None:
            #
            # No subscription matching the batch, create one!
            # Build a node_reference_table:
            subscription_map = {}
            services = []
            methods = []
            for i in range(0, len(qualified_method_list)):
                rna = qualified_method_list[i]
                i_method = rna.rfind(':')
                if i_method == -1 or (i_method == 3 and rna[:3] == "mpx"):
                    # There is no method specified.
                    rna_node = rna
                    rna_method = ''
                else:
                    rna_node = rna[:i_method]
                    rna_method = rna[i_method + 1:]
                services.append(rna_node)
                methods.append(rna_method)
                if methods[i] == 'get':
                    subscription_map[services[i]] = services[i]
            # Create the subscription using the genereated node_reference_table:
            subscription = SUBSCRIPTION_MANAGER.create_polled(
                subscription_map, 5 * 60.0)
            self._subscriptions[sessionID] = subscription
            self._qualified_method_list[sessionID] = qualified_method_list
            self._services[sessionID] = services
            self._methods[sessionID] = methods
            #
            # Now that we've added our node's, validate the other sessions.
            #
            validate_list = []
            validate_list.extend(self._subscriptions.keys())
            for test_session in validate_list:
                if not self.manager().validate(test_session, touch=0):
                    expired = None
                    try:
                        expired = self._subscriptions[test_session]
                        del self._subscriptions[test_session]
                        del self._qualified_method_list[test_session]
                        del self._services[test_session]
                        del self._methods[test_session]
                        SUBSCRIPTION_MANAGER.destroy(expired)
                    except:
                        msglog.log(
                            'RNA_XMLRPC_Handler', msglog.types.WARN,
                            "Error destroying subscription %r on stale session %r."
                            % (expired, test_session))
                        msglog.exception()
        # Get all 'ready' values.
        services = self._services[sessionID]
        methods = self._methods[sessionID]
        polled_values = SUBSCRIPTION_MANAGER.poll_all(subscription)
        results = []
        for i in range(0, len(services)):
            service = services[i]
            try:
                if methods[i] == 'get':
                    result = polled_values[service]
                    if result is None:
                        result = 'error: Waiting for update...'
                    else:
                        result = result['value']
                    if isinstance(result, Exception):
                        result = self._exception_string(result)
                else:
                    result = 'error: %r method not supported, only get().' % (
                        methods[i])
                results.append(result)
            except Exception, e:
                results.append(self._exception_string(e))
Exemplo n.º 10
0
 def subscription_destroy(self, sessionID, sid):
     # Raise exception if this is not a valid session
     if not self.manager().validate(sessionID, touch=1):
         raise EInvalidSession('Invalid session')
     return SUBSCRIPTION_MANAGER.destroy(sid)
Exemplo n.º 11
0
 def stop(self):
     CompositeNode.stop(self)
     if self._smid:
         SM.destroy(self._smid)
         self._smid = None
Exemplo n.º 12
0
  def invoke_batch_async(self, sessionID, *qualified_method_list):
    subscription = None
    if not self.manager().validate(sessionID, touch=1):
      if self._subscriptions.has_key(sessionID):
        try:
          subscription = self._subscriptions[sessionID]
          del self._subscriptions[sessionID]
          del self._qualified_method_list[sessionID]
          del self._services[sessionID]
          del self._methods[sessionID]
          SUBSCRIPTION_MANAGER.destroy(subscription)
        except:
          msglog.log('RNA_XMLRPC_Handler',msglog.types.WARN,
                     "Error destroying subscription %r on stale session %r." %
                     (subscription, sessionID))
          msglog.exception()
      raise EInvalidSession('Invalid session')

    if self._subscriptions.has_key(sessionID):
      subscription = self._subscriptions[sessionID]
      if (self._qualified_method_list[sessionID] != qualified_method_list):
        # New batch, destroy the out of date subscription.
        try:
          del self._subscriptions[sessionID]
          del self._qualified_method_list[sessionID]
          del self._services[sessionID]
          del self._methods[sessionID]
          SUBSCRIPTION_MANAGER.destroy(subscription)
        except:
          msglog.log('RNA_XMLRPC_Handler',msglog.types.WARN,
                     "Error destroying previous subscription %r." %
                     (subscription,))
          msglog.exception()
        subscription = None

    if subscription is None:
      #
      # No subscription matching the batch, create one!
      # Build a node_reference_table:
      subscription_map = {}
      services = []
      methods = []
      for i in range(0,len(qualified_method_list)):
        rna = qualified_method_list[i]
        i_method = rna.rfind(':')
        if i_method == -1 or (i_method == 3 and rna[:3] == "mpx"):
          # There is no method specified.
          rna_node = rna
          rna_method = ''
        else:
          rna_node = rna[:i_method]
          rna_method = rna[i_method+1:]
        services.append(rna_node)
        methods.append(rna_method)
        if methods[i] == 'get':
          subscription_map[services[i]] = services[i]
      # Create the subscription using the genereated node_reference_table:
      subscription = SUBSCRIPTION_MANAGER.create_polled(subscription_map,
                                                        5*60.0)
      self._subscriptions[sessionID] = subscription
      self._qualified_method_list[sessionID] = qualified_method_list
      self._services[sessionID] = services
      self._methods[sessionID] = methods
      #
      # Now that we've added our node's, validate the other sessions.
      #
      validate_list = []
      validate_list.extend(self._subscriptions.keys())
      for test_session in validate_list:
        if not self.manager().validate(test_session, touch=0):
          expired = None
          try:
            expired = self._subscriptions[test_session]
            del self._subscriptions[test_session]
            del self._qualified_method_list[test_session]
            del self._services[test_session]
            del self._methods[test_session]
            SUBSCRIPTION_MANAGER.destroy(expired)
          except:
            msglog.log('RNA_XMLRPC_Handler',msglog.types.WARN,
                       "Error destroying subscription %r on stale session %r." %
                       (expired, test_session))
            msglog.exception()
    # Get all 'ready' values.
    services = self._services[sessionID]
    methods = self._methods[sessionID]
    polled_values = SUBSCRIPTION_MANAGER.poll_all(subscription)
    results = []
    for i in range(0,len(services)):
      service = services[i]
      try:
        if methods[i] == 'get':
          result = polled_values[service]
          if result is None:
              result = 'error: Waiting for update...'
          else:
              result = result['value']
          if isinstance(result,Exception):
            result = self._exception_string(result)
        else:
          result = 'error: %r method not supported, only get().' % (
            methods[i]
            )
        results.append(result)
      except Exception, e:
        results.append(self._exception_string(e))
Exemplo n.º 13
0
 def subscription_destroy(self, sessionID, sid):
   # Raise exception if this is not a valid session
   if not self.manager().validate(sessionID, touch=1):
     raise EInvalidSession('Invalid session')
   return SUBSCRIPTION_MANAGER.destroy(sid)