__init__.py 22 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32
# Copyright (C) 2012, 2013 GRNET S.A. All rights reserved.
#
# Redistribution and use in source and binary forms, with or
# without modification, are permitted provided that the following
# conditions are met:
#
#   1. Redistributions of source code must retain the above
#      copyright notice, this list of conditions and the following
#      disclaimer.
#
#   2. Redistributions in binary form must reproduce the above
#      copyright notice, this list of conditions and the following
#      disclaimer in the documentation and/or other materials
#      provided with the distribution.
#
# THIS SOFTWARE IS PROVIDED BY GRNET S.A. ``AS IS'' AND ANY EXPRESS
# OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GRNET S.A OR
# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
# USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
# AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
#
# The views and conclusions contained in the software and
# documentation are those of the authors and should not be
# interpreted as representing official policies, either expressed
# or implied, of GRNET S.A.
33 34 35

import logging
import urlparse
36
import urllib
37
import hashlib
38
from copy import copy
39 40

import simplejson
41 42
from astakosclient.utils import \
    retry, scheme_to_class, parse_request, check_input
43
from astakosclient.errors import \
44
    AstakosClientException, Unauthorized, BadRequest, NotFound, Forbidden, \
45
    NoUserName, NoUUID, BadValue, QuotaLimit, InvalidResponse
46 47 48 49 50
from .keypath import get_path
from .services import astakos_services


# Customize astakos_services here?
51 52


53 54 55 56
def join_urls(a, b):
    """join_urls from synnefo.lib"""
    return a.rstrip("/") + "/" + b.lstrip("/")

57 58
# --------------------------------------------------------------------
# Astakos API urls
59
UI_PREFIX = get_path(astakos_services, 'astakos_ui.prefix')
60
ACCOUNTS_PREFIX = get_path(astakos_services, 'astakos_account.prefix')
61
ACCOUNTS_PREFIX = join_urls(ACCOUNTS_PREFIX, 'v1.0')
62 63 64
API_AUTHENTICATE = join_urls(ACCOUNTS_PREFIX, "authenticate")
API_USERCATALOGS = join_urls(ACCOUNTS_PREFIX, "user_catalogs")
API_SERVICE_USERCATALOGS = join_urls(ACCOUNTS_PREFIX, "service/user_catalogs")
65
API_GETSERVICES = join_urls(UI_PREFIX, "get_services")
66 67 68 69 70 71 72 73 74
API_RESOURCES = join_urls(ACCOUNTS_PREFIX, "resources")
API_QUOTAS = join_urls(ACCOUNTS_PREFIX, "quotas")
API_SERVICE_QUOTAS = join_urls(ACCOUNTS_PREFIX, "service_quotas")
API_COMMISSIONS = join_urls(ACCOUNTS_PREFIX, "commissions")
API_COMMISSIONS_ACTION = join_urls(API_COMMISSIONS, "action")
API_FEEDBACK = join_urls(ACCOUNTS_PREFIX, "feedback")

# --------------------------------------------------------------------
# Astakos Keystone API urls
75
IDENTITY_PREFIX = get_path(astakos_services, 'astakos_identity.prefix')
76
IDENTITY_PREFIX = join_urls(IDENTITY_PREFIX, "v2.0")
77
API_TOKENS = join_urls(IDENTITY_PREFIX, "tokens")
78 79


80
# --------------------------------------------------------------------
Ilias Tsitsimpis's avatar
Ilias Tsitsimpis committed
81
# Astakos Client Class
82

83
def get_token_from_cookie(request, cookie_name):
84 85 86 87 88 89 90 91 92 93 94 95 96 97
    """Extract token from the cookie name provided

    Cookie should be in the same form as astakos
    service sets its cookie contents:
        <user_uniq>|<user_token>

    """
    try:
        cookie_content = urllib.unquote(request.COOKIE.get(cookie_name, None))
        return cookie_content.split("|")[1]
    except:
        return None


Ilias Tsitsimpis's avatar
Ilias Tsitsimpis committed
98 99 100 101
class AstakosClient():
    """AstakosClient Class Implementation"""

    # ----------------------------------
