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

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

# 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. 

 

""" 

Version 1 of the Magnum API 

 

NOTE: IN PROGRESS AND NOT FULLY IMPLEMENTED. 

""" 

 

import datetime 

 

import pecan 

from pecan import rest 

import wsme 

from wsme import types as wtypes 

import wsmeext.pecan as wsme_pecan 

 

from magnum.api.controllers import link 

from magnum.api.controllers.v1 import bay 

from magnum.api.controllers.v1 import baymodel 

from magnum.api.controllers.v1 import container 

from magnum.api.controllers.v1 import node 

from magnum.api.controllers.v1 import pod 

from magnum.api.controllers.v1 import replicationcontroller as rc 

from magnum.api.controllers.v1 import service 

 

 

class APIBase(wtypes.Base): 

 

    created_at = wsme.wsattr(datetime.datetime, readonly=True) 

    """The time in UTC at which the object is created""" 

 

    updated_at = wsme.wsattr(datetime.datetime, readonly=True) 

    """The time in UTC at which the object is updated""" 

 

    def as_dict(self): 

        """Render this object as a dict of its fields.""" 

        return dict((k, getattr(self, k)) 

                    for k in self.fields 

                    if hasattr(self, k) and 

                    getattr(self, k) != wsme.Unset) 

 

    def unset_fields_except(self, except_list=None): 

        """Unset fields so they don't appear in the message body. 

 

        :param except_list: A list of fields that won't be touched. 

 

        """ 

        if except_list is None: 

            except_list = [] 

 

        for k in self.as_dict(): 

            if k not in except_list: 

                setattr(self, k, wsme.Unset) 

 

 

class MediaType(APIBase): 

    """A media type representation.""" 

 

    base = wtypes.text 

    type = wtypes.text 

 

    def __init__(self, base, type): 

        self.base = base 

        self.type = type 

 

 

class V1(APIBase): 

    """The representation of the version 1 of the API.""" 

 

    id = wtypes.text 

    """The ID of the version, also acts as the release number""" 

 

    media_types = [MediaType] 

    """An array of supcontainersed media types for this version""" 

 

    links = [link.Link] 

    """Links that point to a specific URL for this version and documentation""" 

 

    pods = [link.Link] 

    """Links to the pods resource""" 

 

    rcs = [link.Link] 

    """Links to the rcs resource""" 

 

    baymodels = [link.Link] 

    """Links to the baymodels resource""" 

 

    bays = [link.Link] 

    """Links to the bays resource""" 

 

    containers = [link.Link] 

    """Links to the containers resource""" 

 

    services = [link.Link] 

    """Links to the services resource""" 

 

    @staticmethod 

    def convert(): 

        v1 = V1() 

        v1.id = "v1" 

        v1.links = [link.Link.make_link('self', pecan.request.host_url, 

                                        'v1', '', bookmark=True), 

                    link.Link.make_link('describedby', 

                                        'http://docs.openstack.org', 

                                        'developer/magnum/dev', 

                                        'api-spec-v1.html', 

                                        bookmark=True, type='text/html') 

                   ] 

        v1.media_types = [MediaType('application/json', 

                          'application/vnd.openstack.magnum.v1+json')] 

        v1.pods = [link.Link.make_link('self', pecan.request.host_url, 

                                          'pods', ''), 

                      link.Link.make_link('bookmark', 

                                           pecan.request.host_url, 

                                           'pods', '', 

                                           bookmark=True) 

                     ] 

        v1.rcs = [link.Link.make_link('self', pecan.request.host_url, 

                                      'rcs', ''), 

                      link.Link.make_link('bookmark', 

                                           pecan.request.host_url, 

                                           'rcs', '', 

                                           bookmark=True) 

                     ] 

        v1.baymodels = [link.Link.make_link('self', pecan.request.host_url, 

                                        'baymodels', ''), 

                    link.Link.make_link('bookmark', 

                                        pecan.request.host_url, 

                                        'bays', '', 

                                        bookmark=True) 

                   ] 

        v1.bays = [link.Link.make_link('self', pecan.request.host_url, 

                                        'bays', ''), 

                    link.Link.make_link('bookmark', 

                                        pecan.request.host_url, 

                                        'bays', '', 

                                        bookmark=True) 

                   ] 

        v1.containers = [link.Link.make_link('self', pecan.request.host_url, 

                                        'containers', ''), 

                    link.Link.make_link('bookmark', 

                                        pecan.request.host_url, 

                                        'containers', '', 

                                        bookmark=True) 

                   ] 

        v1.services = [link.Link.make_link('self', pecan.request.host_url, 

                                          'services', ''), 

                      link.Link.make_link('bookmark', 

                                          pecan.request.host_url, 

                                          'services', '', 

                                          bookmark=True) 

                     ] 

        return v1 

 

 

class Controller(rest.RestController): 

    """Version 1 API controller root.""" 

 

    bays = bay.BaysController() 

    baymodels = baymodel.BayModelsController() 

    containers = container.ContainersController() 

    nodes = node.NodesController() 

    pods = pod.PodsController() 

    rcs = rc.ReplicationControllersController() 

    services = service.ServicesController() 

 

    @wsme_pecan.wsexpose(V1) 

    def get(self): 

        # NOTE: The reason why convert() it's being called for every 

        #       request is because we need to get the host url from 

        #       the request object to make the links. 

        return V1.convert() 

 

__all__ = (Controller)