Exemple #1
0
            def start(self):
                retval = self.io.start()
                if retval == self.io.RETURN_FAILURE:
                    raise DriverError, "Start of device service failed, aborting!"

                self.st_m.start()
                info("Start device '%s' (COM: %s | AUX: %s)" % (self.path, self.io.modem_path, self.io.com_path))
Exemple #2
0
 def unregister(self, url):
     info("Unregister request for URL %s" % repr(url))
     try:
         self.__hosts.__delitem__(url)
         return 0
     except KeyError:
         raise DeviceLoggerError, "unregister(): URL %s doesn't exist." % url
Exemple #3
0
 def unregister(self, url):
     info("Unregister request for URL %s" % repr(url))
     try:
         self.__hosts.__delitem__(url)
         return 0
     except KeyError:
         raise DeviceLoggerError, "unregister(): URL %s doesn't exist." % url
Exemple #4
0
    def device_unlocked(self, object):
        info("Unlocked sending signal")
        """
        [DBUS signal exported]
        The object path of the newly added device.

        """
        pass
Exemple #5
0
 def __abort_tasks(self):
     while len(self.__tasks):
         _task = self.__pop()
         if _task is not None:
             info("Going to abort task %i" % _task.id())
             _task.abort()
         else:
             time.sleep(0.100)
Exemple #6
0
    def device_unlocked(self, object):
        info("Unlocked sending signal")
        '''
        [DBUS signal exported]
        The object path of the newly added device.

        '''
        pass
Exemple #7
0
            def start(self):
                retval = self.io.start()
                if retval == self.io.RETURN_FAILURE:
                    raise DriverError, "Start of device service failed, aborting!"

                self.st_m.start()
                info("Start device '%s' (COM: %s | AUX: %s)" %
                     (self.path, self.io.modem_path, self.io.com_path))
Exemple #8
0
 def add(self, vid, pid, com_minor, aux_minor, driver=None):
     try:
         vendor = self.__vendors[vid.lower()]
         vendor.add(pid, com_minor, aux_minor, driver)
         info("Added new product (VID %s | PID %s) of vendor %s | Minors: %s COM and %s AUX" % (vid, pid, vendor.name(), com_minor, aux_minor))
         self.__save()
     except Exception, err:
         raise TableError, "Couldn't add new device, %s" % err
Exemple #9
0
 def removeProduct(self, vid, pid):
     try:
         vendor = self.__vendors[vid.lower()]
         vendor.remove(pid)
         info("Removed product (VID %s | PID %s) of vendor %s" % (vid, pid, vendor.name()))
         self.__save()
     except Exception, err:
         raise TableError, "Couldn't remove the device %s:%s, %s" % (str(vid), str(pid), err)
Exemple #10
0
    def __init__(self, parent, bus_name, mm_path, dm_id):
        gobject.GObject.__init__(self)

        self.__vid        = parent.get_property("ID_VENDOR_ID")
        self.__pid        = parent.get_property("ID_MODEL_ID")

        # -- Hell! In some cases the get_property() of the parent is returning None
        if (self.__vid is None) or (self.__pid is None):
            raise DriverError, "Got 'None' for the parent's VID/PID!"

        self.__vid_pid    = "%s:%s" % (self.__vid, self.__pid)
        self.__id         = create_parent_id(parent)
        self.__sysfs_path = parent.get_sysfs_path()
        self.__devpath    = parent.get_property("DEVPATH")

        self.__udev       = gudev.Client("tty")
        self.__dev        = parent
        self.__dm_id      = dm_id

        # -- Get the libusb device for this parent
        self.__usbdev = None
        busses = usb.busses()
        for bus in busses:
            for dev in bus.devices:
                if (dev.idVendor == int(self.__vid, 16)) and (dev.idProduct == int(self.__pid, 16)):

                    # -- @XXX: Dont know why but in some cases the HUB is passed to
                    if dev.deviceClass  == usb.CLASS_HUB:
                        raise DriverError, "Device with VID %s PID %s is a HUB" % (self.__vid, self.__pid)

                    self.__usbdev = dev
                    break

        if self.__usbdev is None:
            raise DriverError, "No Libusb device with VID %s PID %s" % (self.__vid, self.__pid)

        # -- IMPORTANT: This dict uses the port minor numbers as keys! This is required for searching
        # -- the ports that belong to a product from the devices table
        self.__ports      = DevicePort.PortsHandler()
        self.__ports_nr   = self.__get_number_ports()
        if self.__ports_nr <= 1:
            raise DriverError, "USB parent %s has %i TTY ports (not enough)" % (self.__id, self.__ports_nr)

        self.__portCom     = None
        self.__portAux     = None
        self.__driver      = None
        self.__portLock    = threading.Lock()

        self.bus_name         = bus_name
        self.__modem_id       = alloc_modem_id()
        self.__mm_device_path = os.path.join(mm_path, str(self.__modem_id))
        self.__device_service = None

        self.__devtable       = DeviceTable.DeviceTable()
        self.__measure        = DevicePort.TimeMeasure()

        info("Plugged-in USB parent %s | Ports %i | Sysfs %s" % (self.__vid_pid, self.__ports_nr, self.__sysfs_path))
        thread.start_new_thread(self.__scan, ( ))
