Esempio n. 1
0
    def _run_impl(self):
        sync = Greenlet(retry_and_report_killed,
                        self.sync,
                        account_id=self.account_id,
                        logger=self.log)
        sync.link_value(lambda _: report_stopped(account_id=self.account_id))
        sync.start()
        while not sync.ready():
            try:
                cmd = self.inbox.get_nowait()
                if not self.process_command(cmd):
                    # ctrl-c, basically!
                    self.log.info("Stopping sync", email=self.email_address)
                    # make sure the parent can't start/stop any folder monitors
                    # first
                    sync.kill(block=True)
                    self.folder_monitors.kill()
                    return
            except Empty:
                sleep(self.heartbeat)

        if sync.successful():
            self.folder_monitors.kill()
            return

        self.log.error("mail sync should run forever",
                       provider=self.provider_name,
                       account_id=self.account_id)
        raise sync.exception
Esempio n. 2
0
    def __init__(self, account_id, folder_name, folder_id,
                 email_address, provider, shared_state, state_handlers):
        self.account_id = account_id
        self.folder_name = folder_name
        self.folder_id = folder_id
        self.shared_state = shared_state
        self.state_handlers = state_handlers
        self.state = None
        self.conn_pool = connection_pool(self.account_id)

        self.log = get_logger(account_id, 'mailsync')

        Greenlet.__init__(self)
        self.link_value(lambda _: report_stopped(account_id=self.account_id,
                                                 folder_name=self.folder_name))
Esempio n. 3
0
    def __init__(self, account_id, email_address, provider, heartbeat=1):
        self.inbox = Queue()
        # how often to check inbox, in seconds
        self.heartbeat = heartbeat
        self.log = configure_mailsync_logging(account_id)
        self.account_id = account_id
        self.email_address = email_address
        self.provider = provider

        # Stuff that might be updated later and we want to keep a shared
        # reference on child greenlets.
        if not hasattr(self, 'shared_state'):
            self.shared_state = dict()

        Greenlet.__init__(self)
        self.link_value(lambda _: report_stopped(self.account_id))
Esempio n. 4
0
    def __init__(self, account_id, folder_name, folder_id, email_address,
                 provider_name, shared_state, state_handlers,
                 retry_fail_classes):
        self.account_id = account_id
        self.folder_name = folder_name
        self.folder_id = folder_id
        self.shared_state = shared_state
        self.state_handlers = state_handlers
        self.state = None
        self.conn_pool = _pool(self.account_id)
        self.retry_fail_classes = retry_fail_classes

        self.log = logger.new(account_id=account_id, folder=folder_name)

        Greenlet.__init__(self)
        self.link_value(lambda _: report_stopped(account_id=self.account_id,
                                                 folder_name=self.folder_name))
Esempio n. 5
0
    def __init__(self, account_id, folder_name, folder_id, email_address,
                 provider_name, shared_state, state_handlers,
                 retry_fail_classes):
        self.account_id = account_id
        self.folder_name = folder_name
        self.folder_id = folder_id
        self.shared_state = shared_state
        self.state_handlers = state_handlers
        self.state = None
        self.conn_pool = _pool(self.account_id)
        self.retry_fail_classes = retry_fail_classes

        self.log = logger.new(account_id=account_id, folder=folder_name)

        Greenlet.__init__(self)
        self.link_value(lambda _: report_stopped(account_id=self.account_id,
                                                 folder_name=self.folder_name))
Esempio n. 6
0
File: base.py Progetto: dlitz/inbox
    def __init__(self, account, heartbeat=1, retry_fail_classes=[]):
        self.inbox = Queue()
        # how often to check inbox, in seconds
        self.heartbeat = heartbeat
        self.log = logger.new(component='mail sync', account_id=account.id)
        self.account_id = account.id
        self.email_address = account.email_address
        self.provider_name = account.provider
        self.retry_fail_classes = self.RETRY_FAIL_CLASSES
        self.retry_fail_classes.extend(retry_fail_classes)

        # Stuff that might be updated later and we want to keep a shared
        # reference on child greenlets.
        if not hasattr(self, 'shared_state'):
            self.shared_state = dict()

        Greenlet.__init__(self)
        self.link_value(lambda _: report_stopped(self.account_id))
