Synnefo » ./kamaki

        except KeyError:

            pass

    def _safe_progress_bar(self, msg, arg='progress_bar'):

        """Try to get a progress bar, but do not raise errors"""

        try:

        base_url = self.config.get('astakos', 'url')\

            or self.config.get('global', 'url')

        self.client = AstakosClient(base_url=base_url, token=token)

    def main(self):

@command(astakos_cmds)

        base_url = self.config.get(service, 'url')\

            or self.config.get('global', 'url')

        self.client = CycladesClient(base_url=base_url, token=token)

    def main(self):

        self._run()

            or self.config.get('compute', 'url')\

            or self.config.get('global', 'url')

        self.client = ImageClient(base_url=base_url, token=token)

    def main(self):

        self._run()

            token=self.token,

            account=self.account,

            container=self.container)

    def main(self):

        self._run()

DEBUG_LOG = logger.get_log_filename()

TIMEOUT = 60.0   # seconds

HTTP_METHODS = ['GET', 'POST', 'PUT', 'HEAD', 'DELETE', 'COPY', 'MOVE']

logger.add_file_logger('clients.send', __name__, filename=DEBUG_LOG)

sendlog = logger.get_logger('clients.send')

            self.details = details if details else []

    """Handle http request information"""

    def _connection_info(self, url, path, params={}):

        self.scheme, self.netloc = self._connection_info(url, path, params)

    def log(self):

            self.method,

            self.scheme,

            self.netloc,

            self.path,

            self))

        for key, val in self.headers.items():

                continue

        if self.data:

                datasendlog.info(self.data)

        else:

        sendlog.info('')

    def perform(self, conn):

        raise ClientError('HTTPResponse takes too long - kamaki timeout')

    """Manage the http request and handle the response data, headers, etc."""

    def __init__(self, request, poolsize=None):

            with PooledHTTPConnection(

                    self.request.netloc, self.request.scheme,

                    **pool_kw) as connection:

                r = self.request.perform(connection)

                self._request_performed = True

                self._status_code, self._status = r.status, r.reason

                    '%d %s\t[p: %s]' % (self.status_code, self.status, self))

                self._headers = dict()

                for k, v in r.getheaders():

                        continue

                    self._headers[k] = v

                self._content = r.read()

                    len(self._content) if self._content else 0,

                    self))

        except Exception as err:

            from traceback import format_stack

            recvlog.debug('\n'.join(['%s' % type(err)] + format_stack()))

        '%a %b %d %H:%M:%S %Y',

        '%A, %d-%b-%y %H:%M:%S GMT',

        '%a, %d %b %Y %H:%M:%S GMT']

    def __init__(self, base_url, token):

        self.base_url = base_url

                data=data, headers=headers, params=params)

            #  req.log()

            r = ResponseManager(req)

        finally:

            self.headers = dict()

            self.params = dict()