Exemple #11
0
    def mgu_respond(self, response):
        ussd_cmd = response

        def function(task):
            cmd = 'AT+CUSD=1,"%s",15' % ussd_cmd
            regex = '\+CUSD:.*(?P<code>\d),\"(?P<msg>.+)\",'
            r_values = ["code", "msg"]

            res = self.io.com.send_query({"type" : "regex",
                                          "cmd" : cmd, "task" : task,
                                          "regex" : regex,
                                          "r_values" : r_values,
                                          "alt_ok_value" : "+CUSD",
                                          })
            if res != None:
                return int(res["code"]), res["msg"]
            
            return None

        if self.mgu_state_prop != 'user-response' :
            info("USSD session is not in user-response status")
            return ''
        
        task_msg = "Send USSD response -> ('%s')'" % (response)
        try:
            r = self.io.task_pool.exec_task(function, task_msg=task_msg, timeout=20)
        except:
            self.cache["ussd_status"] = 'idle'
            return ''

        if r == None:
            ussd_cmd = self.mgu_to_gsm7(response)
            task_msg = "Send USSD response gsm7 encoded -> ('%s')" % (ussd_cmd)
            r = self.io.task_pool.exec_task(function, task_msg=task_msg, timeout=20)
            
            if r == None :
                self.cache["ussd_status"] = 'idle'
                return ''
            else:
                c = r[0]
                if c == 0 :
                    self.cache["ussd_status"] = 'idle'
                elif c == 1 :
                    self.cache["ussd_status"] = 'user-response'
                else:
                    self.cache["ussd_status"] = 'idle'
            
            return self.mgu_from_gsm7(r[1])
        else:
            c = r[0]
            if c == 0 :
                self.cache["ussd_status"] = 'idle'
            elif c == 1 :
                self.cache["ussd_status"] = 'user-response'
            else:
                self.cache["ussd_status"] = 'idle'
            
            return r[1]
Exemple #12
0
 def stop(self):
     info("Stopping device : %s" % self.path)
     self.st_m.stop()
     self.io.stop()
     try:
         self.remove_from_connection(path = self.path)
     except:
         pass
     return True
Exemple #13
0
 def stop(self):
     info("Stopping device : %s" % self.path)
     self.st_m.stop()
     self.io.stop()
     try:
         self.remove_from_connection(path=self.path)
     except:
         pass
     return True
Exemple #14
0
 def removeProduct(self, vid, pid):
     try:
         vendor = self.__vendors[vid.lower()]
         vendor.remove(pid)
         info("Removed product (VID %s | PID %s) of vendor %s" %
              (vid, pid, vendor.name()))
         self.__save()
     except Exception, err:
         raise TableError, "Couldn't remove the device %s:%s, %s" % (
             str(vid), str(pid), err)
Exemple #15
0
 def __get_ports_from_device_table(self):
     try:
         product = self.__devtable.product(self.__vid, self.__pid)
         comIdx  = product.com()
         auxIdx  = product.aux()
         info("Product needs ports with index %i and %i (COM and AUX)" % (comIdx, auxIdx))
         return self.__ports.get_port_by_index(comIdx), self.__ports.get_port_by_index(auxIdx)
     except Exception, err:
         self.error("Failure reading a table product, %s" % err)
         raise DeviceTable.TableError, err
