Пример #1
0
    def on_close(self):
        logging.debug(
            'connection closed for mjpg client for camera %(camera_id)s on port %(port)s'
            % {
                'port': self._port,
                'camera_id': self._camera_id
            })

        if MjpgClient.clients.pop(self._camera_id, None):
            logging.debug(
                'mjpg client for camera %(camera_id)s on port %(port)s removed'
                % {
                    'port': self._port,
                    'camera_id': self._camera_id
                })

        if getattr(self, 'error',
                   None) and self.error.errno != errno.ECONNREFUSED:
            now = time.time()
            if now - MjpgClient._last_erroneous_close_time < settings.MJPG_CLIENT_TIMEOUT:
                msg = 'connection problem detected for mjpg client for camera %(camera_id)s on port %(port)s' % {
                    'port': self._port,
                    'camera_id': self._camera_id
                }

                logging.error(msg)

                if settings.MOTION_RESTART_ON_ERRORS:
                    motionctl.stop(invalidate=True
                                   )  # this will close all the mjpg clients
                    motionctl.start(deferred=True)

            MjpgClient._last_erroneous_close_time = now
Пример #2
0
def start_motion():
    import tornado.ioloop
    import config
    import motionctl

    ioloop = tornado.ioloop.IOLoop.instance()
    
    # add a motion running checker
    def checker():
        if ioloop._stopped:
            return
            
        if not motionctl.running() and motionctl.started() and config.get_enabled_local_motion_cameras():
            try:
                logging.error('motion not running, starting it')
                motionctl.start()
            
            except Exception as e:
                logging.error('failed to start motion: %(msg)s' % {
                        'msg': unicode(e)}, exc_info=True)

        ioloop.add_timeout(datetime.timedelta(seconds=settings.MOTION_CHECK_INTERVAL), checker)
    
    motionctl.start()
        
    ioloop.add_timeout(datetime.timedelta(seconds=settings.MOTION_CHECK_INTERVAL), checker)