102 103
    def __init__(self, astakos_url, retry=0,
                 use_pool=False, pool_size=8, logger=None):
104
        """Initialize AstakosClient Class
Ilias Tsitsimpis's avatar
Ilias Tsitsimpis committed
105 106 107 108

        Keyword arguments:
        astakos_url -- i.e https://accounts.example.com (string)
        use_pool    -- use objpool for http requests (boolean)
109
        retry       -- how many time to retry (integer)
Ilias Tsitsimpis's avatar
Ilias Tsitsimpis committed
110 111 112 113
        logger      -- pass a different logger

        """
        if logger is None:
114 115 116 117
            logging.basicConfig(
                format='%(asctime)s [%(levelname)s] %(name)s %(message)s',
                datefmt='%Y-%m-%d %H:%M:%S',
                level=logging.INFO)
Ilias Tsitsimpis's avatar
Ilias Tsitsimpis committed
118
            logger = logging.getLogger("astakosclient")
119
        logger.debug("Intialize AstakosClient: astakos_url = %s, "
Ilias Tsitsimpis's avatar
Ilias Tsitsimpis committed
120 121
                     "use_pool = %s" % (astakos_url, use_pool))

122
        check_input("__init__", logger, astakos_url=astakos_url)
Ilias Tsitsimpis's avatar
Ilias Tsitsimpis committed
123 124 125

        # Check for supported scheme
        p = urlparse.urlparse(astakos_url)
126
        conn_class = scheme_to_class(p.scheme, use_pool, pool_size)
127
        if conn_class is None:
Ilias Tsitsimpis's avatar
Ilias Tsitsimpis committed
128 129
            m = "Unsupported scheme: %s" % p.scheme
            logger.error(m)
130
            raise BadValue(m)
Ilias Tsitsimpis's avatar
Ilias Tsitsimpis committed
131

Ilias Tsitsimpis's avatar
Ilias Tsitsimpis committed
132
        # Save astakos_url etc. in our class
133
        self.retry = retry
Ilias Tsitsimpis's avatar
Ilias Tsitsimpis committed
134 135 136
        self.logger = logger
        self.netloc = p.netloc
        self.scheme = p.scheme
137
        self.path = p.path.rstrip('/')
138
        self.conn_class = conn_class
Ilias Tsitsimpis's avatar
Ilias Tsitsimpis committed
139

140 141
    # ----------------------------------
    @retry
142 143
    def _call_astakos(self, token, request_path, headers=None,
                      body=None, method="GET", log_body=True):
Ilias Tsitsimpis's avatar
Ilias Tsitsimpis committed
144
        """Make the actual call to Astakos Service"""
145 146 147 148 149 150
        if token is not None:
            hashed_token = hashlib.sha1()
            hashed_token.update(token)
            using_token = "using token %s" % (hashed_token.hexdigest())
        else:
            using_token = "without using token"
Ilias Tsitsimpis's avatar
Ilias Tsitsimpis committed
151
        self.logger.debug(
152
            "Make a %s request to %s %s with headers %s and body %s"
153 154
            % (method, request_path, using_token, headers,
               body if log_body else "(not logged)"))
Ilias Tsitsimpis's avatar
Ilias Tsitsimpis committed
155

Ilias Tsitsimpis's avatar
Ilias Tsitsimpis committed
156
        # Check Input
157 158 159 160
        if headers is None:
            headers = {}
        if body is None:
            body = {}
161
        path = self.path + "/" + request_path.strip('/')
Ilias Tsitsimpis's avatar
Ilias Tsitsimpis committed
162

Ilias Tsitsimpis's avatar
Ilias Tsitsimpis committed
163 164
        # Build request's header and body
        kwargs = {}
165
        kwargs['headers'] = copy(headers)
166 167
        if token is not None:
            kwargs['headers']['X-Auth-Token'] = token
Ilias Tsitsimpis's avatar
Ilias Tsitsimpis committed
168
        if body:
169
            kwargs['body'] = copy(body)
Ilias Tsitsimpis's avatar
Ilias Tsitsimpis committed
170 171 172 173 174 175
            kwargs['headers'].setdefault(
                'content-type', 'application/octet-stream')
        kwargs['headers'].setdefault('content-length',
                                     len(body) if body else 0)

        try:
176 177 178
            # Get the connection object
            with self.conn_class(self.netloc) as conn:
                # Send request
179
                (message, data, status) = \
180
                    _do_request(conn, method, path, **kwargs)
Ilias Tsitsimpis's avatar
Ilias Tsitsimpis committed
181
        except Exception as err:
182
            self.logger.error("Failed to send request: %s" % repr(err))
Ilias Tsitsimpis's avatar
Ilias Tsitsimpis committed
183 184 185 186
            raise AstakosClientException(str(err))

        # Return
        self.logger.debug("Request returned with status %s" % status)
187
        if status == 400:
188
            raise BadRequest(message, data)
189
        elif status == 401:
190
            raise Unauthorized(message, data)
191
        elif status == 403:
192
            raise Forbidden(message, data)
193
        elif status == 404:
194
            raise NotFound(message, data)
195
        elif status < 200 or status >= 300:
196
            raise AstakosClientException(message, data, status)
197 198 199 200 201

        try:
            if data:
                return simplejson.loads(unicode(data))
            else:
202
                return None
203
        except Exception as err:
204 205
            self.logger.error("Cannot parse response \"%s\" with simplejson: %s"
                              % (data, str(err)))
206
            raise InvalidResponse(str(err), data)
Ilias Tsitsimpis's avatar
Ilias Tsitsimpis committed
207 208

    # ------------------------
209
    # do a GET to ``API_AUTHENTICATE``
210
    def get_user_info(self, token, usage=False):
211
        """Authenticate user and get user's info as a dictionary
Ilias Tsitsimpis's avatar
Ilias Tsitsimpis committed
212 213

        Keyword arguments:
Ilias Tsitsimpis's avatar
Ilias Tsitsimpis committed
214
        token   -- user's token (string)
Ilias Tsitsimpis's avatar
Ilias Tsitsimpis committed
215 216 217 218 219 220
        usage   -- return usage information for user (boolean)

        In case of success return user information (json parsed format).
        Otherwise raise an AstakosClientException.

        """
Ilias Tsitsimpis's avatar
Ilias Tsitsimpis committed
221
        # Send request
222
        auth_path = copy(API_AUTHENTICATE)
Ilias Tsitsimpis's avatar
Ilias Tsitsimpis committed
223 224
        if usage:
            auth_path += "?usage=1"
225
        return self._call_astakos(token, auth_path)
Ilias Tsitsimpis's avatar
Ilias Tsitsimpis committed
226 227

    # ----------------------------------
228
    # do a POST to ``API_USERCATALOGS`` (or ``API_SERVICE_USERCATALOGS``)
229
    #   with {'uuids': uuids}
230
    def _uuid_catalog(self, token, uuids, req_path):
231
        req_headers = {'content-type': 'application/json'}
232
        req_body = parse_request({'uuids': uuids}, self.logger)
233
        data = self._call_astakos(
234
            token, req_path, req_headers, req_body, "POST")
235 236 237
        if "uuid_catalog" in data:
            return data.get("uuid_catalog")
        else:
238
            m = "_uuid_catalog request returned %s. No uuid_catalog found" \
239 240 241
                % data
            self.logger.error(m)
            raise AstakosClientException(m)
242

243
    def get_usernames(self, token, uuids):
Ilias Tsitsimpis's avatar
Ilias Tsitsimpis committed
244 245 246
        """Return a uuid_catalog dictionary for the given uuids

        Keyword arguments:
Ilias Tsitsimpis's avatar
Ilias Tsitsimpis committed
247
        token   -- user's token (string)
Ilias Tsitsimpis's avatar
Ilias Tsitsimpis committed
248 249 250 251 252 253
        uuids   -- list of user ids (list of strings)

        The returned uuid_catalog is a dictionary with uuids as
        keys and the corresponding user names as values

        """
254
        req_path = copy(API_USERCATALOGS)
255
        return self._uuid_catalog(token, uuids, req_path)
Ilias Tsitsimpis's avatar
Ilias Tsitsimpis committed
256