Exemple #16
0
 def add(self, vid, pid, com_minor, aux_minor, driver=None):
     try:
         vendor = self.__vendors[vid.lower()]
         vendor.add(pid, com_minor, aux_minor, driver)
         info(
             "Added new product (VID %s | PID %s) of vendor %s | Minors: %s COM and %s AUX"
             % (vid, pid, vendor.name(), com_minor, aux_minor))
         self.__save()
     except Exception, err:
         raise TableError, "Couldn't add new device, %s" % err
Exemple #17
0
    def __check_available_devices(self):
        info("Checking tty's availables")
        for device in self.udev_client.query_by_subsystem("tty"):
            self.__on_tty_event(self.udev_client, "add", device)
        info("Checking tty's availables finished")

        for device in self.udev_client_usb.query_by_subsystem("usb"):
            self.__on_usb_event(self.udev_client_usb, "add", device)

        self.udev_client.connect("uevent", self.__on_tty_event)
        self.udev_client_usb.connect("uevent", self.__on_usb_event)
Exemple #18
0
    def __check_available_devices(self):
        info("Checking tty's availables")
        for device in self.udev_client.query_by_subsystem("tty"):
            self.__on_tty_event(self.udev_client, "add", device)
        info("Checking tty's availables finished")

        for device in self.udev_client_usb.query_by_subsystem("usb"):
            self.__on_usb_event(self.udev_client_usb, "add", device)

        self.udev_client.connect("uevent", self.__on_tty_event)
        self.udev_client_usb.connect("uevent", self.__on_usb_event)
Exemple #19
0
 def __get_ports_from_device_table(self):
     try:
         product = self.__devtable.product(self.__vid, self.__pid)
         comIdx = product.com()
         auxIdx = product.aux()
         info("Product needs ports with index %i and %i (COM and AUX)" %
              (comIdx, auxIdx))
         return self.__ports.get_port_by_index(
             comIdx), self.__ports.get_port_by_index(auxIdx)
     except Exception, err:
         self.error("Failure reading a table product, %s" % err)
         raise DeviceTable.TableError, err
Exemple #20
0
    def run(self):
        self.__result = self.RESULT_PENDING
        td = TimeMeasure()
        if self.__port.AT_test(self.__retries, self.__timeout, write=self.__write, read=self.__read) == self.__port.AT_TEST_OK:
            self.__result = self.RESULT_OK
        else:
            self.__result = self.RESULT_ERROR
        self.__duration = td.diff()

        # -- @XXX: This is probably not the correct place for this debug message
        msg = "AT" if self.__result == self.RESULT_OK else "No"
        info("%s answer on %s | Duration %s" % (msg, self.__port.devnode(), self.__duration))
Exemple #21
0
    def __init__(self, addr, port):
        server        = SimpleXMLRPCServer.SimpleXMLRPCServer((addr, port), logRequests=False)
        self.__hosts  = { }
        self.__server = server
        self.__addr   = create_xmlrpc_addr(addr, port)

        server.register_introspection_functions()
        server.register_instance(self._Rpcs(self.__hosts))

        # -- Get the repository revision for returning this value with the RPC
        self.__revision = "@TODO"
        
        info("Created new XML-RPC device logger (revision %s)" % self.__revision)
Exemple #22
0
 def mgn_set_apn(self, apn):
     
     info("************* APNNNNNNNN*************** ")        
     def function(task):
         cmd = "AT+CGDCONT=1,\"IP\",\"%s\"" %apn            
         self.io.com.send_query({"type" : "simple",
                                   "cmd" : cmd, 
                                   "task" : task})
         
         
     task_msg = "Modifying APN"
     self.io.task_pool.exec_task(function, task_msg=task_msg, timeout=60)
     
     pass                
Exemple #23
0
    def __init__(self, addr, port):
        server = SimpleXMLRPCServer.SimpleXMLRPCServer((addr, port),
                                                       logRequests=False)
        self.__hosts = {}
        self.__server = server
        self.__addr = create_xmlrpc_addr(addr, port)

        server.register_introspection_functions()
        server.register_instance(self._Rpcs(self.__hosts))

        # -- Get the repository revision for returning this value with the RPC
        self.__revision = "@TODO"

        info("Created new XML-RPC device logger (revision %s)" %
             self.__revision)
