示例#1
0
 def __init__(self, src):
     asyncore.dispatcher.__init__(self)
     self.id = src.id
     self.logger = self.setupLogger('zmproxy.ZmClient')
     self.src = src
     self.host = src.host
     self.path = src.path
     self.user = src.user
     self.passwd = src.passwd
     self.camera_path = ""
     self.queue = FrameQueue(src.queuesz)
     self.buffer = ""
     self.inp = ""
     self.frame_count = 0
     self.last_stamp = None
     self.chan_started = False
     self.http_started = False
     self._status = 'offline'
     self.head = {}
     self.buf = ''
     self.inp_pos = 0
     self.buffer_pos = 0
     self.fps = 0.0
     self.nconnects = 0
     self.last_count_stamp = None
     self.filehdl = None
     try:
         if self.user != None and self.user != "":
             self.login()
         self.Connect()
     except:
         self.logger.error("Camera connect FAILED")
         self.logger.info(sys.exc_info())
示例#2
0
 def __init__(self, src):
     asyncore.dispatcher.__init__(self)
     self.id = src.id
     self.logger = self.setupLogger('zmproxy.ZmClient')
     self.src = src
     self.host = src.host
     self.path = src.path
     self.user = src.user
     self.passwd = src.passwd
     self.camera_path = ""
     self.queue = FrameQueue(src.queuesz)
     self.buffer = ""
     self.inp = ""
     self.frame_count = 0
     self.last_stamp = None
     self.chan_started = False
     self.http_started = False
     self._status = 'offline'
     self.head = {}
     self.buf = ''
     self.inp_pos = 0
     self.buffer_pos = 0
     self.fps = 0.0
     self.nconnects = 0
     self.last_count_stamp = None
     self.filehdl = None
     try:
         if self.user != None and self.user != "":
             self.login()
         self.Connect()
     except:
         self.logger.error("Camera connect FAILED");
         self.logger.info(sys.exc_info());
示例#3
0
 def __init__(self, inpid, queuesz, path, interval_ms):
     self.id = inpid
     self.path = path
     self.interval = interval_ms
     self.files = filter(is_jpeg, os.listdir(self.path))
     self.currfile = 0
     self.Exit = False
     self.queue = FrameQueue(queuesz)
     self.last_stamp = None
     self.host = None
     self.frame_count = 0
     self._status = "stopped"
     self.fps = 0.0
     self.buffer_pos = 0
     self.nconnects = 0
     self.logger = logging.getLogger('zmproxy.FileInput')
     threading.Thread.__init__(self)
     self.logger.info("File input: %s files to process" % len(self.files))
示例#4
0
class FileInput(threading.Thread):
    def __init__(self, inpid, queuesz, path, interval_ms):
        self.id = inpid
        self.path = path
        self.interval = interval_ms
        self.files = filter(is_jpeg, os.listdir(self.path))
        self.currfile = 0
        self.Exit = False
        self.queue = FrameQueue(queuesz)
        self.last_stamp = None
        self.host = None
        self.frame_count = 0
        self._status = "stopped"
        self.fps = 0.0
        self.buffer_pos = 0
        self.nconnects = 0
        self.logger = logging.getLogger('zmproxy.FileInput')
        threading.Thread.__init__(self)
        self.logger.info("File input: %s files to process" % len(self.files))

    def status(self):
        return self._status

    def proc_file(self):
        f = open(self.path + "/" + self.files[self.currfile])
        buf = f.read()
        self.buffer_pos = self.queue.addbuf(buf)
        f.close()
        self.frame_count += 1
        self.currfile += 1
        if self.currfile >= len(self.files):
            self.currfile = 0
        self.last_stamp = datetime.datetime.now()
        if self.frame_count % 100 == 0:
            self.logger.info(
                "File input: frame processed (%s bytes). Frame count = %s, currfile = %s"
                % (len(buf), self.frame_count, self.currfile))

    def run(self):
        self.logger.info("Start FileInput with interval %s ms." %
                         self.interval)
        self._status = "Ok"
        while not self.Exit:
            self.proc_file()
            time.sleep(self.interval / 1000.0)
        self._status = "stopped"
        return

    def stop(self):
        self.Exit = True