257 258
    def get_username(self, token, uuid):
        """Return the user name of a uuid (see get_usernames)"""
259
        check_input("get_username", self.logger, uuid=uuid)
260
        uuid_dict = self.get_usernames(token, [uuid])
261 262 263
        if uuid in uuid_dict:
            return uuid_dict.get(uuid)
        else:
264
            raise NoUserName(uuid)
Ilias Tsitsimpis's avatar
Ilias Tsitsimpis committed
265

266
    def service_get_usernames(self, token, uuids):
267
        """Return a uuid_catalog dict using a service's token"""
268
        req_path = copy(API_SERVICE_USERCATALOGS)
269
        return self._uuid_catalog(token, uuids, req_path)
270

271
    def service_get_username(self, token, uuid):
272
        """Return the displayName of a uuid using a service's token"""
273
        check_input("service_get_username", self.logger, uuid=uuid)
274
        uuid_dict = self.service_get_usernames(token, [uuid])
275 276 277
        if uuid in uuid_dict:
            return uuid_dict.get(uuid)
        else:
278
            raise NoUserName(uuid)
279

280
    # ----------------------------------
281
    # do a POST to ``API_USERCATALOGS`` (or ``API_SERVICE_USERCATALOGS``)
282
    #   with {'displaynames': display_names}
283
    def _displayname_catalog(self, token, display_names, req_path):
284
        req_headers = {'content-type': 'application/json'}
285
        req_body = parse_request({'displaynames': display_names}, self.logger)
286
        data = self._call_astakos(
287
            token, req_path, req_headers, req_body, "POST")
288 289 290
        if "displayname_catalog" in data:
            return data.get("displayname_catalog")
        else:
291
            m = "_displayname_catalog request returned %s. " \
292 293 294
                "No displayname_catalog found" % data
            self.logger.error(m)
            raise AstakosClientException(m)
295

296
    def get_uuids(self, token, display_names):
297 298 299 300 301 302 303 304 305 306
        """Return a displayname_catalog for the given names

        Keyword arguments:
        token           -- user's token (string)
        display_names   -- list of user names (list of strings)

        The returned displayname_catalog is a dictionary with
        the names as keys and the corresponding uuids as values

        """
307
        req_path = copy(API_USERCATALOGS)
308
        return self._displayname_catalog(token, display_names, req_path)
309

310
    def get_uuid(self, token, display_name):
311
        """Return the uuid of a name (see getUUIDs)"""
312
        check_input("get_uuid", self.logger, display_name=display_name)
313
        name_dict = self.get_uuids(token, [display_name])
314 315 316 317
        if display_name in name_dict:
            return name_dict.get(display_name)
        else:
            raise NoUUID(display_name)
318

319
    def service_get_uuids(self, token, display_names):
320
        """Return a display_name catalog using a service's token"""
321
        req_path = copy(API_SERVICE_USERCATALOGS)
322
        return self._displayname_catalog(token, display_names, req_path)
323

324
    def service_get_uuid(self, token, display_name):
325
        """Return the uuid of a name using a service's token"""
326
        check_input("service_get_uuid", self.logger, display_name=display_name)
327
        name_dict = self.service_get_uuids(token, [display_name])
328 329 330 331
        if display_name in name_dict:
            return name_dict.get(display_name)
        else:
            raise NoUUID(display_name)
332

Ilias Tsitsimpis's avatar
Ilias Tsitsimpis committed
333
    # ----------------------------------
334
    # do a GET to ``API_GETSERVICES``
335
    def get_services(self):
Ilias Tsitsimpis's avatar
Ilias Tsitsimpis committed
336
        """Return a list of dicts with the registered services"""
337
        return self._call_astakos(None, copy(API_GETSERVICES))
338 339

    # ----------------------------------
340
    # do a GET to ``API_RESOURCES``
341 342
    def get_resources(self):
        """Return a dict of dicts with the available resources"""
343
        return self._call_astakos(None, copy(API_RESOURCES))
Ilias Tsitsimpis's avatar
Ilias Tsitsimpis committed
344

