Exemplo n.º 1
0
def process_call_function_command(message, sender, connection):
    try:
        interface = autobus.lookup_interface(message["interface_name"])
        function = interface.lookup_function(message["function"])
    except (autobus.NoSuchInterfaceException, autobus.NoSuchFunctionException) as e:
        connection.send_error(message, text=str(e))
        return
    if function.special:
        function.invoke_special(message, connection)
        return
    invoke_message = create_message(RunFunctionCommand,
            interface_name=interface.name, function=function.name,
            arguments=message["arguments"])
    interface.connection.send(invoke_message)
    print ("Sending run command to " + str(interface.connection.id) + 
            " with message id " + str(invoke_message["message_id"]) + 
            " whose response is to be forwarded with id " + 
            str(message["message_id"]))
    # FIXME: This causes a response to a function invocation sent as a notification
    # to still be sent when the function returns on the remote side. We need to
    # somehow not add the message to this list and perhaps suppress the "sporadic
    # message received" warning that would consequently be printed to stdout once
    # the remote client sends back the return value if the incoming message here
    # is a notification.
    interface.connection.pending_responses[invoke_message["message_id"]] = (
            sender, message["message_id"])
Exemplo n.º 2
0
def process_register_listener_command(message, sender, connection):
    interface_name = message["interface_name"]
    event_name = message["event_name"]
    autobus.register_event_listener(interface_name, event_name, sender)
    connection.listeners.append((interface_name, event_name))
    response = create_message(RegisterListenerResponse,
            message, interface_name=interface_name, event_name=event_name)
    connection.send(response)
Exemplo n.º 3
0
def process_activate_hack_command(message, sender, connection):
    hack = message["hack"]
    valid = True
    if hack == "buffer":
        print "Buffer hack activated for connection " + str(sender)
        connection.output_thread.enable_buffer_hack = True
    else:
        valid = False
    if valid:
        connection.send(create_message(ActivateHackResponse, message))
    else:
        connection.send_error(message, text="No such hack: " + str(hack))
Exemplo n.º 4
0
 def invoke_special(self, message, connection):
     args = message["arguments"]
     args = [decode_object(arg) for arg in args]
     try:
         return_value = self.special_target(*args)
     except Exception as e:
         print_exc()
         return_value = e
     result = encode_object(return_value)
     response = create_message(CallFunctionResponse,
             message, return_value=result)
     connection.send(response)
Exemplo n.º 5
0
def process_register_interface_command(message, sender, connection):
    name = message["name"]
    doc = message["doc"]
    print "Registering interface with name " + name
    interface = autobus.Interface(name, connection, doc)
    try:
        interface.register()
    except KeyError:
        connection.send_error(message, text="An interface with the same name "
                "is already registered.")
        return
    response = create_message(RegisterInterfaceResponse, message)
    connection.send(response)
Exemplo n.º 6
0
def process_get_object_value_command(message, sender, connection):
    interface_name = message["interface_name"]
    object_name = message["object_name"]
    try:
        interface = autobus.lookup_interface(interface_name)
        object = interface.object_map[object_name]
        object_value = object.get()
    except (autobus.NoSuchInterfaceException, KeyError): # Object doesn't exist yet
        object_value = encode_object(None)
    response = create_message(GetObjectValueResponse,
            message, interface_name=interface_name, object_name=object_name,
            value=object_value)
    connection.send(response)
Exemplo n.º 7
0
 def send_error(self, in_reply_to=None, **kwargs):
     """
     Sends an error back to the client. If in_reply_to is itself a
     notification message, no message will be sent back. Otherwise, an
     ErrorResponse to the specified message will be sent. The error's
     fields will be initialized to have any additional keyword arugments
     specified. You'll typically do:
     
     send_error(some_message, text="A random problem happened")
     """
     if in_reply_to == None:
         in_reply_to = NOTIFICATION
     message = create_message(ErrorResponse, in_reply_to, **kwargs)
     self.send(message)