Exemple #24
0
    def mgn_set_apn(self, apn):

        info("************* APNNNNNNNN*************** ")

        def function(task):
            cmd = "AT+CGDCONT=1,\"IP\",\"%s\"" % apn
            self.io.com.send_query({
                "type": "simple",
                "cmd": cmd,
                "task": task
            })

        task_msg = "Modifying APN"
        self.io.task_pool.exec_task(function, task_msg=task_msg, timeout=60)

        pass
Exemple #25
0
        def register(self, url):
            info("Register request for URL %s" % repr(url))
            if type(url) != type(""):
                raise DeviceLoggerError, "register(): Got invalid URL (not a string), %s" % repr(url)
            elif len(url) == 0:
                raise DeviceLoggerError, "register(): Got empty string."

            if self.__hosts.has_key(url):
                raise DeviceLoggerError, "register(): Passed URL '%s' already registered" % url

            # -- Ok, we are safe, create the proxy object and store it for further operations
            try:
                srv = xmlrpclib.Server(url)
                #val = srv.ping_from_device_manager()
                self.__hosts[url] = srv
                return 0
            except xmlrpclib.Fault, err:
                raise DeviceLoggerError, "xmlrpclib failure, %s" % err
Exemple #26
0
    def __init__(self):

        self.vids  = [ ]
        self.__cfg = ConfigFile(os.path.join(mobilemanager.DEVICE_TABLE_DIR(), self.DEVICE_TABLE_XML))

        try:
            self.__vendors = self.__cfg.read()
            info("Using XML devices table '%s'" % self.__cfg.fpath())
        except Exception, err:
            warning("Error reading '%s', %s" % (self.__cfg.fpath(), err))
            info("Using default vendors table")
            self.__vendors = { }
            self.__add( "Huawei"  , "huawei"  , HUAWEI_VID  , [ ( '1003', 1, 0, None ) ] )
            self.__add( "Novatel" , "novatel" , NOVATEL_VID , [ ] )
            self.__add( "Sierra"  , "sierra"  , SIERRA_VID  , [ ] )
            self.__add( "ZTE"     , "zte"     , ZTE_VID     , [ ] )
            self.__add( "Option"  , "option"  , OPTION_VID  , [ ] )
            self.__add( "Alcatel" , "alcatel" , ALCATEL_VID , [ ] )
            self.__save()
Exemple #27
0
        def register(self, url):
            info("Register request for URL %s" % repr(url))
            if type(url) != type(""):
                raise DeviceLoggerError, "register(): Got invalid URL (not a string), %s" % repr(
                    url)
            elif len(url) == 0:
                raise DeviceLoggerError, "register(): Got empty string."

            if self.__hosts.has_key(url):
                raise DeviceLoggerError, "register(): Passed URL '%s' already registered" % url

            # -- Ok, we are safe, create the proxy object and store it for further operations
            try:
                srv = xmlrpclib.Server(url)
                #val = srv.ping_from_device_manager()
                self.__hosts[url] = srv
                return 0
            except xmlrpclib.Fault, err:
                raise DeviceLoggerError, "xmlrpclib failure, %s" % err
Exemple #28
0
    def __init__(self):

        self.vids = []
        self.__cfg = ConfigFile(
            os.path.join(mobilemanager.DEVICE_TABLE_DIR(),
                         self.DEVICE_TABLE_XML))

        try:
            self.__vendors = self.__cfg.read()
            info("Using XML devices table '%s'" % self.__cfg.fpath())
        except Exception, err:
            warning("Error reading '%s', %s" % (self.__cfg.fpath(), err))
            info("Using default vendors table")
            self.__vendors = {}
            self.__add("Huawei", "huawei", HUAWEI_VID, [('1003', 1, 0, None)])
            self.__add("Novatel", "novatel", NOVATEL_VID, [])
            self.__add("Sierra", "sierra", SIERRA_VID, [])
            self.__add("ZTE", "zte", ZTE_VID, [])
            self.__add("Option", "option", OPTION_VID, [])
            self.__add("Alcatel", "alcatel", ALCATEL_VID, [])
            self.__save()