345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362
    # ----------------------------------
    # do a POST to ``API_FEEDBACK``
    def send_feedback(self, token, message, data):
        """Send feedback to astakos service

        keyword arguments:
        token       -- user's token (string)
        message     -- Feedback message
        data        -- Additional information about service client status

        In case of success return nothing.
        Otherwise raise an AstakosClientException

        """
        check_input("send_feedback", self.logger, message=message, data=data)
        path = copy(API_FEEDBACK)
        req_body = urllib.urlencode(
            {'feedback_msg': message, 'feedback_data': data})
363 364
        self._call_astakos(token, path, None, req_body, "POST")

365 366
    # ----------------------------------
    # do a POST to ``API_TOKENS``
367
    def get_endpoints(self, token, uuid=None):
368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387
        """ Fallback call for authenticate

        Keyword arguments:
        token   -- user's token (string)
        uuid    -- user's uniq id

        It returns back the token as well as information about the token
        holder and the services he/she can acess (in json format).
        In case of error raise an AstakosClientException.

        """
        req_path = copy(API_TOKENS)
        req_headers = {'content-type': 'application/json'}
        body = {'auth': {'token': {'id': token}}}
        if uuid is not None:
            body['auth']['tenantName'] = uuid
        req_body = parse_request(body, self.logger)
        return self._call_astakos(token, req_path, req_headers,
                                  req_body, "POST", False)

388
    # ----------------------------------
389
    # do a GET to ``API_QUOTAS``
390
    def get_quotas(self, token):
391 392 393 394 395 396 397 398 399
        """Get user's quotas

        Keyword arguments:
        token   -- user's token (string)

        In case of success return a dict of dicts with user's current quotas.
        Otherwise raise an AstakosClientException

        """
400
        return self._call_astakos(token, copy(API_QUOTAS))
401

402
    # ----------------------------------
403
    # do a GET to ``API_SERVICE_QUOTAS``
404
    def service_get_quotas(self, token, user=None):
405 406 407 408
        """Get all quotas for resources associated with the service

        Keyword arguments:
        token   -- service's token (string)
409
        user    -- optionally, the uuid of a specific user
410 411

        In case of success return a dict of dicts of dicts with current quotas
412
        for all users, or of a specified user, if user argument is set.
413 414 415
        Otherwise raise an AstakosClientException

        """
416
        query = copy(API_SERVICE_QUOTAS)
417 418 419
        if user is not None:
            query += "?user=" + user
        return self._call_astakos(token, query)
420

421
    # ----------------------------------
422
    # do a POST to ``API_COMMISSIONS``
423 424 425 426
    def issue_commission(self, token, request):
        """Issue a commission

        Keyword arguments:
427
        token   -- service's token (string)
428 429 430 431 432 433 434
        request -- commision request (dict)

        In case of success return commission's id (int).
        Otherwise raise an AstakosClientException.

        """
        req_headers = {'content-type': 'application/json'}
435
        req_body = parse_request(request, self.logger)
436
        try:
437
            response = self._call_astakos(token, copy(API_COMMISSIONS),
438 439 440 441 442 443 444 445 446 447 448 449 450 451 452
                                          req_headers, req_body, "POST")
        except AstakosClientException as err:
            if err.status == 413:
                raise QuotaLimit(err.message, err.details)
            else:
                raise

        if "serial" in response:
            return response['serial']
        else:
            m = "issue_commission_core request returned %s. No serial found" \
                % response
            self.logger.error(m)
            raise AstakosClientException(m)

453
    def issue_one_commission(self, token, holder, source, provisions,
454
                             name="", force=False, auto_accept=False):
455 456 457 458 459 460
        """Issue one commission (with specific holder and source)

        keyword arguments:
        token       -- service's token (string)
        holder      -- user's id (string)
        source      -- commission's source (ex system) (string)
461
        provisions  -- resources with their quantity (dict from string to int)
462
        name        -- description of the commission (string)
463 464 465 466 467 468 469 470
        force       -- force this commission (boolean)
        auto_accept -- auto accept this commission (boolean)

        In case of success return commission's id (int).
        Otherwise raise an AstakosClientException.
        (See also issue_commission)

        """
471 472 473
        check_input("issue_one_commission", self.logger,
                    holder=holder, source=source,
                    provisions=provisions)
