import time
import logging
-import backend
import addressbook
import conversations
import state_machine
+import util.go_utils as gobject_utils
+import util.misc as misc_utils
-_moduleLogger = logging.getLogger("gvoice.session")
+
+_moduleLogger = logging.getLogger(__name__)
class Session(object):
_DEFAULTS = {
- "contacts": (3, "hours"),
- "voicemail": (30, "minutes"),
- "texts": (5, "minutes"),
+ "contacts": (12, "hours"),
+ "voicemail": (120, "minutes"),
+ "texts": (10, "minutes"),
}
_MINIMUM_MESSAGE_PERIOD = state_machine.to_seconds(minutes=30)
else:
for key, (quant, unit) in defaults.iteritems():
if quant == 0:
- defaults[key] = self._DEFAULTS[key]
+ defaults[key] = (self._DEFAULTS[key], unit)
elif quant < 0:
- defaults[key] = state_machine.INFINITE_PERIOD
+ defaults[key] = (state_machine.UpdateStateMachine.INFINITE_PERIOD, unit)
self._username = None
self._password = None
+ self._cookiePath = cookiePath
- self._backend = backend.GVoiceBackend(cookiePath)
+ self._lastDndCheck = 0
+ self._cachedIsDnd = False
- contactsPeriodInSeconds = state_machine.to_seconds(
- **{defaults["contacts"][1]: defaults["contacts"][0],}
- )
- self._addressbook = addressbook.Addressbook(self._backend)
+ self._asyncPool = gobject_utils.AsyncPool()
+ import backend
+ self._backend = backend.GVoiceBackend(self._cookiePath)
+
+ if defaults["contacts"][0] == state_machine.UpdateStateMachine.INFINITE_PERIOD:
+ contactsPeriodInSeconds = state_machine.UpdateStateMachine.INFINITE_PERIOD
+ else:
+ contactsPeriodInSeconds = state_machine.to_seconds(
+ **{defaults["contacts"][1]: defaults["contacts"][0],}
+ )
+ self._addressbook = addressbook.Addressbook(self._backend, self._asyncPool)
self._addressbookStateMachine = state_machine.UpdateStateMachine([self.addressbook], "Addressbook")
self._addressbookStateMachine.set_state_strategy(
state_machine.StateMachine.STATE_DND,
state_machine.ConstantStateStrategy(contactsPeriodInSeconds)
)
- voicemailPeriodInSeconds = state_machine.to_seconds(
- **{defaults["voicemail"][1]: defaults["voicemail"][0],}
- )
- self._voicemails = conversations.Conversations(self._backend.get_voicemails)
+ if defaults["voicemail"][0] == state_machine.UpdateStateMachine.INFINITE_PERIOD:
+ voicemailPeriodInSeconds = state_machine.UpdateStateMachine.INFINITE_PERIOD
+ idleVoicemailPeriodInSeconds = state_machine.UpdateStateMachine.INFINITE_PERIOD
+ else:
+ voicemailPeriodInSeconds = state_machine.to_seconds(
+ **{defaults["voicemail"][1]: defaults["voicemail"][0],}
+ )
+ idleVoicemailPeriodInSeconds = max(voicemailPeriodInSeconds * 4, self._MINIMUM_MESSAGE_PERIOD)
+ self._voicemails = conversations.Conversations(self._backend.get_voicemails, self._asyncPool)
self._voicemailsStateMachine = state_machine.UpdateStateMachine([self.voicemails], "Voicemail")
self._voicemailsStateMachine.set_state_strategy(
state_machine.StateMachine.STATE_DND,
)
self._voicemailsStateMachine.set_state_strategy(
state_machine.StateMachine.STATE_IDLE,
- state_machine.ConstantStateStrategy(
- min(voicemailPeriodInSeconds * 4, self._MINIMUM_MESSAGE_PERIOD)
- )
+ state_machine.ConstantStateStrategy(idleVoicemailPeriodInSeconds)
)
self._voicemailsStateMachine.set_state_strategy(
state_machine.StateMachine.STATE_ACTIVE,
- state_machine.ConstantStateStrategy(voicemailPeriodInSeconds)
+ state_machine.NTimesStateStrategy(
+ 3 * [state_machine.to_seconds(minutes=1)], voicemailPeriodInSeconds
+ )
)
self._voicemails.updateSignalHandler.register_sink(
self._voicemailsStateMachine.request_reset_timers
)
- textsPeriodInSeconds = state_machine.to_seconds(
- **{defaults["texts"][1]: defaults["texts"][0],}
- )
- self._texts = conversations.Conversations(self._backend.get_texts)
+ if defaults["texts"][0] == state_machine.UpdateStateMachine.INFINITE_PERIOD:
+ initTextsPeriodInSeconds = state_machine.UpdateStateMachine.INFINITE_PERIOD
+ minTextsPeriodInSeconds = state_machine.UpdateStateMachine.INFINITE_PERIOD
+ textsPeriodInSeconds = state_machine.UpdateStateMachine.INFINITE_PERIOD
+ idleTextsPeriodInSeconds = state_machine.UpdateStateMachine.INFINITE_PERIOD
+ else:
+ initTextsPeriodInSeconds = state_machine.to_seconds(seconds=20)
+ minTextsPeriodInSeconds = state_machine.to_seconds(seconds=1)
+ textsPeriodInSeconds = state_machine.to_seconds(
+ **{defaults["texts"][1]: defaults["texts"][0],}
+ )
+ idleTextsPeriodInSeconds = max(textsPeriodInSeconds * 4, self._MINIMUM_MESSAGE_PERIOD)
+ self._texts = conversations.Conversations(self._backend.get_texts, self._asyncPool)
self._textsStateMachine = state_machine.UpdateStateMachine([self.texts], "Texting")
self._textsStateMachine.set_state_strategy(
state_machine.StateMachine.STATE_DND,
)
self._textsStateMachine.set_state_strategy(
state_machine.StateMachine.STATE_IDLE,
- state_machine.ConstantStateStrategy(
- min(textsPeriodInSeconds * 4, self._MINIMUM_MESSAGE_PERIOD)
- )
+ state_machine.ConstantStateStrategy(idleTextsPeriodInSeconds)
)
self._textsStateMachine.set_state_strategy(
state_machine.StateMachine.STATE_ACTIVE,
state_machine.GeometricStateStrategy(
- state_machine.to_seconds(seconds=20),
- state_machine.to_seconds(seconds=1),
+ initTextsPeriodInSeconds,
+ minTextsPeriodInSeconds,
textsPeriodInSeconds,
)
)
self._masterStateMachine.append_machine(self._voicemailsStateMachine)
self._masterStateMachine.append_machine(self._textsStateMachine)
- self._lastDndCheck = 0
- self._cachedIsDnd = False
-
def load(self, path):
self._texts.load(os.sep.join((path, "texts.cache")))
self._voicemails.load(os.sep.join((path, "voicemails.cache")))
)
self._masterStateMachine.close()
- def login(self, username, password):
+ def login(self, username, password, on_success, on_error):
+ self._asyncPool.start()
+
+ le = gobject_utils.AsyncLinearExecution(self._asyncPool, self._login)
+ le.start(username, password, on_success, on_error)
+
+ @misc_utils.log_exception(_moduleLogger)
+ def _login(self, username, password, on_success, on_error):
self._username = username
self._password = password
- self._backend.login(self._username, self._password)
+
+ isLoggedIn = False
+
+ if not isLoggedIn and self._backend.is_quick_login_possible():
+ try:
+ isLoggedIn = yield (
+ self._backend.is_authed,
+ (),
+ {},
+ )
+ except Exception, e:
+ on_error(e)
+ return
+ if isLoggedIn:
+ _moduleLogger.info("Logged in through cookies")
+
+ if not isLoggedIn:
+ try:
+ isLoggedIn = yield (
+ self._backend.login,
+ (self._username, self._password),
+ {},
+ )
+ except Exception, e:
+ on_error(e)
+ return
+ if isLoggedIn:
+ _moduleLogger.info("Logged in through credentials")
self._masterStateMachine.start()
+ on_success(isLoggedIn)
+
+ def shutdown(self):
+ self._asyncPool.stop()
+ self._masterStateMachine.stop()
+ self._backend.shutdown()
+
+ self._username = None
+ self._password = None
def logout(self):
+ self._asyncPool.stop()
self._masterStateMachine.stop()
self._backend.logout()
if self._username is None and self._password is None:
_moduleLogger.info("Hasn't even attempted to login yet")
return False
- elif self._backend.is_authed():
- return True
else:
- try:
- loggedIn = self._backend.login(self._username, self._password)
- except RuntimeError, e:
- _moduleLogger.exception("Re-authenticating and erroring")
- loggedIn = False
- if loggedIn:
- return True
- else:
- _moduleLogger.info("Login failed")
- self.logout()
- return False
+ isLoggedIn = self._backend.is_authed()
+ if not isLoggedIn:
+ _moduleLogger.error("Not logged in anymore")
+ return isLoggedIn
def set_dnd(self, doNotDisturb):
- self._backend.set_dnd(doNotDisturb)
- self._cachedIsDnd = doNotDisturb
+ if self._cachedIsDnd != doNotDisturb:
+ self._backend.set_dnd(doNotDisturb)
+ self._cachedIsDnd = doNotDisturb
def is_dnd(self):
# To throttle checking with the server, use a 30s cache
newTime = time.time()
if self._lastDndCheck + 30 < newTime:
- self._lasDndCheck = newTime
+ self._lastDndCheck = newTime
self._cachedIsDnd = self._backend.is_dnd()
return self._cachedIsDnd
@property
def backend(self):
- """
- Login enforcing backend
- """
- assert self.is_logged_in(), "User not logged in"
+ assert self.is_logged_in()
return self._backend
@property
+ def pool(self):
+ return self._asyncPool
+
+ @property
def addressbook(self):
return self._addressbook
projects / theonering / blobdiff