Example #1
0
 def _http_json_set_value(uids, locations, names, values):
     """
     Set single or multiple endpoint values on data source
     
     @param uids: list of endpoint ids
     @param locations: list of endpoint locations
     @param names: list of endpoint names
     @param values: list of endpoint values
     
     @return list of endpoint values in JSON format
     """
     # Create list of JSON endpoint data
     req = []
     if values is not None:
         if len(values) > 0:
             for i, val in enumerate(values):
                 if len(locations) == len(names) > i:
                     endp = LagartoEndpoint(location = locations[i], name=names[i], value=val)
                 elif len(uids) > i:
                     endp = LagartoEndpoint(endp_id=uids[i], value=val)
                 req.append(endp.dumps())
     else:
         return None
                 
     status = LagartoHttpServer.data_server.set_status(req)
     
     if status is not None:
         if len(status) > 0:
             # Create complete Lagarto status message
             http_server = LagartoHttpServer.address + ":" + str(LagartoHttpServer.port)
             response = LagartoMessage(proc_name=LagartoHttpServer.proc_name, http_server=http_server, status=status)
             return json.dumps(response.dumps())
             
     return None
Example #2
0
    def publish_status(self, status_data=None, endp=None):
        """
        Publish network status (collection of endpoint data)
        
        @param status_data network status to be transmitted
        @param endp Endpoint data
        """
        self.publish_lock.acquire()
        try:
            http_server = self.address + ":" + str(self.httpport)

            if endp is not None:
                status_data = [endp.dumps()]

            # Message in JSON format
            lagarto_msg = LagartoMessage(proc_name=self.procname,
                                         http_server=http_server,
                                         status=status_data)
            msg = json.dumps(lagarto_msg.dumps())
            topic = self.procname + "/json/status"
            self.mqtt_client.publish(topic, payload=msg, qos=0, retain=False)

            # Message in simple format
            if status_data is not None:
                for endp_data in status_data:
                    topic = self.procname + "/simple/status/" + endp_data[
                        "location"] + "/" + endp_data["name"]
                    msg = endp_data["value"]
                    self.mqtt_client.publish(topic,
                                             payload=msg,
                                             qos=0,
                                             retain=False)

        finally:
            self.publish_lock.release()
Example #3
0
 def publish_status(self, status_data=None, endp=None):
     """
     Publish network status (collection of endpoint data)
     
     @param status_data network status to be transmitted
     @param endp Endpoint data
     """
     self.publish_lock.acquire()
     try:
         http_server = self.address + ":" + str(self.httpport)
         
         if endp is not None:
             status_data = [endp.dumps()]
             
         # Message in JSON format
         lagarto_msg = LagartoMessage(proc_name=self.procname, http_server=http_server, status=status_data)
         msg = json.dumps(lagarto_msg.dumps())
         topic = self.procname + "/json/status"    
         self.mqtt_client.publish(topic, payload=msg, qos=0, retain=False)
         
         # Message in simple format
         if status_data is not None:
             for endp_data in status_data:
                 topic = self.procname + "/simple/status/" + endp_data["location"] + "/" + endp_data["name"]
                 msg = endp_data["value"]
                 self.mqtt_client.publish(topic, payload=msg, qos=0, retain=False)
         
     finally:
         self.publish_lock.release()      
Example #4
0
 def _http_json_get_value(uids=None, locations=None, names=None):
     """
     Get single or multiple endpoint values from data source
     
     @param uids: list of endpoint ids
     @param locations: list of endpoint locations
     @param names: list of endpoint names
     
     @return list of endpoint values in JSON format
     """
     # Create list of JSON endpoint data
     req = []
     if uids is not None and locations is not None and names is not None:
         if len(uids) > 0:
             for uid in uids:
                 endp = LagartoEndpoint(endp_id=uid)
                 req.append(endp.dumps())
         elif len(locations) == len(names) > 0:
             for i, loc in enumerate(locations):
                 endp = LagartoEndpoint(location=loc, name=names[i])
                 req.append(endp.dumps())
     else:  # Return whole network status
         req = None
                 
     status = LagartoHttpServer.data_server.get_status(req)
     
     if status is not None:
         if len(status) > 0:
             # Create complete Lagarto status message
             http_server = LagartoHttpServer.address + ":" + str(LagartoHttpServer.port)
             response = LagartoMessage(proc_name=LagartoHttpServer.proc_name, http_server=http_server, status=status)
             return json.dumps(response.dumps())
             
     return None