474 475 476 477

        request = {}
        request["force"] = force
        request["auto_accept"] = auto_accept
478
        request["name"] = name
479 480
        try:
            request["provisions"] = []
481
            for resource, quantity in provisions.iteritems():
482 483 484 485 486 487 488 489 490
                t = {"holder": holder, "source": source,
                     "resource": resource, "quantity": quantity}
                request["provisions"].append(t)
        except Exception as err:
            self.logger.error(str(err))
            raise BadValue(str(err))

        return self.issue_commission(token, request)

491
    # ----------------------------------
492
    # do a GET to ``API_COMMISSIONS``
493 494 495 496
    def get_pending_commissions(self, token):
        """Get Pending Commissions

        Keyword arguments:
497
        token   -- service's token (string)
498 499 500 501 502

        In case of success return a list of pending commissions' ids
        (list of integers)

        """
503
        return self._call_astakos(token, copy(API_COMMISSIONS))
504

505
    # ----------------------------------
506
    # do a GET to ``API_COMMISSIONS``/<serial>
507 508 509 510
    def get_commission_info(self, token, serial):
        """Get Description of a Commission

        Keyword arguments:
511
        token   -- service's token (string)
512 513 514
        serial  -- commission's id (int)

        In case of success return a dict of dicts containing
515
        informations (details) about the requested commission
516 517

        """
518
        check_input("get_commission_info", self.logger, serial=serial)
519

520
        path = API_COMMISSIONS + "/" + str(serial)
521 522
        return self._call_astakos(token, path)

523
    # ----------------------------------
524
    # do a POST to ``API_COMMISSIONS``/<serial>/action"
525 526
    def commission_action(self, token, serial, action):
        """Perform a commission action
527 528

        Keyword arguments:
529
        token   -- service's token (string)
530 531 532 533 534 535
        serial  -- commission's id (int)
        action  -- action to perform, currently accept/reject (string)

        In case of success return nothing.

        """
536 537
        check_input("commission_action", self.logger,
                    serial=serial, action=action)
538

539
        path = API_COMMISSIONS + "/" + str(serial) + "/action"
540
        req_headers = {'content-type': 'application/json'}
541
        req_body = parse_request({str(action): ""}, self.logger)
542 543
        self._call_astakos(token, path, req_headers, req_body, "POST")

544 545 546
    def accept_commission(self, token, serial):
        """Accept a commission (see commission_action)"""
        self.commission_action(token, serial, "accept")
547

548 549 550
    def reject_commission(self, token, serial):
        """Reject a commission (see commission_action)"""
        self.commission_action(token, serial, "reject")
551

552
    # ----------------------------------
553
    # do a POST to ``API_COMMISSIONS_ACTION``
554 555 556 557 558 559 560 561 562 563 564 565 566
    def resolve_commissions(self, token, accept_serials, reject_serials):
        """Resolve multiple commissions at once

        Keyword arguments:
        token           -- service's token (string)
        accept_serials  -- commissions to accept (list of ints)
        reject_serials  -- commissions to reject (list of ints)

        In case of success return a dict of dicts describing which
        commissions accepted, which rejected and which failed to
        resolved.

        """
567 568 569
        check_input("resolve_commissions", self.logger,
                    accept_serials=accept_serials,
                    reject_serials=reject_serials)
570

571
        path = copy(API_COMMISSIONS_ACTION)
572 573 574 575 576 577
        req_headers = {'content-type': 'application/json'}
        req_body = parse_request({"accept": accept_serials,
                                  "reject": reject_serials},
                                 self.logger)
        return self._call_astakos(token, path, req_headers, req_body, "POST")

578

579 580
# --------------------------------------------------------------------
# Private functions
581 582
# We want _doRequest to be a distinct function
# so that we can replace it during unit tests.
583
def _do_request(conn, method, url, **kwargs):
584 585 586 587 588 589
    """The actual request. This function can easily be mocked"""
    conn.request(method, url, **kwargs)
    response = conn.getresponse()
    length = response.getheader('content-length', None)
    data = response.read(length)
    status = int(response.status)
590 591
    message = response.reason
    return (message, data, status)