Exemplo n.º 8
0
def process_watch_object_command(message, sender, connection):
    interface_name = message["interface_name"]
    object_name = message["object_name"]
    autobus.register_object_watch(interface_name, object_name, sender)
    connection.watches.append((interface_name, object_name))
    try:
        interface = autobus.lookup_interface(interface_name)
        object = interface.object_map[object_name]
        object_value = object.get()
    except (autobus.NoSuchInterfaceException, KeyError): # Object doesn't exist yet
        object_value = encode_object(None)
    response = create_message(WatchObjectResponse,
            message, interface_name=interface_name, object_name=object_name,
            value=object_value)
    connection.send(response)
Exemplo n.º 9
0
 def notify(self, arguments):
     """
     Sends a message to all connections listening for this event containing
     the specified arguments, which should be passed into this function as
     a (possibly empty) list or tuple.
     """
     listener_spec = (self.interface.name, self.name)
     if listener_spec in listener_map:
         message = create_message(FireEventCommand,
                 NOTIFICATION, interface_name=self.interface.name,
                 event_name=self.name, arguments=arguments)
         encoded_message = dumps(message)
         for connection_id in listener_map[listener_spec]:
             connection = connection_map[connection_id]
             connection.send(encoded_message)
Exemplo n.º 10
0
def process_run_function_response(message, sender, connection):
    response = create_message(CallFunctionResponse,
            RESPONSE, return_value=message["return_value"])
    if not message["message_id"] in connection.pending_responses:
        # Sporadic response received, just ignore it
        print ("Sporadic run response received from connection " + str(sender)
                + " for reported message id " + str(message["message_id"]) + 
                ". It will be ignored.")
        return
    response_connection_id, response_message_id = connection.pending_responses[message["message_id"]]
    del connection.pending_responses[message["message_id"]]
    response["message_id"] = response_message_id
    if response_connection_id in autobus.connection_map: # Make sure the connection
        # listening for the response is still alive
        response_connection = autobus.connection_map[response_connection_id]
        response_connection.send(response)
Exemplo n.º 11
0
def process_register_event_command(message, sender, connection):
    interface_name = message["interface_name"]
    event_name = message["event_name"]
    doc = message["doc"]
    try:
        interface = autobus.lookup_interface(interface_name, sender)
    except autobus.NoSuchInterfaceException as e:
        connection.send_error(message, text=str(e))
        return
    try:
        interface.create_and_register_event(sender, event_name, doc)
    except KeyError:
        connection.send_error(message, "An event with that name has already "
                "been registered on that interface.")
        return
    response = create_message(RegisterEventResponse, message)
    connection.send(response)
Exemplo n.º 12
0
 def notify(self):
     """
     Sends a message to all connections watching this object containing the
     object's current value. This only calls self.get() once, so it's not
     generally processor-intensive even when lots of connections are
     listening for changes to this object.
     """
     watch_spec = (self.interface.name, self.name)
     if watch_spec in watch_map:
         current_value = self.get()
         message = create_message(SetObjectCommand,
                 NOTIFICATION, interface_name=self.interface.name,
                 object_name=self.name, value=current_value)
         encoded_message = dumps(message)
         for connection_id in watch_map[watch_spec]:
             connection = connection_map[connection_id]
             connection.send(encoded_message)
Exemplo n.º 13
0
def process_register_function_command(message, sender, connection):
    interface_name = message["interface_name"]
    function_names = message["name"]
    docs = message["doc"]
    if isinstance(function_names, basestring) and isinstance(docs, basestring):
        function_names = [function_names]
        docs = [docs]
    try:
        interface = autobus.lookup_interface(interface_name, sender)
    except autobus.NoSuchInterfaceException as e:
        connection.send_error(message, text=str(e))
        return
    try:
        for function_name, doc in zip(function_names, docs):
            interface.register_function(sender, function_name, doc, notify=False)
    except KeyError:
        connection.send_error(message, "A function with that name has already "
                "been registered on that interface.")
        autobus.autobus_interface.notify_object("interface_items")
        return
    autobus.autobus_interface.notify_object("interface_items")
    response = create_message(RegisterFunctionResponse, message)
    connection.send(response)
Exemplo n.º 14
0
def create_error_response(message_id, text):
    return create_message(ErrorResponse, RESPONSE, message_id=message_id, text=text)
Exemplo n.º 15
0
 def send_new(self, *args, **kwargs):
     """
     Exactly the same as
     self.send(libautobus.create_message(*args, **kwargs)).
     """
     self.send(create_message(*args, **kwargs))