Example #5
0
    def _http_json_get_value(self, uid=None, location=None, name=None):
        """
        Get single or multiple endpoint values from data source
        
        @param uid: endpoint uid
        @param location: endpoint locations
        @param name: endpoint name
        
        @return list of endpoint values in JSON format
        """
        # Create list of JSON endpoint data
        req = []
        if uid is not None:
            endp = LagartoEndpoint(endp_id=uid)
            req.append(endp.dumps())
        elif location is not None and name is not None:
            endp = LagartoEndpoint(location=location, name=name)
            req.append(endp.dumps())
        else:  # Return whole network status
            req = None

        status = self.data_server.get_status(req)

        if status is not None:
            if len(status) > 0:
                # Create complete Lagarto status message
                http_server = self.address + ":" + str(self.port)
                response = LagartoMessage(proc_name=self.proc_name,
                                          http_server=http_server,
                                          status=status)
                return json.dumps(response.dumps())

        return None
Example #6
0
    def _http_json_set_value(self, uid, location, name, value):
        """
        Set single or multiple endpoint values from data source
        
        @param uids: endpoint id
        @param locations: endpoint location
        @param names: endpoint name
        @param values: endpoint value
        
        @return list of endpoint values in JSON format
        """
        # Create list of JSON endpoint data
        req = []
        if value is not None:
            if uid is not None:
                endp = LagartoEndpoint(endp_id=uid, value=value)
            elif location is not None and name is not None:
                endp = LagartoEndpoint(location = location, name=name, value=value)

            req.append(endp.dumps())
        else:
            return None
                    
        status = self.data_server.set_status(req)
        
        if status is not None:
            if len(status) > 0:
                # Create complete Lagarto status message
                http_server = self.address + ":" + str(self.port)
                response = LagartoMessage(proc_name=self.proc_name, http_server=http_server, status=status)
                return json.dumps(response.dumps())
                
        return None
Example #7
0
 def publish_status(self, status_data=None):
     """
     Broadcast network status (collection of endpoint data)
     
     @param status_data network status to be transmitted
     """
     self.publish_lock.acquire()
     try:
         http_server = self.config.address + ":" + str(self.config.httpport)
         lagarto_msg = LagartoMessage(proc_name=self.config.procname, http_server=http_server, status=status_data)
         msg = json.dumps(lagarto_msg.dumps())
         self.pub_socket.send(msg)
     finally:
         self.publish_lock.release()
Example #8
0
 def publish_status(self, status_data=None):
     """
     Broadcast network status (collection of endpoint data)
     
     @param status_data network status to be transmitted
     """
     self.publish_lock.acquire()
     try:
         http_server = self.config.address + ":" + str(self.config.httpport)
         lagarto_msg = LagartoMessage(proc_name=self.config.procname,
                                      http_server=http_server,
                                      status=status_data)
         msg = json.dumps(lagarto_msg.dumps())
         self.pub_socket.send(msg)
     finally:
         self.publish_lock.release()
Example #9
0
    def publish_status(self, status_data=None):
        """
        Broadcast network status (collection of endpoint data)
        
        @param status_data list of network status to be transmitted
        """
        self.publish_lock.acquire()
        try:
            http_server = self.config.address + ":" + str(self.config.httpport)
            lagarto_msg = LagartoMessage(proc_name=self.config.procname, http_server=http_server, status=status_data)
            msg = json.dumps(lagarto_msg.dumps())

            # send to zmq
            if self.pub_socket:
                self.pub_socket.send(msg)

            # mqtt 
            if self.mqtt_client and status_data:
                self.mqtt_client.handle_swap_message(status_data)
            elif self.mqtt_client and not status_data:
                # probably HBEAT message, skipping it at mqtt level
                pass
        finally:
            self.publish_lock.release()
Example #10
0
    def request_status(self, procname, req):
        """
        Query/command network/endpoint status from server
        
        @param procname: name of the process to be queried
        @param req: queried/controlled endpoints
        
        @return status
        """
        if len(req) > 0:
            control = False
            if "value" in req[0]:
                control = True

            cmd_list = []
            for endp in req:
                if endp["location"] is not None and endp["name"] is not None:
                    cmd = "location=" + endp[
                        "location"] + "&" + "name=" + endp["name"]
                elif endp["id"] is not None:
                    cmd = "id=" + endp["id"]
                else:
                    raise LagartoException(
                        "Insufficient data to identify endpoint")

                if control:
                    cmd += "&value=" + endp["value"]
                cmd_list.append(cmd)

            if procname in self.http_servers:
                try:
                    conn = httplib.HTTPConnection(self.http_servers[procname],
                                                  timeout=5)
                    conn.request("GET", "/values/?" + "&".join(cmd_list))
                    response = conn.getresponse()
                    if response.reason == "OK":
                        status_response = json.loads(response.read())
                        status_msg = LagartoMessage(status_response)

                        return status_msg.status
                except:
                    raise LagartoException(
                        "Unable to get response from HTTP server")

        return None