def new_onRosterSet(f):
log = getLoggerAdapter(getLogger('wokkel_onRosterSet', level='INFO'),
id='TWISTED')
@wraps(f)
def wrapper(self, iq):
def trapIgnored(failure):
failure.trap(RosterPushIgnored)
raise error.StanzaError('service-unavailable')
request = RosterRequest.fromElement(iq)
if (not self.allowAnySender and request.sender and
request.sender.userhostJID() != self.parent.jid.userhostJID()):
d = defer.fail(RosterPushIgnored())
elif request.item is None:
log.info('_onRosterSet iq malformed. %s', iq.toXml())
d = defer.fail(RosterPushIgnored())
elif request.item.remove:
d = defer.maybeDeferred(self.removeReceived, request)
else:
d = defer.maybeDeferred(self.setReceived, request)
d.addErrback(trapIgnored)
return d
return wrapper
def setup(cls, url=None, log=None):
if cls.redis_conn is None:
if url is None:
url = conf.REDIS_URL
hostname, port, db, _, password = url_parse(url, 'redis')
cls.redis_db = int(db)
AuthRedisProtocol.password = password
if log is None:
log = getLoggerAdapter(getLogger(__name__),
id='REDIS_CONNECTIONPOOL')
cls.log = AuthRedisProtocol.log = log
RedisFactory.protocol = AuthRedisProtocol
cls.redis_conn = redis.lazyConnectionPool(host=hostname,
port=port,
dbid=cls.redis_db,
poolsize=conf.REDIS_POOL,
reconnect=True)
def setup(cls, url=None, log=None):
if cls.mongo_conn is None:
if url is None:
url = conf.MONGO_URL
hostname, port, cls.mongo_db, username, password = url_parse(
url, 'mongodb')
AuthMongoProtocol.database = cls.mongo_db
AuthMongoProtocol.username = username
AuthMongoProtocol.password = password
if log is None:
log = getLoggerAdapter(getLogger(__name__),
id='MONGO_CONNECTIONPOOL')
cls.log = AuthMongoProtocol.log = log
txmongo._MongoFactory.protocol = AuthMongoProtocol
txmongo._MongoFactory.maxRetries = conf.BACKEND_MAX_RETRIES
txmongo._MongoFactory.maxDelay = conf.BACKEND_MAX_DELAY
cls.mongo_conn = txmongo.lazyMongoConnectionPool(
host=hostname,
port=port,
reconnect=True,
pool_size=conf.MONGO_POOL)
os.environ[
'ADOPTED_STREAM'] = '' #Avoid to perform Mutlprocess Service in child processes
if conf.MULTIPROCESS > 0:
m = MultiProcess(__file__, number=conf.MULTIPROCESS)
m.setServiceParent(application)
metrics_supervisor = MetricsSupervisor()
metrics_supervisor.setServiceParent(application)
xmpp_keepalive_supervisor = XMPPKeepAliveSupervisor()
xmpp_keepalive_supervisor.setServiceParent(application)
if conf.REDIS_WORKERS > 0:
worker.LOGGING_OK_JOBS = conf.LOGGING_OK_JOBS
worker.SLEEP_CALL = sleep
worker.MAX_RETRIES = conf.BACKEND_MAX_RETRIES
worker.MAX_DELAY_TIME = conf.BACKEND_MAX_DELAY
w = worker.Worker(
[conf.MACHINEID, conf.DIST_QUEUE_LOGIN, conf.DIST_QUEUE_RELOGIN],
name=conf.MACHINEID,
loops=conf.REDIS_WORKERS,
default_result_ttl=conf.DIST_DEFAULT_TTL,
default_warmup=conf.WORKER_WARMUP,
default_enqueue_failed_jobs=conf.DIST_ENQUEUE_FAILED_JOBS,
default_perform_job_in_thread=conf.DIST_PERFORM_JOB_IN_THREAD,
default_thread_pool_size=conf.DIST_THREAD_POOL)
w.log = getLoggerAdapter(getLogger('WORKER', level='INFO'), id='WORKER')
w.setServiceParent(application)
deferred_list.append(self.user.save())
deferred_list.append(GoogleMessage.updateRemoveTime(self.user.userid, self.user.lastTimeConnected))
deferred_list.append(GoogleRosterItem.remove(self.user.userid))
return defer.DeferredList(deferred_list, consumeErrors=True)
def __str__(self):
return '<%s object at %s. name: %s>(user: %s)'%(self.__class__.__name__, hex(id(self)), self.name, self.user)
if __name__ == '__main__':
import os
from katoo.data import GoogleUser
from wokkel_extensions import XMPPClient
from katoo.utils.applog import getLogger, getLoggerAdapter
from katoo.apns.api import KatooAPNSService
from katoo.supervisor import XMPPKeepAliveSupervisor
my_log = getLoggerAdapter(getLogger(__name__, level="INFO"), id='MYLOG')
app = KatooApp().app
KatooAPNSService().service.setServiceParent(app)
KatooApp().start()
XMPPKeepAliveSupervisor().setServiceParent(app)
import twisted.python.log
twisted.python.log.startLoggingWithObserver(KatooApp().log.emit)
user = GoogleUser("1", _token=os.getenv('TOKEN'), _refreshtoken=os.getenv('REFRESHTOKEN'), _resource="asdfasdf", _pushtoken=os.getenv('PUSHTOKEN', None), _jid=os.getenv('JID'), _pushsound='cell1.aif', _favoritesound='cell7.aif', _away=True)
my_log.info('Instance user: %s', user)
xmppclient = XMPPGoogle(user, app)
my_log.info('Instance xmppclient: %s', xmppclient)
xmppclient.log.info("Instance XMPPGoogle %s. Instance ReauthXMPP %s Instance XMPPClient %s Instance GoogleUser %s", isinstance(xmppclient, XMPPGoogle), isinstance(xmppclient, ReauthXMPPClient), isinstance(xmppclient, XMPPClient), isinstance(xmppclient, GoogleUser))
reactor.run()
from cyclone.escape import json_encode
from katoo import conf
from katoo.api import API
from katoo.data import GoogleUser, GoogleMessage
from katoo.exceptions import XMPPUserAlreadyLogged, XMPPUserNotLogged
from katoo.metrics import IncrementMetric, Metric
from katoo.utils.applog import getLoggerAdapter, getLogger
from katoo.utils.connections import RedisMixin
from katoo.utils.time import Timer
from twisted.internet import defer
import cyclone.web
import re
import urllib
log = getLogger(__name__)
METRIC_UNIT = 'requests'
METRIC_UNIT_TIME = 'ms'
METRIC_SOURCE = 'RESTAPI'
class RequiredArgument(object):
pass
class DefaultArgument(object):
pass
class arguments(object):
from katoo.apns.api import API as APNSAPI
from katoo.data import GoogleUser
from katoo.globalmetrics import RedisMetrics, MongoMetrics
from katoo.metrics import MetricsHub, Metric
from katoo.rqtwisted.job import Job
from katoo.rqtwisted.queue import Queue
from katoo.rqtwisted.worker import Worker
from katoo.utils.applog import getLogger, getLoggerAdapter
from katoo.utils.patterns import Subject
from twisted.application import service
from twisted.internet import defer, reactor
from twisted.internet.task import LoopingCall
import cyclone.httpclient
import translate
log = getLogger(__name__, level='INFO')
class Supervisor(service.Service):
def __init__(self):
self.tasks = []
def registerTask(self, t):
self.tasks.append(t)
def stopService(self):
if self.running:
service.Service.stopService(self)
for task in self.tasks:
self.log.info('STOPPING_TASK %s', task)
task.stop()
Created on Jul 2, 2013
@author: pvicente
'''
from functools import wraps
from katoo import conf
from katoo.exceptions import XMPPUserNotLogged, DistributedJobTimeout, \
DistributedJobFailure
from katoo.rqtwisted.job import Job
from katoo.rqtwisted.queue import Queue, Status
from katoo.utils.applog import getLogger, getLoggerAdapter
from katoo.metrics import IncrementMetric
from katoo.utils.time import sleep
from twisted.internet import defer
log = getLogger(__name__)
class DistributedAPI(object):
"""API with distributed behaviour must subclass it to be performed"""
def __init__(self, key=None, queue=None, synchronous_call=False):
self.key = key
self.queue_name = None if conf.DIST_DISABLED else queue
self.enqueued = False
self.sync = synchronous_call
self._log = getLoggerAdapter(log, id=self.key)
def __getstate__(self):
self._log = None
return self.__dict__
@author: pvicente
'''
from datetime import timedelta
from katoo import conf
from katoo.data import GoogleMessage, GoogleRosterItem, GoogleUser
from katoo.metrics import Metric
from katoo.rqtwisted.queue import Queue, FailedQueue
from katoo.utils.applog import getLogger, getLoggerAdapter
from katoo.utils.connections import RedisMixin
from katoo.utils.patterns import Observer
from katoo.utils.time import Timer
from twisted.internet import defer
log = getLoggerAdapter(getLogger(__name__),id='GLOBAL_METRICS')
class RedisMetrics(Observer):
SOURCE='REDIS'
UNIT='keys'
def __init__(self):
self._connection = RedisMixin.redis_conn
self._keys=Metric(name="keys", value=None, unit=self.UNIT, source=self.SOURCE)
failed_queue_name = FailedQueue().name
self._items={conf.DIST_QUEUE_LOGIN: Metric(name='queue_%s'%(conf.DIST_QUEUE_LOGIN), value=None, unit=self.UNIT, source=self.SOURCE),
conf.DIST_QUEUE_PUSH: Metric(name='queue_%s'%(conf.DIST_QUEUE_PUSH), value=None, unit=self.UNIT, source=self.SOURCE),
conf.DIST_QUEUE_RELOGIN: Metric(name='queue_%s'%(conf.DIST_QUEUE_RELOGIN), value=None, unit=self.UNIT, source=self.SOURCE),
failed_queue_name: Metric(name='queue_%s'%(failed_queue_name), value=None, unit=self.UNIT, source=self.SOURCE)
}
@defer.inlineCallbacks
@AsynchronousCall(conf.DIST_QUEUE_PUSH)
def sendpush(self, message, token, badgenumber, sound='', **kwargs):
self.log.debug(
'SEND_PUSH: %s token: %s, badgenumber: %s, sound: %s kwargs: %s',
message, token, badgenumber, sound, kwargs)
return self._sendapn(token, message, sound, badgenumber, **kwargs)
if __name__ == '__main__':
from twisted.internet import reactor, defer, task
from katoo import KatooApp
from katoo.utils.applog import getLoggerAdapter, getLogger
from katoo.rqtwisted import worker
import os, translate
my_log = getLoggerAdapter(getLogger(__name__, level="DEBUG"), id='MYLOG')
#@defer.inlineCallbacks
def send():
my_log.debug('Starting send')
API('TEST').sendpush(
message=translate.TRANSLATORS['en']._('disconnected'),
token=os.getenv('PUSHTOKEN', None),
badgenumber=0,
sound='')
my_log.debug('Finished send')
@defer.inlineCallbacks
def close():
try:
my_log.debug('Starting close')
def constructor(self):
self._time = datetime.utcnow()
self.log = getLoggerAdapter(getLogger(__name__, "INFO"), id='TIMER')
self._interval = conf.TIMER_INTERVAL
self._maxinterval = self._interval * 3