示例#5
0
class FileInput(threading.Thread):
    def __init__(self, inpid, queuesz, path, interval_ms):
        self.id = inpid
        self.path = path
        self.interval = interval_ms        
        self.files = filter(is_jpeg, os.listdir(self.path))
        self.currfile = 0
        self.Exit = False
        self.queue = FrameQueue(queuesz)
        self.last_stamp = None
        self.host = None
        self.frame_count = 0
        self._status = "stopped"
        self.fps = 0.0
        self.buffer_pos = 0
        self.nconnects = 0
        self.logger = logging.getLogger('zmproxy.FileInput')
        threading.Thread.__init__(self)
        self.logger.info( "File input: %s files to process" % len(self.files))
        
    def status(self):
        return self._status
        
    def proc_file(self):
        f = open(self.path + "/" + self.files[self.currfile])
        buf = f.read()
        self.buffer_pos = self.queue.addbuf(buf)
        f.close()
        self.frame_count += 1
        self.currfile += 1
        if self.currfile >= len(self.files):
            self.currfile = 0
        self.last_stamp = datetime.datetime.now()
        if self.frame_count % 100 == 0:
            self.logger.info( "File input: frame processed (%s bytes). Frame count = %s, currfile = %s" % (len(buf), self.frame_count, self.currfile))
        
    def run(self):
        self.logger.info( "Start FileInput with interval %s ms." % self.interval) 
        self._status = "Ok"
        while not self.Exit:
            self.proc_file()
            time.sleep(self.interval / 1000.0)
        self._status = "stopped"
        return    
    
    def stop(self):
        self.Exit = True
        
示例#6
0
 def __init__(self, inpid, queuesz, path, interval_ms):
     self.id = inpid
     self.path = path
     self.interval = interval_ms        
     self.files = filter(is_jpeg, os.listdir(self.path))
     self.currfile = 0
     self.Exit = False
     self.queue = FrameQueue(queuesz)
     self.last_stamp = None
     self.host = None
     self.frame_count = 0
     self._status = "stopped"
     self.fps = 0.0
     self.buffer_pos = 0
     self.nconnects = 0
     self.logger = logging.getLogger('zmproxy.FileInput')
     threading.Thread.__init__(self)
     self.logger.info( "File input: %s files to process" % len(self.files))
示例#7
0
class ZmClient(asyncore.dispatcher):
    boundary = '--ZoneMinderFrame'
    logger_map = {}
    def __init__(self, src):
        asyncore.dispatcher.__init__(self)
        self.id = src.id
        self.logger = self.setupLogger('zmproxy.ZmClient')
        self.src = src
        self.host = src.host
        self.path = src.path
        self.user = src.user
        self.passwd = src.passwd
        self.camera_path = ""
        self.queue = FrameQueue(src.queuesz)
        self.buffer = ""
        self.inp = ""
        self.frame_count = 0
        self.last_stamp = None
        self.chan_started = False
        self.http_started = False
        self._status = 'offline'
        self.head = {}
        self.buf = ''
        self.inp_pos = 0
        self.buffer_pos = 0
        self.fps = 0.0
        self.nconnects = 0
        self.last_count_stamp = None
        self.filehdl = None
        try:
            if self.user != None and self.user != "":
                self.login()
            self.Connect()
        except:
            self.logger.error("Camera connect FAILED");
            self.logger.info(sys.exc_info());

    def __del__(self):      
        if hasattr(self, "filehdl") and not self.filehdl is None:
            self.filehdl.close()


    def setupLogger(self, module_name):
        lname = module_name + "_%d" % self.id
        if self.logger_map.has_key(lname):
            return self.logger_map[lname]

        logger = logging.getLogger(lname)
        logger.setLevel(logging.DEBUG)
#        conshdl = logging.StreamHandler()
#        conshdl.setLevel(logging.DEBUG)
        
        self.filehdl = logging.FileHandler('zmproxy_input_%d.log' % self.id)
        self.filehdl.setLevel(logging.DEBUG)
        
        formatter = logging.Formatter('%(asctime)s %(name)s %(levelname)s %(message)s')
#        conshdl.setFormatter(formatter)
        self.filehdl.setFormatter(formatter)
