Synnefo

    d = defaultdict(dict)

    if not public_mode:

        uuid = None

        try:

        r = client.post(url, "not json", content_type='application/json')

        self.assertEqual(r.status_code, 400)

        body = json.loads(r.content)

        # Check auth with token

        post_data = """{"auth":{"token": {"id":"%s"},

    images = True

    backend = None

    if request.body:

        req_stats = utils.get_attribute(req, "stats", required=True,

                                        attr_type=dict)

        # Check backend

                serializations=["json"])

def floating_ip_action_demux(request, floating_ip_id):

    userid = request.user_uniq

    log.debug('floating_ip_action %s %s', floating_ip_id, req)

    if len(req) != 1:

        raise faults.BadRequest('Malformed request.')

@transaction.commit_on_success

def allocate_floating_ip(request):

    """Allocate a floating IP."""

    floating_ip_dict = api.utils.get_attribute(req, "floatingip",

                                               required=True, attr_type=dict)

    log.info('allocate_floating_ip %s', req)

    #userid = request.user_uniq

    #log.info("update_floating_ip '%s'. User '%s'.", floating_ip_id, userid)

    #info = api.utils.get_attribute(req, "floatingip", required=True)

    #device_id = api.utils.get_attribute(info, "device_id", required=False)

    #                       badMediaType(415),

    #                       overLimit (413)

    log.info('update_image_metadata %s %s', image_id, req)

    with image_backend(request.user_uniq) as backend:

        image = backend.get_image(image_id)

    #                       badMediaType(415),

    #                       overLimit (413)

    log.info('create_image_metadata_item %s %s %s', image_id, key, req)

    try:

        metadict = req['meta']

@api.api_method(http_method='POST', user_required=True, logger=log)

def network_action_demux(request, network_id):

    network = util.get_network(network_id, request.user_uniq, for_update=True)

    action = req.keys()[0]

    try:

@api.api_method(http_method='POST', user_required=True, logger=log)

def create_network(request):

    userid = request.user_uniq

    log.info('create_network %s', req)

    network_dict = api.utils.get_attribute(req, "network",

@api.api_method(http_method='PUT', user_required=True, logger=log)

def update_network(request, network_id):

    network = api.utils.get_attribute(info, "network", attr_type=dict,

                                      required=True)

@transaction.commit_on_success

def create_port(request):

    user_id = request.user_uniq

    log.info('create_port %s', req)

    port_dict = api.utils.get_attribute(req, "port", attr_type=dict)

    You can update only name, security_groups

    '''

    port = util.get_port(port_id, request.user_uniq, for_update=True)

    port_info = api.utils.get_attribute(req, "port", required=True,

                                        attr_type=dict)

    #                       badRequest (400),

    #                       serverCapacityUnavailable (503),

    #                       overLimit (413)

    log.info('create_server %s', req)

    user_id = request.user_uniq

    #                       buildInProgress (409),

    #                       overLimit (413)

    log.info('update_server_name %s %s', server_id, req)

    req = utils.get_attribute(req, "server", attr_type=dict, required=True)

@api.api_method(http_method='POST', user_required=True, logger=log)

@transaction.commit_on_success

def demux_server_action(request, server_id):

    log.debug('server_action %s %s', server_id, req)

    if not isinstance(req, dict) and len(req) != 1:

    #                       badMediaType(415),

    #                       overLimit (413)

    log.info('update_server_metadata %s %s', server_id, req)

    vm = util.get_vm(server_id, request.user_uniq, non_suspended=True)

    metadata = utils.get_attribute(req, "metadata", required=True,

    #                       badMediaType(415),

    #                       overLimit (413)

    log.info('create_server_metadata_item %s %s %s', server_id, key, req)

    vm = util.get_vm(server_id, request.user_uniq, non_suspended=True)

    try:

    network_id and the desired cidr are mandatory, everything else is optional

    """

    log.info('create subnet %s', dictionary)

    try:

    """

    user_id = request.user_uniq

    try:

    """

    log.debug('update_image_members %s', image_id)

    members = []

    with image_backend(request.user_uniq) as backend:

        backend.replace_users(image_id, members)

    return utc_since

    """

    data = request.body

    if content_type.startswith("application/json"):

        try:

            return json.loads(data)

        except ValueError:

    else:

        raise faults.BadRequest("Unsupported Content-type: '%s'" %

                                content_type)