Example #1
0
 def lock(self, key, owner, timeout=None, expire=None):
     if not self.locker:
         db = self.mongo_database()
         self.locker = MongoLock(client=db.client, db=db.name)
     try:
         with self.locker(key, owner, timeout=timeout, expire=expire):
             yield
     except MongoLockLocked:
         #lock_doc = self.locker.get_lock_info(key)
         raise errors.Locked(key=key, owner=owner)
     finally:
         self.locker.release(key, owner)
Example #2
0
class Context(object):
    def __init__(self, mongo_url=None, verbose=False,
                 log_level='ERROR', log_config=None, log_file=None,
                 trace=False,
                 cache_enable=False,  
                 requests_cache_enable=None, requests_cache_path=None, 
                 requests_cache_expire=None,               
                 debug=False, silent=False, pretty=False, quiet=False):

        self.mongo_url = mongo_url
        self.verbose = verbose
        self.debug = debug
        self.silent = silent
        self.pretty = pretty
        self.quiet = quiet
        self.trace = trace
        
        self.cache_enable = cache_enable
        
        self.requests_cache_enable = requests_cache_enable
        self.requests_cache_path = requests_cache_path
        self.requests_cache_expire = requests_cache_expire
        
        self.log_level = log_level
        self.log_config = log_config
        self.log_file = log_file
        
        if self.verbose and log_level != "DEBUG":
            self.log_level = 'INFO'
        
        self.locker = None
        
        self.client_mongo = None
        self.db_mongo = None
        self.client_es = None
        self.fs_mongo = None
        
        self.logger = configure_logging(debug=self.debug, 
                                config_file=self.log_config, 
                                level=self.log_level)
        
        if self.log_file:
            self._set_log_file()
            
        if self.cache_enable:
            self._set_cache()
            
        if self.requests_cache_enable:
            self._set_requests_cache()
            
        if self.trace:
            from widukind_common import debug
            debug.TRACE_ENABLE = True
            atexit.register(debug.flush_logs)

    def _set_log_file(self):
        from logging import FileHandler
        handler = FileHandler(filename=self.log_file)
        if self.logger.hasHandlers():
            handler.setFormatter(self.logger.handlers[0].formatter)
        self.logger.addHandler(handler)
        
    def _set_cache(self):
        from dlstats import cache
        cache.configure_cache(cache_url=CACHE_URL)
            
    def _set_requests_cache(self):

        cache_settings = {
            "backend": 'sqlite', 
            "cache_name": self.requests_cache_path, 
            "expire_after": self.requests_cache_expire,
            "include_get_headers": True
        }
        
        if self.requests_cache_expire <= 0:
            cache_settings["expire_after"] = None
        
        try:
            import requests_cache
            requests_cache.install_cache(**cache_settings)
            self.log("Use requests cache in %s" % self.requests_cache_path)
        except ImportError:
            self.log_warn("requests-cache library is required for enable cache.")
            
    def log(self, msg, *args):
        """Logs a message to stderr."""
        if args:
            msg %= args
        if self.quiet:
            self.logger.info(msg)
            return
        click.echo(msg, file=sys.stderr)

    def log_error(self, msg, *args):
        """Logs a message to stderr."""
        if args:
            msg %= args
        if self.quiet:
            self.logger.error(msg)
            return
        click.echo(click.style(msg, fg='red'), file=sys.stderr)

    def log_ok(self, msg, *args):
        """Logs a message to stdout."""
        if args:
            msg %= args
        if self.quiet:
            self.logger.info(msg)
            return
        click.echo(click.style(msg, fg='green'), file=sys.stdout)

    def log_warn(self, msg, *args):
        """Logs a message to stdout."""
        if args:
            msg %= args
        if self.quiet:
            self.logger.warn(msg)
            return
        click.echo(click.style(msg, fg='yellow'), file=sys.stdout)

    def pretty_print(self, obj):
        pprint.pprint(obj)

    def mongo_client(self):
        if not self.client_mongo:
            self.client_mongo = get_mongo_client(self.mongo_url.strip('"'))
        return self.client_mongo
    
    @contextlib.contextmanager
    def lock(self, key, owner, timeout=None, expire=None):
        if not self.locker:
            db = self.mongo_database()
            self.locker = MongoLock(client=db.client, db=db.name)
        try:
            with self.locker(key, owner, timeout=timeout, expire=expire):
                yield
        except MongoLockLocked:
            #lock_doc = self.locker.get_lock_info(key)
            raise errors.Locked(key=key, owner=owner)
        finally:
            self.locker.release(key, owner)
    
    def mongo_database(self):
        if not self.db_mongo:
            self.db_mongo = self.mongo_client().get_default_database()
        return self.db_mongo
    
    def mongo_fs(self):
        db = self.mongo_database()
        if not self.fs_mongo:
            self.fs_mongo = gridfs.GridFS(db)
        return self.fs_mongo