#        logger.addHandler(conshdl)
        logger.addHandler(self.filehdl)
        self.logger_map[lname] = logger
        return logger

    def login(self):
        url = 'http://' + self.host  + self.path
        self.logger.info('Loging in ' + url + ' as ' + self.user)
        hdl = LoginHandler(self.logger, self.host, self.path)
        hdl.login(self.user, self.passwd)
        if hdl.src == None:
            self.logger.error('Login FAILED')
            raise Exception('Login Failed')
        self.camera_path = hdl.src
        self.logger.info('Login performed')
        return

    def Connect(self):
        ''' Connect to data socket
        '''
        
        self.buffer = "GET %s\r\n\r\n" % self.camera_path
                
        self.create_socket(socket.AF_INET, socket.SOCK_STREAM)
        self.logger.debug('Connecting to ' + self.host + ' port 80')
        self.connect((self.host, 80))

    def parse_packet(self, in_str):       
        ''' Receive packet starting with boundary, to the end start of next boundary
        '''
                
        packet = cStringIO.StringIO(in_str)
        content_type = None
        content_length= None
        in_head = False
        while 1:
            line=packet.readline().strip()
            if len(line) == 0:
                if not in_head:
                    in_head = True
                    continue
                else:
                    break;
                
            if line == self.boundary:
                # Found next boundary - give up
                in_head = True
                continue
                        
            parts = line.split(':')
            if len(parts) == 2:
                if parts[0] == 'Content-Type':
                    content_type = parts[1].strip()
                elif parts[0] == 'Content-Length':
                    content_length = int(parts[1])
        
        buf = packet.read(content_length)
        if content_type != 'image/jpeg':
            self.logger.warning( "ZmClient: warning: wrong packet type. Got %s, expected image/jpeg " % content_type)
        if len (buf) != content_length:
            self.logger.warning( "ZmClient: warning: packet of wrong size. Got %s bytes, expected from header %s" % (len(buf), content_length))
            db = len(buf) - content_length
            self.logger.debug( "Extra bytes: %d (%s)" % (len(buf[-db:]), ' '.join( [hex(ord(x)) for x in buf[-db:] ])))
        packet.close()
#        self.logger.debug("Packet received: %d bytes" % len(buf))
        return buf    

    def status(self):
        if self._status == 'Ok':
            if not self.last_stamp is None:
                datediff = datetime.datetime.now() - self.last_stamp
                if datediff > datetime.timedelta(0, 60):            
                    self._status = 'hang'
            else:
                self._status = 'no signal'
    
        return self._status

    def start_http(self):        
        ''' Read HTTP header(s) and check if we are listening for the right source
        '''
        packet = cStringIO.StringIO(self.inp)
        while 1:
            line = packet.readline().strip()
            if not line:
                break
            self.logger.debug( "ZmClient: recieved header line: %s" % line)
            if line == 'HTTP/1.0 200 OK':                
                self.http_started = True
                pos = packet.tell()
                self.inp = self.inp[pos:]
                self._status = "Ok"
            else:
                self.logger.debug( 'ZmClient error: wrong HTTP header line: %s' % line)
#                self.logger.debug( packet.getvalue() )
                self._status = "error"
            return

    def start_channel(self):        
        ''' Read HTTP header(s) and check if we are listening for the right source
        '''
        packet = cStringIO.StringIO(self.inp)
        while 1:
            line = packet.readline().strip()
            if not line:
                break
            self.logger.debug( "ZmClient: recieved header line: %s" % line)
            parts = line.split(':')
            self.head[parts[0]] = parts[1]
        if self.head.has_key('Content-Type'):
            self.chan_started = True
            self.inp = ''

    def stream_process(self):
        fr = self.inp.find(self.boundary)
        out_pos = None
        while fr != -1:        
            self.inp_pos = fr + len(self.boundary)
            fr1 = self.inp.find(self.boundary, self.inp_pos)
            if fr1 != -1:                            
                frame = self.parse_packet(self.inp[fr: fr1])
                if not frame is None:
                    self.buffer_pos = self.queue.addbuf(frame)
                    self.frame_count += 1
                    self.last_stamp = datetime.datetime.now()
                    if not self.frame_count % frame_stat_rate:
                        now = datetime.datetime.now()                        
                        s = ""
                        if not self.last_count_stamp is None:
                            dt = now - self.last_count_stamp
            #                print dt
                            sec = (dt.microseconds + dt.seconds * 10**6) / 1000000.0
                            self.fps = float(frame_stat_rate)/sec
                            s = " %f sec (%f fps)" % (sec, self.fps)
                        self.last_count_stamp = now                    
                        
                        self.logger.debug( "ZmClient %s: %sth Frame processed. Length %s total count %s %s" % (self.host, frame_stat_rate, len(frame), self.frame_count, s))
                        if self.status() != "Ok":
                            self.logger.info("Camera connection restored")
                            self._status = "Ok"
                        f = open('bee.jpg', 'w')
                        f.write(frame)
                        f.close()
                    out_pos = fr1        
            fr = fr1    
        if out_pos:
            self.inp = self.inp[out_pos:]
        return

    def handle_connect(self):
        self.logger.debug( "Connected. Sending %s" % self.buffer)
        self.nconnects += 1
        pass

    def handle_close(self):
        self.logger.debug('Closing socket')
        self.close()
        self._status = 'disconnected'
        #
        #  As we don't support 'normal' shutdown, closing socket is not expected operation. Try to reconnect it.
        #
        
    def handle_error(self):        
        self.logger.error("ChannelHandler %d: handle_error." % self.id)
        self.logger.exception('Exception details:')         
        self.close()
        self._status = 'disconnected'
        
    def handle_read(self):
        buf = self.recv(8192)