Exemple #29
0
 def info(self, msg):
     if self.__logging is True:
         info(msg)
Exemple #30
0
class TaskPool():

    STATE_IDLE    = 0
    STATE_BUSY    = 1
    STATE_STOPPED = 2
    STATE_FAILURE = 3

    WAIT_TASK_ADDED_TIME = 0.010

    # -- After this threshold is reached, a device reset is triggered!
    # -- Arbitraty value used for avoiding deadlocks in the task queue
    ERRORS_THRESHOLD     = 20

    class _TaskLog():

        # -- Disables globally the filters
        DISABLED_FILTERS = False

        def __init__(self):
            # -- Disable the filters per default
            self.__enable(False)
            self.filters([ ])

        def info(self, msg):
            if self.__logging is True:
                info(msg)

        def error(self, msg):
            error(msg)

        def warning(self, msg):
            warning(msg)

        def start(self, task):
            msg = task.msg()
            if self.__filters_enabled is True:
                self.__logging = False if (self.__task_filters.match(msg) is None) else True
            else:
                self.__logging = True

            self.info("Dispatching Task num=%i '%s' :" % (task.id(), task.msg()))

        def end(self, task):
            if self.__logging is True:
                self.info('-' * 20)

        def enable(self, value=None):
            if self.DISABLED_FILTERS is True:
                raise SystemError, "Filters feature is disabled"
            else:
                return self.__enable(value)

        def __enable(self, value=None):
            if value is not None:
                self.__filters_enabled = True if value else False
            return self.__filters_enabled

        def filters(self, commands=None):
            if (commands is not None):
                if not hasattr(commands, '__iter__'):
                    commands = [ commands ]

                self.__task_filters = re.compile(r"%s" % '|'.join(map(lambda cmd: ".*%s.*" % cmd, commands)))
                self.__commands     = commands

                if self.__filters_enabled is True:
                    warning("IMPORTANT: Tasks filter(s) enabled: %s" % repr(commands))

            return self.__commands

    def start(self):
        self.__stop = False
        thread.start_new_thread(self.__start, ( ))

    def __init__(self, device):
        self.__device     = device
        self.__stop       = False
        self.__task_added = threading.Event()
        self.__tasks_lock = threading.Lock()
        self.__tasks      = [ ]
        self.__errors     = 0
        self.__state      = self.STATE_IDLE

        # -- Set the external access to the logger
        self.__tasklog      = self._TaskLog()
        self.filters_enable = self.__tasklog.enable
        self.filters_set    = self.__tasklog.filters

    def info(self, msg):
        self.__tasklog.info(msg)

    def error(self, msg):
        self.__tasklog.error(msg)

    def __start(self):

        while self.__stop is False:
            try:
                self.__task_added.wait(self.WAIT_TASK_ADDED_TIME)
                self.__task_added.clear()

                # -- Now execute the next task of the queue
                _task = self.__pop()
                if _task is not None:

                    # -- Change the state to busy
                    self.__state = self.STATE_BUSY

                    self.__tasklog.start(_task)
                    retval = _task.execute()
                    if retval == _task.RESULT_OK:
                        self.__errors = 0
                    elif retval == _task.RESULT_ERROR:
                        self.__errors += 1

                        # -- Failure threshold reached, so try to reset the device and stop the task queue
                        if self.__errors == self.ERRORS_THRESHOLD:
                            self.stop()
                            self.__device.reset()
                            break

                    # -- Set the state to idle
                    self.__state = self.STATE_IDLE
                    self.__tasklog.end(_task)

            except Exception, err:
                error("Unexpected failure in TaskPool thread, %s" % err)
                self.__state = self.STATE_IDLE

        self.__state = self.STATE_STOPPED
        info("TaskPool stopped | Pending tasks %i" % len(self.__tasks))
        self.__abort_tasks()
Exemple #31
0
 def debug(self, msg):
     info("%s: %s" % (self.__id, msg))
Exemple #32
0
 def __device_added(self, dm, obj):
     self.device_added(obj)
     info("DBUS (signal:DeviceAdded:(%s))" % (obj))
