Revision 9986e569
| b/kamaki/cli/__init__.py | ||
|---|---|---|
| 40 | 40 |
from kamaki.cli.history import History |
| 41 | 41 |
from kamaki.cli.utils import print_dict, red, magenta, yellow |
| 42 | 42 |
from kamaki.cli.errors import CLIError |
| 43 |
from kamaki.logger import add_stream_logger, get_logger |
|
| 43 | 44 |
|
| 44 | 45 |
_help = False |
| 45 | 46 |
_debug = False |
| ... | ... | |
| 168 | 169 |
def _setup_logging(silent=False, debug=False, verbose=False, include=False): |
| 169 | 170 |
"""handle logging for clients package""" |
| 170 | 171 |
|
| 171 |
def add_handler(name, level, prefix=''): |
|
| 172 |
h = logging.StreamHandler() |
|
| 173 |
fmt = logging.Formatter(prefix + '%(message)s') |
|
| 174 |
h.setFormatter(fmt) |
|
| 175 |
logger = logging.getLogger(name) |
|
| 176 |
logger.addHandler(h) |
|
| 177 |
logger.setLevel(level) |
|
| 178 |
|
|
| 179 | 172 |
if silent: |
| 180 |
add_handler('', logging.CRITICAL)
|
|
| 173 |
add_stream_logger(__name__, logging.CRITICAL)
|
|
| 181 | 174 |
return |
| 182 | 175 |
|
| 183 | 176 |
if debug: |
| 184 |
add_handler('requests', logging.INFO, prefix='* ')
|
|
| 185 |
add_handler('clients.send', logging.DEBUG, prefix='> ')
|
|
| 186 |
add_handler('clients.recv', logging.DEBUG, prefix='< ')
|
|
| 187 |
add_handler('kamaki', logging.DEBUG, prefix='(debug): ')
|
|
| 177 |
add_stream_logger('kamaki.clients.send', logging.DEBUG)
|
|
| 178 |
add_stream_logger('kamaki.clients.recv', logging.DEBUG)
|
|
| 179 |
add_stream_logger(__name__, logging.DEBUG) |
|
| 188 | 180 |
elif verbose: |
| 189 |
add_handler('requests', logging.INFO, prefix='* ')
|
|
| 190 |
add_handler('clients.send', logging.INFO, prefix='> ')
|
|
| 191 |
add_handler('clients.recv', logging.INFO, prefix='< ')
|
|
| 192 |
add_handler('kamaki', logging.INFO, prefix='(i): ')
|
|
| 181 |
add_stream_logger('kamaki.clients.send', logging.INFO)
|
|
| 182 |
add_stream_logger('kamaki.clients.recv', logging.INFO)
|
|
| 183 |
add_stream_logger(__name__, logging.INFO) |
|
| 193 | 184 |
if include: |
| 194 |
add_handler('data.send', logging.INFO, prefix='>[data]: ')
|
|
| 195 |
add_handler('data.recv', logging.INFO, prefix='<[data]: ')
|
|
| 196 |
add_handler('kamaki', logging.WARNING, prefix='(warning): ')
|
|
| 185 |
add_stream_logger('kamaki.clients.send', logging.INFO)
|
|
| 186 |
add_stream_logger('kamaki.clients.recv', logging.INFO)
|
|
| 187 |
add_stream_logger(__name__, logging.WARNING)
|
|
| 197 | 188 |
global kloger |
| 198 |
kloger = logging.getLogger('kamaki')
|
|
| 189 |
kloger = get_logger(__name__)
|
|
| 199 | 190 |
|
| 200 | 191 |
|
| 201 | 192 |
def _init_session(arguments): |
| b/kamaki/cli/argument.py | ||
|---|---|---|
| 34 | 34 |
from kamaki.cli.config import Config |
| 35 | 35 |
from kamaki.cli.errors import CLISyntaxError, raiseCLIError |
| 36 | 36 |
from kamaki.cli.utils import split_input |
| 37 |
from logging import getLogger
|
|
| 37 |
from kamaki.logger import get_logger
|
|
| 38 | 38 |
from datetime import datetime as dtm |
| 39 | 39 |
from time import mktime |
| 40 | 40 |
|
| ... | ... | |
| 52 | 52 |
# progress not installed - pls, pip install progress |
| 53 | 53 |
pass |
| 54 | 54 |
|
| 55 |
kloger = getLogger('kamaki')
|
|
| 55 |
log = get_logger('kamaki.cli')
|
|
| 56 | 56 |
|
| 57 | 57 |
|
| 58 | 58 |
class Argument(object): |
| ... | ... | |
| 354 | 354 |
try: |
| 355 | 355 |
KamakiProgressBar |
| 356 | 356 |
except NameError: |
| 357 |
kloger.debug('WARNING: no progress bar functionality')
|
|
| 357 |
log.debug('WARNING: no progress bar functionality')
|
|
| 358 | 358 |
|
| 359 | 359 |
def clone(self): |
| 360 | 360 |
"""Get a modifiable copy of this bar""" |
| b/kamaki/cli/commands/__init__.py | ||
|---|---|---|
| 31 | 31 |
# interpreted as representing official policies, either expressed |
| 32 | 32 |
# or implied, of GRNET S.A.command |
| 33 | 33 |
|
| 34 |
from kamaki import logger
|
|
| 34 |
from kamaki.logger import get_logger
|
|
| 35 | 35 |
|
| 36 |
logger.add_file_logger('cli', __name__, filename=logger.get_log_filename())
|
|
| 37 |
sendlog = logger.get_logger('cli')
|
|
| 36 |
log = get_logger('kamaki.cli')
|
|
| 38 | 37 |
|
| 39 | 38 |
|
| 40 | 39 |
class _command_init(object): |
| ... | ... | |
| 55 | 54 |
self['config'].get('global', 'log_token') == 'on',
|
| 56 | 55 |
self['config'].get('global', 'log_data') == 'on')
|
| 57 | 56 |
except Exception as e: |
| 58 |
sendlog.warning('Failed to read custom log settings: %s' % e)
|
|
| 59 |
sendlog.warning('\tdefaults for token and data logging are off')
|
|
| 57 |
log.warning('Failed to read custom log settings: %s' % e)
|
|
| 58 |
log.warning('\tdefaults for token and data logging are off')
|
|
| 60 | 59 |
pass |
| 61 | 60 |
|
| 62 | 61 |
def _update_max_threads(self): |
| ... | ... | |
| 65 | 64 |
assert max_threads > 0 |
| 66 | 65 |
self.client.MAX_THREADS = max_threads |
| 67 | 66 |
except Exception as e: |
| 68 |
sendlog.warning('Failed to read custom thread settings: %s' % e)
|
|
| 69 |
sendlog.warning(
|
|
| 67 |
log.warning('Failed to read custom thread settings: %s' % e)
|
|
| 68 |
log.warning( |
|
| 70 | 69 |
'\tdefault for max threads is %s' % self.client.MAX_THREADS) |
| 71 | 70 |
pass |
| 72 | 71 |
|
| b/kamaki/cli/commands/errors.py | ||
|---|---|---|
| 32 | 32 |
# or implied, of GRNET S.A.command |
| 33 | 33 |
|
| 34 | 34 |
from traceback import print_stack, print_exc |
| 35 |
import logging |
|
| 36 | 35 |
|
| 37 | 36 |
from kamaki.clients import ClientError |
| 38 | 37 |
from kamaki.cli.errors import CLIError, raiseCLIError, CLISyntaxError |
| 39 | 38 |
from kamaki.cli import _debug, kloger |
| 40 | 39 |
from kamaki.cli.utils import format_size |
| 41 | 40 |
|
| 42 |
sendlog = logging.getLogger('clients.send')
|
|
| 43 |
datasendlog = logging.getLogger('data.send')
|
|
| 44 |
recvlog = logging.getLogger('clients.recv')
|
|
| 45 |
datarecvlog = logging.getLogger('data.recv')
|
|
| 46 |
|
|
| 47 | 41 |
|
| 48 | 42 |
class generic(object): |
| 49 | 43 |
|
| b/kamaki/cli/commands/pithos.py | ||
|---|---|---|
| 33 | 33 |
|
| 34 | 34 |
from sys import stdout |
| 35 | 35 |
from time import localtime, strftime |
| 36 |
from logging import getLogger |
|
| 37 | 36 |
from os import path, makedirs, walk |
| 38 | 37 |
|
| 39 | 38 |
from kamaki.cli import command |
| ... | ... | |
| 49 | 48 |
from kamaki.clients.pithos import PithosClient, ClientError |
| 50 | 49 |
from kamaki.clients.astakos import AstakosClient |
| 51 | 50 |
|
| 52 |
|
|
| 53 |
kloger = getLogger('kamaki')
|
|
| 54 |
|
|
| 55 | 51 |
pithos_cmds = CommandTree('file', 'Pithos+/Storage API commands')
|
| 56 | 52 |
_commands = [pithos_cmds] |
| 57 | 53 |
|
| b/kamaki/cli/errors.py | ||
|---|---|---|
| 31 | 31 |
# interpreted as representing official policies, either expressed |
| 32 | 32 |
# or implied, of GRNET S.A. |
| 33 | 33 |
|
| 34 |
import logging
|
|
| 34 |
from kamaki.logger import get_logger
|
|
| 35 | 35 |
|
| 36 |
sendlog = logging.getLogger('clients.send')
|
|
| 37 |
recvlog = logging.getLogger('clients.recv')
|
|
| 36 |
log = get_logger('kamaki.cli')
|
|
| 38 | 37 |
|
| 39 | 38 |
|
| 40 | 39 |
class CLIError(Exception): |
| ... | ... | |
| 101 | 100 |
try: |
| 102 | 101 |
stack = [e for e in stack if e != stack[1]] |
| 103 | 102 |
except KeyError: |
| 104 |
recvlog.debug('\n < '.join(stack))
|
|
| 103 |
log.debug('\n < '.join(stack))
|
|
| 105 | 104 |
|
| 106 | 105 |
details = ['%s' % details] if not isinstance(details, list)\ |
| 107 | 106 |
else list(details) |
| b/kamaki/cli/one_command.py | ||
|---|---|---|
| 31 | 31 |
# interpreted as representing official policies, either expressed |
| 32 | 32 |
# or implied, of GRNET S.A.command |
| 33 | 33 |
|
| 34 |
from logging import getLogger
|
|
| 34 |
from kamaki.logger import get_logger
|
|
| 35 | 35 |
|
| 36 | 36 |
from kamaki.cli import get_command_group, set_command_params |
| 37 | 37 |
from kamaki.cli import print_subcommands_help, exec_cmd, update_parser_help |
| 38 | 38 |
from kamaki.cli import _groups_help, _load_spec_module |
| 39 | 39 |
|
| 40 | 40 |
|
| 41 |
kloger = getLogger('kamaki')
|
|
| 41 |
kloger = get_logger('kamaki.cli')
|
|
| 42 | 42 |
|
| 43 | 43 |
|
| 44 | 44 |
def _get_cmd_tree_from_spec(spec, cmd_tree_list): |
| b/kamaki/clients/__init__.py | ||
|---|---|---|
| 42 | 42 |
|
| 43 | 43 |
from objpool.http import PooledHTTPConnection |
| 44 | 44 |
|
| 45 |
from kamaki import logger
|
|
| 45 |
from kamaki.logger import add_file_logger, get_log_filename
|
|
| 46 | 46 |
|
| 47 | 47 |
TIMEOUT = 60.0 # seconds |
| 48 | 48 |
HTTP_METHODS = ['GET', 'POST', 'PUT', 'HEAD', 'DELETE', 'COPY', 'MOVE'] |
| 49 | 49 |
|
| 50 |
log = logger.add_file_logger(__name__)
|
|
| 51 |
log.debug('Logging location: %s' % logger.get_log_filename())
|
|
| 52 |
sendlog = logger.add_file_logger('%s.send' % __name__)
|
|
| 53 |
recvlog = logger.add_file_logger('%s.recv' % __name__)
|
|
| 50 |
log = add_file_logger(__name__) |
|
| 51 |
log.debug('Logging location: %s' % get_log_filename())
|
|
| 52 |
sendlog = add_file_logger('%s.send' % __name__)
|
|
| 53 |
recvlog = add_file_logger('%s.recv' % __name__)
|
|
| 54 | 54 |
|
| 55 | 55 |
|
| 56 | 56 |
def _encode(v): |
| b/kamaki/logger.py | ||
|---|---|---|
| 57 | 57 |
|
| 58 | 58 |
|
| 59 | 59 |
def _add_logger(name, level=None, filename=None, fmt=None): |
| 60 |
log = logging.getLogger(name)
|
|
| 60 |
log = get_logger(name)
|
|
| 61 | 61 |
h = logging.FileHandler(filename) if ( |
| 62 |
filename) else logging.StreamHandler(filename) |
|
| 63 |
h.setFormatter(logging.Formatter(fmt or '%(name)s %(message)s')) |
|
| 62 |
filename) else logging.StreamHandler() |
|
| 63 |
lfmt = logging.Formatter(fmt or '%(name)s\n %(message)s') |
|
| 64 |
h.setFormatter(lfmt) |
|
| 64 | 65 |
log.addHandler(h) |
| 65 | 66 |
log.setLevel(level or logging.DEBUG) |
| 66 | 67 |
return get_logger(name) |
| ... | ... | |
| 77 | 78 |
|
| 78 | 79 |
def add_stream_logger(name, level=None): |
| 79 | 80 |
try: |
| 80 |
return _add_logger(name, level, fmt='%(name)s\n\t%(message)s')
|
|
| 81 |
return _add_logger(name, level) |
|
| 81 | 82 |
except Exception: |
| 82 | 83 |
return get_logger(name) |
| 83 | 84 |
|
Also available in: Unified diff