#        self.inp = ''.join([self.inp, buf])
        self.inp = '%s%s' % (self.inp, buf)

        if not self.http_started:
            self.start_http()
            return
            
        if not self.chan_started:
            self.start_channel()
            return
            
        self.stream_process()

    def writable(self):
        return (len(self.buffer) > 0)

    def handle_write(self):
        sent = self.send(self.buffer)
        self.buffer = self.buffer[sent:]
        
    def start(self):
        return
    
    def stop(self):
        return
    
    def join(self):
        return
示例#8
0
class ZmClient(asyncore.dispatcher):
    boundary = '--ZoneMinderFrame'
    logger_map = {}

    def __init__(self, src):
        asyncore.dispatcher.__init__(self)
        self.id = src.id
        self.logger = self.setupLogger('zmproxy.ZmClient')
        self.src = src
        self.host = src.host
        self.path = src.path
        self.user = src.user
        self.passwd = src.passwd
        self.camera_path = ""
        self.queue = FrameQueue(src.queuesz)
        self.buffer = ""
        self.inp = ""
        self.frame_count = 0
        self.last_stamp = None
        self.chan_started = False
        self.http_started = False
        self._status = 'offline'
        self.head = {}
        self.buf = ''
        self.inp_pos = 0
        self.buffer_pos = 0
        self.fps = 0.0
        self.nconnects = 0
        self.last_count_stamp = None
        self.filehdl = None
        try:
            if self.user != None and self.user != "":
                self.login()
            self.Connect()
        except:
            self.logger.error("Camera connect FAILED")
            self.logger.info(sys.exc_info())

    def __del__(self):
        if hasattr(self, "filehdl") and not self.filehdl is None:
            self.filehdl.close()

    def setupLogger(self, module_name):
        lname = module_name + "_%d" % self.id
        if self.logger_map.has_key(lname):
            return self.logger_map[lname]

        logger = logging.getLogger(lname)
        logger.setLevel(logging.DEBUG)
        #        conshdl = logging.StreamHandler()
        #        conshdl.setLevel(logging.DEBUG)

        self.filehdl = logging.FileHandler('zmproxy_input_%d.log' % self.id)
        self.filehdl.setLevel(logging.DEBUG)

        formatter = logging.Formatter(
            '%(asctime)s %(name)s %(levelname)s %(message)s')
        #        conshdl.setFormatter(formatter)
        self.filehdl.setFormatter(formatter)
        #        logger.addHandler(conshdl)
        logger.addHandler(self.filehdl)
        self.logger_map[lname] = logger
        return logger

    def login(self):
        url = 'http://' + self.host + self.path
        self.logger.info('Loging in ' + url + ' as ' + self.user)
        hdl = LoginHandler(self.logger, self.host, self.path)
        hdl.login(self.user, self.passwd)
        if hdl.src == None:
            self.logger.error('Login FAILED')
            raise Exception('Login Failed')
        self.camera_path = hdl.src
        self.logger.info('Login performed')
        return

    def Connect(self):
        ''' Connect to data socket
        '''

        self.buffer = "GET %s\r\n\r\n" % self.camera_path

        self.create_socket(socket.AF_INET, socket.SOCK_STREAM)
        self.logger.debug('Connecting to ' + self.host + ' port 80')
        self.connect((self.host, 80))

    def parse_packet(self, in_str):
        ''' Receive packet starting with boundary, to the end start of next boundary
        '''

        packet = cStringIO.StringIO(in_str)
        content_type = None
        content_length = None
        in_head = False
        while 1:
            line = packet.readline().strip()
            if len(line) == 0:
                if not in_head:
                    in_head = True
                    continue
                else:
                    break

            if line == self.boundary:
                # Found next boundary - give up
                in_head = True
                continue

            parts = line.split(':')
            if len(parts) == 2:
                if parts[0] == 'Content-Type':
                    content_type = parts[1].strip()
                elif parts[0] == 'Content-Length':
                    content_length = int(parts[1])

        buf = packet.read(content_length)
        if content_type != 'image/jpeg':
            self.logger.warning(
                "ZmClient: warning: wrong packet type. Got %s, expected image/jpeg "
                % content_type)
        if len(buf) != content_length:
            self.logger.warning(
                "ZmClient: warning: packet of wrong size. Got %s bytes, expected from header %s"
                % (len(buf), content_length))
            db = len(buf) - content_length
            self.logger.debug(
                "Extra bytes: %d (%s)" %
                (len(buf[-db:]), ' '.join([hex(ord(x)) for x in buf[-db:]])))
        packet.close()
        #        self.logger.debug("Packet received: %d bytes" % len(buf))
        return buf

    def status(self):
        if self._status == 'Ok':
            if not self.last_stamp is None:
                datediff = datetime.datetime.now() - self.last_stamp
                if datediff > datetime.timedelta(0, 60):
                    self._status = 'hang'
            else:
                self._status = 'no signal'

        return self._status

    def start_http(self):
        ''' Read HTTP header(s) and check if we are listening for the right source
        '''
        packet = cStringIO.StringIO(self.inp)
        while 1:
            line = packet.readline().strip()
            if not line:
                break
            self.logger.debug("ZmClient: recieved header line: %s" % line)
            if line == 'HTTP/1.0 200 OK':
                self.http_started = True
                pos = packet.tell()
                self.inp = self.inp[pos:]
                self._status = "Ok"
            else:
                self.logger.debug(
                    'ZmClient error: wrong HTTP header line: %s' % line)
                #                self.logger.debug( packet.getvalue() )
                self._status = "error"
            return

    def start_channel(self):
        ''' Read HTTP header(s) and check if we are listening for the right source
        '''
        packet = cStringIO.StringIO(self.inp)
        while 1:
            line = packet.readline().strip()
            if not line:
                break
            self.logger.debug("ZmClient: recieved header line: %s" % line)
            parts = line.split(':')
            self.head[parts[0]] = parts[1]
        if self.head.has_key('Content-Type'):
            self.chan_started = True
            self.inp = ''

    def stream_process(self):
        fr = self.inp.find(self.boundary)
        out_pos = None
        while fr != -1:
            self.inp_pos = fr + len(self.boundary)
            fr1 = self.inp.find(self.boundary, self.inp_pos)
            if fr1 != -1:
                frame = self.parse_packet(self.inp[fr:fr1])
                if not frame is None:
                    self.buffer_pos = self.queue.addbuf(frame)
                    self.frame_count += 1
                    self.last_stamp = datetime.datetime.now()
                    if not self.frame_count % frame_stat_rate:
                        now = datetime.datetime.now()
                        s = ""
                        if not self.last_count_stamp is None:
                            dt = now - self.last_count_stamp
                            #                print dt
                            sec = (dt.microseconds +
                                   dt.seconds * 10**6) / 1000000.0
                            self.fps = float(frame_stat_rate) / sec
                            s = " %f sec (%f fps)" % (sec, self.fps)
                        self.last_count_stamp = now

                        self.logger.debug(
                            "ZmClient %s: %sth Frame processed. Length %s total count %s %s"
                            % (self.host, frame_stat_rate, len(frame),
                               self.frame_count, s))
                        if self.status() != "Ok":
                            self.logger.info("Camera connection restored")
                            self._status = "Ok"
                        f = open('bee.jpg', 'w')
                        f.write(frame)
                        f.close()
                    out_pos = fr1
            fr = fr1
        if out_pos:
            self.inp = self.inp[out_pos:]
        return

    def handle_connect(self):
        self.logger.debug("Connected. Sending %s" % self.buffer)
        self.nconnects += 1
        pass

    def handle_close(self):
        self.logger.debug('Closing socket')
        self.close()
        self._status = 'disconnected'
        #
        #  As we don't support 'normal' shutdown, closing socket is not expected operation. Try to reconnect it.
        #

    def handle_error(self):
        self.logger.error("ChannelHandler %d: handle_error." % self.id)
        self.logger.exception('Exception details:')
        self.close()
        self._status = 'disconnected'

    def handle_read(self):
        buf = self.recv(8192)
        #        self.inp = ''.join([self.inp, buf])
        self.inp = '%s%s' % (self.inp, buf)

        if not self.http_started:
            self.start_http()
            return

        if not self.chan_started:
            self.start_channel()
            return

        self.stream_process()

    def writable(self):
        return (len(self.buffer) > 0)

    def handle_write(self):
        sent = self.send(self.buffer)
        self.buffer = self.buffer[sent:]

    def start(self):
        return

    def stop(self):
        return

    def join(self):
        return