def _garbage_collector():
    io_loop = IOLoop.instance()
    io_loop.add_timeout(
        datetime.timedelta(seconds=settings.MJPG_CLIENT_TIMEOUT),
        _garbage_collector)

    now = time.time()
    for camera_id, client in MjpgClient.clients.items():
        port = client.get_port()

        if client.closed():
            continue

        # check for jpeg frame timeout
        last_jpg_time = client.get_last_jpg_time()
        delta = now - last_jpg_time
        if delta > settings.MJPG_CLIENT_TIMEOUT:
            logging.error(
                'mjpg client timed out receiving data for camera %(camera_id)s on port %(port)s'
                % {
                    'camera_id': camera_id,
                    'port': port
                })

            if settings.MOTION_RESTART_ON_ERRORS:
                motionctl.stop(
                    invalidate=True)  # this will close all the mjpg clients
                motionctl.start(deferred=True)

            break

        # check for last access timeout
        '''
Пример #4
0
    def on_close(self):
        logging.debug(
            "connection closed for mjpg client for camera %(camera_id)s on port %(port)s"
            % {"port": self._port, "camera_id": self._camera_id}
        )

        if MjpgClient.clients.pop(self._camera_id, None):
            MjpgClient.last_access.pop(self._camera_id, None)
            MjpgClient.last_jpg_moment.pop(self._camera_id, None)

            logging.debug(
                "mjpg client for camera %(camera_id)s on port %(port)s removed"
                % {"port": self._port, "camera_id": self._camera_id}
            )

        if getattr(self, "error", None) and self.error.errno != errno.ECONNREFUSED:
            now = time.time()
            if now - MjpgClient.last_erroneous_close_time < settings.MJPG_CLIENT_TIMEOUT:
                logging.error(
                    "connection problem detected for mjpg client for camera %(camera_id)s on port %(port)s"
                    % {"port": self._port, "camera_id": self._camera_id}
                )

                motionctl.stop(invalidate=True)  # this will close all the mjpg clients
                motionctl.start(deferred=True)

            MjpgClient.last_erroneous_close_time = now

        # remove the cached picture
        MjpgClient.last_jpgs.pop(self._camera_id, None)
Пример #5
0
def _garbage_collector():
    logging.debug('running garbage collector for mjpg clients...')

    now = datetime.datetime.utcnow()
    for client in MjpgClient.clients.values():
        camera_id = client._camera_id
        port = client._port

        # check for last jpg moment timeout
        last_jpg_moment = MjpgClient.last_jpg_moment.get(camera_id)
        if last_jpg_moment is None:
            MjpgClient.last_jpg_moment[camera_id] = now

            continue

        if client.closed():
            continue

        delta = now - last_jpg_moment
        delta = delta.days * 86400 + delta.seconds

        if delta > settings.MJPG_CLIENT_TIMEOUT:
            logging.error(
                'mjpg client timed out receiving data for camera %(camera_id)s on port %(port)s'
                % {
                    'camera_id': camera_id,
                    'port': port
                })

            motionctl.stop(
                invalidate=True)  # this will close all the mjpg clients
            motionctl.start(deferred=True)

            break

        # check for last access timeout
        last_access = MjpgClient.last_access.get(camera_id)
        if last_access is None:
            continue

        delta = now - last_access
        delta = delta.days * 86400 + delta.seconds

        if settings.MJPG_CLIENT_IDLE_TIMEOUT and delta > settings.MJPG_CLIENT_IDLE_TIMEOUT:
            logging.debug(
                'mjpg client for camera %(camera_id)s on port %(port)s has been idle for %(timeout)s seconds, removing it'
                % {
                    'camera_id': camera_id,
                    'port': port,
                    'timeout': settings.MJPG_CLIENT_IDLE_TIMEOUT
                })

            client.close()

            continue

    io_loop = ioloop.IOLoop.instance()
    io_loop.add_timeout(
        datetime.timedelta(seconds=settings.MJPG_CLIENT_TIMEOUT),
        _garbage_collector)
Пример #6
0
def start_motion():
    import config
    import motionctl

    io_loop = IOLoop.instance()

    # add a motion running checker
    def checker():
        if io_loop._stopped:
            return

        if not motionctl.running() and motionctl.started(
        ) and config.get_enabled_local_motion_cameras():
            try:
                logging.error('motion not running, starting it')
                motionctl.start()

            except Exception as e:
                logging.error('failed to start motion: %(msg)s' %
                              {'msg': unicode(e)},
                              exc_info=True)

        io_loop.add_timeout(
            datetime.timedelta(seconds=settings.MOTION_CHECK_INTERVAL),
            checker)

    try:
        motionctl.start()

    except Exception as e:
        logging.error(str(e), exc_info=True)

    io_loop.add_timeout(
        datetime.timedelta(seconds=settings.MOTION_CHECK_INTERVAL), checker)
Пример #7
0
def _garbage_collector():
    logging.debug('running garbage collector for mjpg clients...')

    io_loop = IOLoop.instance()
    io_loop.add_timeout(
        datetime.timedelta(seconds=settings.MJPG_CLIENT_TIMEOUT),
        _garbage_collector)

    now = time.time()
    for camera_id, client in MjpgClient.clients.items():
        port = client._port

        # check for jpeg frame timeout
        if not client._last_jpg_times:
            client._last_jpg_times.append(now)

        last_jpg_time = client._last_jpg_times[-1]

        if client.closed():
            continue

        delta = now - last_jpg_time
        if delta > settings.MJPG_CLIENT_TIMEOUT:
            logging.error(
                'mjpg client timed out receiving data for camera %(camera_id)s on port %(port)s'
                % {
                    'camera_id': camera_id,
                    'port': port
                })

            if settings.MOTION_RESTART_ON_ERRORS:
                motionctl.stop(
                    invalidate=True)  # this will close all the mjpg clients
                motionctl.start(deferred=True)

            break

        # check for last access timeout
        if client._last_access is None:
            continue

        delta = now - client._last_access
        if settings.MJPG_CLIENT_IDLE_TIMEOUT and delta > settings.MJPG_CLIENT_IDLE_TIMEOUT:
            logging.debug(
                'mjpg client for camera %(camera_id)s on port %(port)s has been idle for %(timeout)s seconds, removing it'
                % {
                    'camera_id': camera_id,
                    'port': port,
                    'timeout': settings.MJPG_CLIENT_IDLE_TIMEOUT
                })

            client.close()

            continue
Пример #8
0
def _check_mounts():
    logging.debug('checking SMB mounts...')
    
    stop, start = update_mounts()
    if stop:
        motionctl.stop()

    if start:
        motionctl.start()
        
    io_loop = ioloop.IOLoop.instance()
    io_loop.add_timeout(datetime.timedelta(seconds=settings.MOUNT_CHECK_INTERVAL), _check_mounts)
Пример #9
0
def _garbage_collector():
    logging.debug("running garbage collector for mjpg clients...")

    io_loop = ioloop.IOLoop.instance()
    io_loop.add_timeout(datetime.timedelta(seconds=settings.MJPG_CLIENT_TIMEOUT), _garbage_collector)

    now = datetime.datetime.utcnow()
    for client in MjpgClient.clients.values():
        camera_id = client._camera_id
        port = client._port

        # check for last jpg moment timeout
        last_jpg_moment = MjpgClient.last_jpg_moment.get(camera_id)
        if last_jpg_moment is None:
            MjpgClient.last_jpg_moment[camera_id] = now

            continue

        if client.closed():
            continue

        delta = now - last_jpg_moment
        delta = delta.days * 86400 + delta.seconds

        if delta > settings.MJPG_CLIENT_TIMEOUT:
            logging.error(
                "mjpg client timed out receiving data for camera %(camera_id)s on port %(port)s"
                % {"camera_id": camera_id, "port": port}
            )

            motionctl.stop(invalidate=True)  # this will close all the mjpg clients
            motionctl.start(deferred=True)

            break

        # check for last access timeout
        last_access = MjpgClient.last_access.get(camera_id)
        if last_access is None:
            continue

        delta = now - last_access
        delta = delta.days * 86400 + delta.seconds

        if settings.MJPG_CLIENT_IDLE_TIMEOUT and delta > settings.MJPG_CLIENT_IDLE_TIMEOUT:
            logging.debug(
                "mjpg client for camera %(camera_id)s on port %(port)s has been idle for %(timeout)s seconds, removing it"
                % {"camera_id": camera_id, "port": port, "timeout": settings.MJPG_CLIENT_IDLE_TIMEOUT}
            )

            client.close()

            continue
Пример #10
0
    def checker():
        if ioloop._stopped:
            return

        if not motionctl.running() and motionctl.started() and config.has_local_enabled_cameras():
            try:
                logging.error("motion not running, starting it")
                motionctl.start()

            except Exception as e:
                logging.error("failed to start motion: %(msg)s" % {"msg": unicode(e)}, exc_info=True)

        ioloop.add_timeout(datetime.timedelta(seconds=settings.MOTION_CHECK_INTERVAL), checker)
Пример #11
0
def _check_mounts():
    import motionctl
    
    logging.debug('checking SMB mounts...')
    
    stop, start = update_mounts()
    if stop:
        motionctl.stop()

    if start:
        motionctl.start()
        
    io_loop = IOLoop.instance()
    io_loop.add_timeout(datetime.timedelta(seconds=settings.MOUNT_CHECK_INTERVAL), _check_mounts)
Пример #12
0
def _garbage_collector():
    logging.debug('running garbage collector for mjpg clients...')
    
    now = datetime.datetime.utcnow()
    for client in MjpgClient.clients.values():
        camera_id = client._camera_id
        port = client._port
        
        # check for last jpg moment timeout
        last_jpg_moment = MjpgClient.last_jpg_moment.get(camera_id)
        if last_jpg_moment is None:
            MjpgClient.last_jpg_moment[camera_id] = now
            
            continue
        
        if client.closed():
            continue

        delta = now - last_jpg_moment
        delta = delta.days * 86400 + delta.seconds
        
        if delta > settings.MJPG_CLIENT_TIMEOUT:
            logging.error('mjpg client timed out receiving data for camera %(camera_id)s on port %(port)s' % {
                    'camera_id': camera_id, 'port': port})
            
            motionctl.stop() # this will close all the mjpg clients
            motionctl.start()
            
            break

        # check for last access timeout
        last_access = MjpgClient.last_access.get(camera_id)
        if last_access is None:
            continue
        
        delta = now - last_access
        delta = delta.days * 86400 + delta.seconds
        
        if delta > settings.MJPG_CLIENT_TIMEOUT:
            logging.debug('mjpg client for camera %(camera_id)s on port %(port)s timed out' % {
                    'camera_id': camera_id, 'port': port})
            
            client.close()

            continue
        
    io_loop = ioloop.IOLoop.instance()
    io_loop.add_timeout(datetime.timedelta(seconds=settings.MJPG_CLIENT_TIMEOUT), _garbage_collector)
Пример #13
0
    def on_close(self):
        logging.debug('connection closed for mjpg client for camera %(camera_id)s on port %(port)s' % {
                'port': self._port, 'camera_id': self._camera_id})
        
        if MjpgClient.clients.pop(self._camera_id, None):
            logging.debug('mjpg client for camera %(camera_id)s on port %(port)s removed' % {
                    'port': self._port, 'camera_id': self._camera_id})

        if getattr(self, 'error', None) and self.error.errno != errno.ECONNREFUSED:
            now = time.time()
            if now - MjpgClient._last_erroneous_close_time < settings.MJPG_CLIENT_TIMEOUT:
                logging.error('connection problem detected for mjpg client for camera %(camera_id)s on port %(port)s' % {
                        'port': self._port, 'camera_id': self._camera_id})
 
                motionctl.stop(invalidate=True) # this will close all the mjpg clients
                motionctl.start(deferred=True)
 
            MjpgClient._last_erroneous_close_time = now
Пример #14
0
def _garbage_collector():
    logging.debug('running garbage collector for mjpg clients...')

    io_loop = IOLoop.instance()
    io_loop.add_timeout(datetime.timedelta(seconds=settings.MJPG_CLIENT_TIMEOUT), _garbage_collector)

    now = time.time()
    for camera_id, client in MjpgClient.clients.items():
        port = client._port
        
        # check for jpeg frame timeout
        if not client._last_jpg_times:
            client._last_jpg_times.append(now)
        
        last_jpg_time = client._last_jpg_times[-1]

        if client.closed():
            continue

        delta = now - last_jpg_time
        if delta > settings.MJPG_CLIENT_TIMEOUT:
            logging.error('mjpg client timed out receiving data for camera %(camera_id)s on port %(port)s' % {
                    'camera_id': camera_id, 'port': port})
            
            if settings.MOTION_RESTART_ON_ERRORS:
                motionctl.stop(invalidate=True) # this will close all the mjpg clients
                motionctl.start(deferred=True)
            
            break

        # check for last access timeout
        if client._last_access is None:
            continue

        delta = now - client._last_access
        if settings.MJPG_CLIENT_IDLE_TIMEOUT and delta > settings.MJPG_CLIENT_IDLE_TIMEOUT:
            logging.debug('mjpg client for camera %(camera_id)s on port %(port)s has been idle for %(timeout)s seconds, removing it' % {
                    'camera_id': camera_id, 'port': port, 'timeout': settings.MJPG_CLIENT_IDLE_TIMEOUT})

            client.close()

            continue
Пример #15
0
    def on_close(self):
        logging.debug('connection closed for mjpg client for camera %(camera_id)s on port %(port)s' % {
                'port': self._port, 'camera_id': self._camera_id})
        
        if MjpgClient.clients.pop(self._camera_id, None):
            MjpgClient.last_access.pop(self._camera_id, None)
            MjpgClient.last_jpg_moment.pop(self._camera_id, None)
            
            logging.debug('mjpg client for camera %(camera_id)s on port %(port)s removed' % {
                    'port': self._port, 'camera_id': self._camera_id})
        
        if getattr(self, 'error', None):
            now = time.time()
            if now - MjpgClient.last_erroneous_close_time < settings.MJPG_CLIENT_TIMEOUT:
                logging.error('connection problem detected for mjpg client for camera %(camera_id)s on port %(port)s' % {
                        'port': self._port, 'camera_id': self._camera_id})

                motionctl.stop() # this will close all the mjpg clients
                motionctl.start()

            MjpgClient.last_erroneous_close_time = now
Пример #16
0
    def checker():
        #vector fix me: print ("Type:",type(io_loop))
        if not io_loop:
            #if io_loop._stopped:
            print("Return...")
            return

        if not motionctl.running() and motionctl.started(
        ) and config.get_enabled_local_motion_cameras():
            try:
                logging.error('motion not running, starting it')
                motionctl.start()

            except Exception as e:
                logging.error('failed to start motion: %(msg)s' %
                              {'msg': str(e)},
                              exc_info=True)

        io_loop.add_timeout(
            datetime.timedelta(seconds=settings.MOTION_CHECK_INTERVAL),
            checker)
Пример #17
0
    def on_close(self):
        logging.debug(
            'connection closed for mjpg client for camera %(camera_id)s on port %(port)s'
            % {
                'port': self._port,
                'camera_id': self._camera_id
            })

        if MjpgClient.clients.pop(self._camera_id, None):
            MjpgClient.last_access.pop(self._camera_id, None)
            MjpgClient.last_jpg_moment.pop(self._camera_id, None)

            logging.debug(
                'mjpg client for camera %(camera_id)s on port %(port)s removed'
                % {
                    'port': self._port,
                    'camera_id': self._camera_id
                })

        if getattr(self, 'error',
                   None) and self.error.errno != errno.ECONNREFUSED:
            now = time.time()
            if now - MjpgClient.last_erroneous_close_time < settings.MJPG_CLIENT_TIMEOUT:
                logging.error(
                    'connection problem detected for mjpg client for camera %(camera_id)s on port %(port)s'
                    % {
                        'port': self._port,
                        'camera_id': self._camera_id
                    })

                motionctl.stop(
                    invalidate=True)  # this will close all the mjpg clients
                motionctl.start(deferred=True)

            MjpgClient.last_erroneous_close_time = now

        # remove the cached picture
        MjpgClient.last_jpgs.pop(self._camera_id, None)