Esempio n. 7
0
    def __init__(self, account, heartbeat=1, retry_fail_classes=[]):
        self.inbox = Queue()
        # how often to check inbox, in seconds
        self.heartbeat = heartbeat
        self.log = logger.new(component='mail sync', account_id=account.id)
        self.account_id = account.id
        self.email_address = account.email_address
        self.provider_name = account.provider
        self.retry_fail_classes = self.RETRY_FAIL_CLASSES
        self.retry_fail_classes.extend(retry_fail_classes)

        # Stuff that might be updated later and we want to keep a shared
        # reference on child greenlets.
        if not hasattr(self, 'shared_state'):
            self.shared_state = dict()

        Greenlet.__init__(self)
        self.link_value(lambda _: report_stopped(self.account_id))
Esempio n. 8
0
    def __init__(self, account_id, email_address, provider, heartbeat=1,
                 retry_fail_classes=[MailsyncError,
                                     ValueError, AttributeError,
                                     DataError, IntegrityError]):
        self.inbox = Queue()
        # how often to check inbox, in seconds
        self.heartbeat = heartbeat
        self.log = logger.new(component='mail sync', account_id=account_id)
        self.account_id = account_id
        self.email_address = email_address
        self.provider = provider
        self.retry_fail_classes = retry_fail_classes

        # Stuff that might be updated later and we want to keep a shared
        # reference on child greenlets.
        if not hasattr(self, 'shared_state'):
            self.shared_state = dict()

        Greenlet.__init__(self)
        self.link_value(lambda _: report_stopped(self.account_id))
Esempio n. 9
0
    def __init__(self, account_id, folder_name, folder_id, email_address,
                 provider_name, poll_frequency, syncmanager_lock,
                 refresh_flags_max, retry_fail_classes):
        self.account_id = account_id
        self.folder_name = folder_name
        self.folder_id = folder_id
        self.poll_frequency = poll_frequency
        self.syncmanager_lock = syncmanager_lock
        self.refresh_flags_max = refresh_flags_max
        self.retry_fail_classes = retry_fail_classes
        self.state = None
        self.conn_pool = _pool(self.account_id)

        self.state_handlers = {
            'initial': self.initial_sync,
            'initial uidinvalid': self.resync_uids_from('initial'),
            'poll': self.poll,
            'poll uidinvalid': self.resync_uids_from('poll'),
            'finish': lambda self: 'finish',
        }

        Greenlet.__init__(self)
        self.link_value(lambda _: report_stopped(account_id=self.account_id,
                                                 folder_name=self.folder_name))
Esempio n. 10
0
    def __init__(self, account_id, folder_name, folder_id, email_address,
                 provider_name, poll_frequency, syncmanager_lock,
                 refresh_flags_max, retry_fail_classes):
        self.account_id = account_id
        self.folder_name = folder_name
        self.folder_id = folder_id
        self.poll_frequency = poll_frequency
        self.syncmanager_lock = syncmanager_lock
        self.refresh_flags_max = refresh_flags_max
        self.retry_fail_classes = retry_fail_classes
        self.state = None
        self.conn_pool = _pool(self.account_id)

        self.state_handlers = {
            'initial': self.initial_sync,
            'initial uidinvalid': self.resync_uids_from('initial'),
            'poll': self.poll,
            'poll uidinvalid': self.resync_uids_from('poll'),
            'finish': lambda self: 'finish',
        }

        Greenlet.__init__(self)
        self.link_value(lambda _: report_stopped(account_id=self.account_id,
                                                 folder_name=self.folder_name))
Esempio n. 11
-1
File: base.py Progetto: dlitz/inbox
    def _run_impl(self):
        sync = Greenlet(retry_and_report_killed, self.sync,
                        account_id=self.account_id, logger=self.log)
        sync.link_value(lambda _: report_stopped(account_id=self.account_id))
        sync.start()
        while not sync.ready():
            try:
                cmd = self.inbox.get_nowait()
                if not self.process_command(cmd):
                    # ctrl-c, basically!
                    self.log.info("Stopping sync", email=self.email_address)
                    # make sure the parent can't start/stop any folder monitors
                    # first
                    sync.kill(block=True)
                    self.folder_monitors.kill()
                    return
            except Empty:
                sleep(self.heartbeat)

        if sync.successful():
            self.folder_monitors.kill()
            return

        self.log.error("mail sync should run forever",
                       provider=self.provider_name,
                       account_id=self.account_id)
        raise sync.exception