def wrapped(*args, **kwargs): try: start = time.time() r = f(*args, **kwargs) finally: logger().debug('Latency (%s): %.4fs' \ % (f.__name__, time.time() - start)) return r
def create_filename(*args, **kwargs): """ Generate filename based on hash of secret key and supplied params. Example usage: import datatime timestamp = datetime.datetime.utcnow().strftime('%Y%m%d.%H%M%S%Z') group_id = group_profile.id contact_email = group_profile.contact_email unique_filename = create_unique_filename(timestamp, group_id, contact_email) * if args is empty list function will generate file name using timestamp and a random key (of length 'FILENAME_RANDOM_KEY_LEN') :param args: list of basestrings to use to construct file name :param kwargs: options :returns: sha1hashed file name """ # extract options append_random_key = kwargs.get('append_random_key', False) random_key_len = kwargs.get('random_key_len', FILENAME_RANDOM_KEY_LEN) lowercase = kwargs.get('lowercase', False) fext = kwargs.get('fext', '') # construct parts for hashing parts = [] def _add(x): if isinstance(x, (list, tuple)): for a in x: _add(a) else: try: assert x parts.append(str(x)) except (AssertionError, TypeError): pass if not args: args = [datetime.datetime.utcnow().strftime('%Y%m%d.%H%M%S%Z'), random_key(random_key_len)] _add(_s('SECRET_KEY')) _add(args) if append_random_key: _add(random_key(random_key_len)) filename = '%s%s' % (sha1hash('.'.join(parts)), fext) if lowercase: filename = filename.lower() logger().debug('create_filename - parts: %s' % repr(parts)) logger().debug('create_filename - hashed filename: %s' % filename) return filename
def _delete(url): e = 0 if use_remote_storage: if not is_local_path(url): ok = delete_remote_media(url) if not ok: e += 1 logger().debug('deleted remote image - %s %s' % (ok, url)) path = url_to_path(url) if os.path.isfile(path): os.remove(path) ok = os.path.isfile(path) == False if not ok: e += 1 logger().debug('deleted image - %s %s' % (ok, path)) return e
def _test_new_logger(self): """ logger should create new logging object if DebugLogger is None. * verify function is calling ``create_log`` with the correct parameters to create a new logger. """ from garage.logger import logger, DebugLogger self._msg("test", "logger", first=True) DebugLogger = None with patch("garage.logger.create_log") as mock_create_log: expected = "foo" mock_create_log.return_value = expected result = logger() args, kwargs = mock_create_log.call_args self.assertEqual(result, expected) self.assertTrue("logname" in kwargs) self.assertTrue("logfile" in kwargs) self.assertTrue("format" in kwargs) self.assertEqual(kwargs["logname"], "garage-test") self.assertEqual(kwargs["logfile"], "garage-test.log") self.assertEqual(kwargs["format"], "%(asctime)s - %(levelname)s - %(message)s") self._msg("result", result) self._msg("args", args) self._msg("kwargs", kwargs)
def delete_cache(cache_key): """ Delete cached object. """ if not get_setting('USE_MINI_CACHE'): return False if cache.get(cache_key): cache.set(cache_key, None, 0) result = True else: result = False if get_setting('CACHE_DEBUG'): if result is True: logger().debug('delete_cache: Deleting cached data: %s' % cache_key) else: logger().debug('delete_cache: Unable to get cached data: %s' % cache_key) return result
def _cache_controller(*args, **kwargs): if not get_setting('USE_MINI_CACHE'): return f(*args, **kwargs) if isinstance(cache_key, basestring): k = cache_key % locals() elif callable(cache_key): k = cache_key(*args, **kwargs) result = cache.get(k) if result is None: result = f(*args, **kwargs) cache.set(k, result, timeout) if get_setting('CACHE_DEBUG'): logger().debug('Cached data: %s' % k) else: if get_setting('CACHE_DEBUG'): logger().debug('Return cached data: %s' % k) return result
def save_to_remote_storage(path, storage=None): """ Push a local file to remote media storage. :param path: local path of file :param storage: storage instance to use (default: default_storage) :returns: url of file on remote storage server """ if not path or not os.path.isfile(path): logger().debug('save to remote storage - cannot find file: %s' % path) remote_path = path else: if not storage: storage = default_storage if storage == resources_storage: fkey = path.replace(RESOURCES_ROOT, '') else: fkey = path.replace(MEDIA_ROOT, '') # determine mime type fext = get_img_ext(path) content_type = MIME_TYPES.get(fext, UNKNOWN_MIME_TYPE) # write file to remote server file = storage.open(fkey, 'w') storage.headers.update({"Content-Type": content_type}) f = open(path, 'rb') media = File(f) for chunk in media.chunks(chunk_size=FILE_IO_CHUNK_SIZE): file.write(chunk) file.close() media.close() f.close() # construct remote url if storage == resources_storage: remote_path = '%s%s' % (RESOURCES_URL, fkey) else: remote_path = '%s%s' % (MEDIA_URL, fkey) logger().debug( 'save_to_remote_storage - local: %s / remote: %s / mime-type: %s' % (path, remote_path, content_type)) return remote_path
def test_existing_logger(self): """ logger should return existing loggng object if DebugLogger is not None. """ from garage.logger import logger from garage.logger import logger, DebugLogger self._msg("test", "logger", first=True) with patch("garage.logger.DebugLogger") as mock_logger: expected = "foobar" mock_logger.debug.return_value = expected result = logger().debug("this is a test message") self.assertEqual(result, expected) self._msg("result", result)
def copy_media_to_remote(path, verify=True): """ Verify local file path has remote version and copy to remote storage if remote does not exist. * if verify is True, function will skip copy if remote version exists. * NOTE: this is for files in the ``media`` directory. :param path: local file path :param verify: if True, verify and skip copy if remote exists :returns: remote server media url or None if error """ from helpers.files.utils import ( local_path_to_remote_media_url, remote_media_url_exists, save_to_remote_media_storage, ) try: assert local_file_exists(path) except AssertionError: url = None logger().debug( 'copy_media_to_remote - local file not found -' 'local: %s' % path) else: copy_to_remote = True if verify: url = local_path_to_remote_media_url(path) remote_exists = remote_media_url_exists(url) if remote_exists: copy_to_remote = False logger().debug( 'copy_media_to_remote - remote exists - ' 'local: %s / remote: %s' % (path, url)) if copy_to_remote: url = save_to_remote_media_storage(path) logger().debug( 'copy_media_to_remote - copied to remote - ' 'local: %s / remote: %s' % (path, url)) return url
def delete_images(entry, image_fields=None): """ Delete image associated with entry and all its thumbnails. * if image_fields is None, check entry for get_image_fields method. Example usage: ENTRY_IMAGES = ( 'image', 'thumbnail', 'thumbnail_small' ) delete_images(entry, ENTRY_IMAGES) * FIXME: add get_images method to model to fetch image paths directly instead of using field to fetch paths :param entry: object instance :param image_fields: list of field names for thumbnails :returns: number of errors encountered (0 is successful) """ from helpers.files.utils import delete_remote_media use_remote_storage = _s('USE_REMOTE_STORAGE', False) errors = 0 def _delete(url): e = 0 if use_remote_storage: if not is_local_path(url): ok = delete_remote_media(url) if not ok: e += 1 logger().debug('deleted remote image - %s %s' % (ok, url)) path = url_to_path(url) if os.path.isfile(path): os.remove(path) ok = os.path.isfile(path) == False if not ok: e += 1 logger().debug('deleted image - %s %s' % (ok, path)) return e if entry: if image_fields is None: if hasattr(entry, 'get_image_fields'): image_fields = entry.get_image_fields() if isinstance(image_fields, (list, tuple)): for img in image_fields: try: assert img url = getattr(entry, img) assert url except AssertionError: pass else: result = _delete(url) errors += result setattr(entry, img, None) logger().debug('delete_images - errors: %d' % errors) return errors
def _msg(self, msg): """ Dump debug message to log file. """ if self.debug: logger().debug(msg)
def handle_new_job(sender, **kwargs): site = kwargs.get('instance') logger().debug("POST_SAVE : site : %s" % site)