Hot-keys on this page

r m x p   toggle line displays

j k   next/prev highlighted chunk

0   (zero) top of page

1   (one) first highlighted chunk

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

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

# Copyright 2013 Red Hat, Inc. 

# All Rights Reserved. 

# 

#    Licensed under the Apache License, Version 2.0 (the "License"); you may 

#    not use this file except in compliance with the License. You may obtain 

#    a copy of the License at 

# 

#         http://www.apache.org/licenses/LICENSE-2.0 

# 

#    Unless required by applicable law or agreed to in writing, software 

#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT 

#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the 

#    License for the specific language governing permissions and limitations 

#    under the License. 

 

import jsonpatch 

from oslo_config import cfg 

import pecan 

import wsme 

 

from magnum.common import exception 

from magnum.common import utils 

from magnum import objects 

from magnum.openstack.common._i18n import _ 

 

CONF = cfg.CONF 

 

 

JSONPATCH_EXCEPTIONS = (jsonpatch.JsonPatchException, 

                        jsonpatch.JsonPointerException, 

                        KeyError) 

 

 

def validate_limit(limit): 

    if limit is not None and limit <= 0: 

        raise wsme.exc.ClientSideError(_("Limit must be positive")) 

 

    return min(CONF.api.max_limit, limit) or CONF.api.max_limit 

 

 

def validate_sort_dir(sort_dir): 

    if sort_dir not in ['asc', 'desc']: 

        raise wsme.exc.ClientSideError(_("Invalid sort direction: %s. " 

                                         "Acceptable values are " 

                                         "'asc' or 'desc'") % sort_dir) 

    return sort_dir 

 

 

def apply_jsonpatch(doc, patch): 

    for p in patch: 

        if p['op'] == 'add' and p['path'].count('/') == 1: 

            if p['path'].lstrip('/') not in doc: 

                msg = _('Adding a new attribute (%s) to the root of ' 

                        ' the resource is not allowed') 

                raise wsme.exc.ClientSideError(msg % p['path']) 

    return jsonpatch.apply_patch(doc, jsonpatch.JsonPatch(patch)) 

 

 

def get_rpc_resource(resource, resource_ident): 

    """Get the RPC resource from the uuid or logical name. 

 

    :param resource: the resource type. 

    :param resource_ident: the UUID or logical name of the resource. 

 

    :returns: The RPC resource. 

    :raises: InvalidUuidOrName if the name or uuid provided is not valid. 

    """ 

    resource = getattr(objects, resource) 

 

    if utils.is_uuid_like(resource_ident): 

        return resource.get_by_uuid(pecan.request.context, resource_ident) 

 

76    if utils.allow_logical_names(): 

        return resource.get_by_name(pecan.request.context, resource_ident) 

 

    raise exception.InvalidUuidOrName(name=resource_ident) 

 

 

def get_openstack_resource(manager, resource_ident, resource_type): 

    """Get the openstack resource from the uuid or logical name. 

 

    :param manager: the resource manager class. 

    :param resource_ident: the UUID or logical name of the resource. 

    :param resource_type: the type of the resource 

 

    :returns: The openstack resource. 

    :raises: ResourceNotFound if the openstack resource is not exist. 

             Conflict if multi openstack resources have same name. 

    """ 

    if utils.is_uuid_like(resource_ident): 

        resource_data = manager.get(resource_ident) 

    else: 

        filters = {'name': resource_ident} 

        matches = list(manager.list(filters=filters)) 

        if len(matches) == 0: 

            raise exception.ResourceNotFound(name=resource_type, 

                                             id=resource_ident) 

        if len(matches) > 1: 

            msg = ("Multiple '%s' exist with same name '%s'. " 

                   "Please use the resource id instead." % 

                   (resource_type, resource_ident)) 

            raise exception.Conflict(msg) 

        resource_data = matches[0] 

    return resource_data