Exemple #33
0
    def __init__(self, parent, bus_name, mm_path, dm_id):
        gobject.GObject.__init__(self)

        self.__vid = parent.get_property("ID_VENDOR_ID")
        self.__pid = parent.get_property("ID_MODEL_ID")

        # -- Hell! In some cases the get_property() of the parent is returning None
        if (self.__vid is None) or (self.__pid is None):
            raise DriverError, "Got 'None' for the parent's VID/PID!"

        self.__vid_pid = "%s:%s" % (self.__vid, self.__pid)
        self.__id = create_parent_id(parent)
        self.__sysfs_path = parent.get_sysfs_path()
        self.__devpath = parent.get_property("DEVPATH")

        self.__udev = gudev.Client("tty")
        self.__dev = parent
        self.__dm_id = dm_id

        # -- Get the libusb device for this parent
        self.__usbdev = None
        busses = usb.busses()
        for bus in busses:
            for dev in bus.devices:
                if (dev.idVendor == int(self.__vid,
                                        16)) and (dev.idProduct == int(
                                            self.__pid, 16)):

                    # -- @XXX: Dont know why but in some cases the HUB is passed to
                    if dev.deviceClass == usb.CLASS_HUB:
                        raise DriverError, "Device with VID %s PID %s is a HUB" % (
                            self.__vid, self.__pid)

                    self.__usbdev = dev
                    break

        if self.__usbdev is None:
            raise DriverError, "No Libusb device with VID %s PID %s" % (
                self.__vid, self.__pid)

        # -- IMPORTANT: This dict uses the port minor numbers as keys! This is required for searching
        # -- the ports that belong to a product from the devices table
        self.__ports = DevicePort.PortsHandler()
        self.__ports_nr = self.__get_number_ports()
        if self.__ports_nr <= 1:
            raise DriverError, "USB parent %s has %i TTY ports (not enough)" % (
                self.__id, self.__ports_nr)

        self.__portCom = None
        self.__portAux = None
        self.__driver = None
        self.__portLock = threading.Lock()

        self.bus_name = bus_name
        self.__modem_id = alloc_modem_id()
        self.__mm_device_path = os.path.join(mm_path, str(self.__modem_id))
        self.__device_service = None

        self.__devtable = DeviceTable.DeviceTable()
        self.__measure = DevicePort.TimeMeasure()

        info("Plugged-in USB parent %s | Ports %i | Sysfs %s" %
             (self.__vid_pid, self.__ports_nr, self.__sysfs_path))
        thread.start_new_thread(self.__scan, ())
Exemple #34
0
 def __device_removed_cb(self, driver, mm_device_path):
     try:
         info("Going to remove the device '%s'" % mm_device_path)
         self.__remove(driver)
     except Exception, err:
         error("Unexpected failure removing device, %s" % err)
Exemple #35
0
 def info(self, msg):
     info("%s: %s" % (self.__vid_pid, msg))
Exemple #36
0
 def reset(self):
     info("Going to reset the device!")
     self.stop()
     self.driver.reset()
Exemple #37
0
 def start(self, background=True):
     info("Starting XML-RPC device logger (%s)" % self.__addr)
     if background is True:
         thread.start_new_thread(self.__start, ())
     else:
         self.__start()
Exemple #38
0
 def __device_removed(self, dm, obj):
     self.device_removed(obj)
     info("DBUS (signal:DeviceRemoved:(%s))" % (obj))
Exemple #39
0
    def mgu_initiate(self, command):
        ussd_cmd = command

        def function(task):
            cmd = 'AT+CUSD=1,"%s",15' % ussd_cmd
            regex = '\+CUSD:.*(?P<code>\d),\"(?P<msg>.+)\",'
            r_values = ["code", "msg"]
            self.io.com.send_query({"cmd" : "AT^PORTSEL=0", 
                                    "task" : task,})

            res = self.io.com.send_query({"type" : "regex",
                                          "cmd" : cmd, "task" : task,
                                          "regex" : regex,
                                          "r_values" : r_values,
                                          "alt_ok_value" : "+CUSD",
                                          })

            self.io.com.send_query({"cmd" : "AT^PORTSEL=1", 
                                    "task" : task,})
            
            if res != None:
                return int(res["code"]), res["msg"]
            
            return None

        if self.mgu_state_prop != 'idle' :
            info("ussd system not idle status")
            return ''

        self.cache["ussd_status"] = 'active'
        
        task_msg = "[Huawei] Send USSD msg -> ('%s')'" % (command)
        try:
            r = self.io.task_pool.exec_task(function, task_msg=task_msg, timeout=20)
        except:
            self.cache["ussd_status"] = 'idle'
            return ''
            
        if r == None:
            ussd_cmd = self.mgu_to_gsm7(command)
            task_msg = "[Huawei] Send USSD msg gsm7 encoded -> ('%s')'" % (ussd_cmd)
            r = self.io.task_pool.exec_task(function, task_msg=task_msg, timeout=20)
            
            if r == None :
                self.cache["ussd_status"] = 'idle'
                return ''
            else:
                c = r[0]
                if c == 0 :
                    self.cache["ussd_status"] = 'idle'
                elif c == 1 :
                    self.cache["ussd_status"] = 'user-response'
                else:
                    self.cache["ussd_status"] = 'idle'
            
            return self.mgu_from_gsm7(r[1])

        else:
            c = r[0]
            if c == 0 :
                self.cache["ussd_status"] = 'idle'
            elif c == 1 :
                self.cache["ussd_status"] = 'user-response'
            else:
                self.cache["ussd_status"] = 'idle'
            
            return r[1]
Exemple #40
0
 def info(self, msg):
     info("%s: %s" % (self.__vid_pid, msg))
Exemple #41
0
    def mgu_initiate(self, command):
        ussd_cmd = command

        def function(task):
            cmd = 'AT+CUSD=1,"%s",15' % ussd_cmd
            regex = '\+CUSD:.*(?P<code>\d),\"(?P<msg>.+)\",'
            r_values = ["code", "msg"]
            self.io.com.send_query({
                "cmd": "AT^PORTSEL=0",
                "task": task,
            })

            res = self.io.com.send_query({
                "type": "regex",
                "cmd": cmd,
                "task": task,
                "regex": regex,
                "r_values": r_values,
                "alt_ok_value": "+CUSD",
            })

            self.io.com.send_query({
                "cmd": "AT^PORTSEL=1",
                "task": task,
            })

            if res != None:
                return int(res["code"]), res["msg"]

            return None

        if self.mgu_state_prop != 'idle':
            info("ussd system not idle status")
            return ''

        self.cache["ussd_status"] = 'active'

        task_msg = "[Huawei] Send USSD msg -> ('%s')'" % (command)
        try:
            r = self.io.task_pool.exec_task(function,
                                            task_msg=task_msg,
                                            timeout=20)
        except:
            self.cache["ussd_status"] = 'idle'
            return ''

        if r == None:
            ussd_cmd = self.mgu_to_gsm7(command)
            task_msg = "[Huawei] Send USSD msg gsm7 encoded -> ('%s')'" % (
                ussd_cmd)
            r = self.io.task_pool.exec_task(function,
                                            task_msg=task_msg,
                                            timeout=20)

            if r == None:
                self.cache["ussd_status"] = 'idle'
                return ''
            else:
                c = r[0]
                if c == 0:
                    self.cache["ussd_status"] = 'idle'
                elif c == 1:
                    self.cache["ussd_status"] = 'user-response'
                else:
                    self.cache["ussd_status"] = 'idle'

            return self.mgu_from_gsm7(r[1])

        else:
            c = r[0]
            if c == 0:
                self.cache["ussd_status"] = 'idle'
            elif c == 1:
                self.cache["ussd_status"] = 'user-response'
            else:
                self.cache["ussd_status"] = 'idle'

            return r[1]
Exemple #42
0
 def start(self, background=True):
     info("Starting XML-RPC device logger (%s)" % self.__addr)
     if background is True:
         thread.start_new_thread(self.__start, ( ))
     else:
         self.__start()
Exemple #43
0
 def debug(self, msg):
     info("%s: %s" % (self.__id, msg))
Exemple #44
0
 def __device_removed_cb(self, driver, mm_device_path):
     try:
         info("Going to remove the device '%s'" % mm_device_path)
         self.__remove(driver)
     except Exception, err:
         error("Unexpected failure removing device, %s" % err)
Exemple #45
0
 def reset(self):
     info("Going to reset the device!")
     self.stop()
     self.driver.reset()