Coverage for osmclient/sol005/sdncontroller.py: 18%

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

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

7# a copy of the License at

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

10#

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

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

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

14# License for the specific language governing permissions and limitations

15# under the License.

17"""

18OSM SDN controller API handling

19"""

21from osmclient.common import utils

22from osmclient.common import wait as WaitForStatus

23from osmclient.common.exceptions import ClientException

24from osmclient.common.exceptions import NotFound

25import json

26import logging

27import yaml

30class SdnController(object):

31 def __init__(self, http=None, client=None):

32 self._http = http

33 self._client = client

34 self._logger = logging.getLogger("osmclient")

35 self._apiName = "/admin"

36 self._apiVersion = "/v1"

37 self._apiResource = "/sdns"

38 self._apiBase = "{}{}{}".format(

39 self._apiName, self._apiVersion, self._apiResource

40 )

42 # SDNC '--wait' option

43 def _wait(self, id, wait_time, deleteFlag=False):

44 self._logger.debug("")

45 self._client.get_token()

46 # Endpoint to get operation status

47 apiUrlStatus = "{}{}{}".format(self._apiName, self._apiVersion, "/sdns")

48 # Wait for status for SDN instance creation/update/deletion

49 if isinstance(wait_time, bool):

50 wait_time = WaitForStatus.TIMEOUT_SDNC_OPERATION

51 WaitForStatus.wait_for_status(

52 "SDNC",

53 str(id),

54 wait_time,

55 apiUrlStatus,

56 self._http.get2_cmd,

57 deleteFlag=deleteFlag,

58 )

60 def _get_id_for_wait(self, name):

61 """Returns id of name, or the id itself if given as argument"""

62 self._logger.debug("")

63 for sdnc in self.list():

64 if name == sdnc["_id"]:

65 return sdnc["_id"]

66 for sdnc in self.list():

67 if name == sdnc["name"]:

68 return sdnc["_id"]

69 return ""

71 def create(self, name, sdn_controller, wait=False):

72 self._logger.debug("")

73 if "config" in sdn_controller and isinstance(sdn_controller["config"], str):

74 sdn_controller["config"] = yaml.safe_load(sdn_controller["config"])

75 self._client.get_token()

76 http_code, resp = self._http.post_cmd(

77 endpoint=self._apiBase, postfields_dict=sdn_controller

78 )

79 # print('HTTP CODE: {}'.format(http_code))

80 # print('RESP: {}'.format(resp))

81 # if http_code in (200, 201, 202, 204):

82 if resp:

83 resp = json.loads(resp)

84 if not resp or "id" not in resp:

85 raise ClientException("unexpected response from server - {}".format(resp))

86 if wait:

87 # Wait for status for SDNC instance creation

88 self._wait(resp.get("id"), wait)

89 print(resp["id"])

90 # else:

91 # msg = ""

92 # if resp:

93 # try:

94 # msg = json.loads(resp)

95 # except ValueError:

96 # msg = resp

97 # raise ClientException("failed to create SDN controller {} - {}".format(name, msg))

99 def update(self, name, sdn_controller, wait=False):

100 self._logger.debug("")

101 if "config" in sdn_controller and isinstance(sdn_controller["config"], str):

102 sdn_controller["config"] = yaml.safe_load(sdn_controller["config"])

103 self._client.get_token()

104 sdnc = self.get(name)

105 sdnc_id_for_wait = self._get_id_for_wait(name)

106 http_code, resp = self._http.patch_cmd(

107 endpoint="{}/{}".format(self._apiBase, sdnc["_id"]),

108 postfields_dict=sdn_controller,

109 )

110 # print('HTTP CODE: {}'.format(http_code))

111 # print('RESP: {}'.format(resp))

112 # if http_code in (200, 201, 202, 204):

113 if wait:

114 # In this case, 'resp' always returns None, so 'resp['id']' cannot be used.

115 # Use the previously obtained id instead.

116 wait_id = sdnc_id_for_wait

117 # Wait for status for VI instance update

118 self._wait(wait_id, wait)

119 # else:

120 # pass

121 # else:

122 # msg = ""

123 # if resp:

124 # try:

125 # msg = json.loads(resp)

126 # except ValueError:

127 # msg = resp

128 # raise ClientException("failed to update SDN controller {} - {}".format(name, msg))

129

130 def delete(self, name, force=False, wait=False):

131 self._logger.debug("")

132 self._client.get_token()

133 sdn_controller = self.get(name)

134 sdnc_id_for_wait = self._get_id_for_wait(name)

135 querystring = ""

136 if force:

137 querystring = "?FORCE=True"

138 http_code, resp = self._http.delete_cmd(

139 "{}/{}{}".format(self._apiBase, sdn_controller["_id"], querystring)

140 )

141 # print('HTTP CODE: {}'.format(http_code))

142 # print('RESP: {}'.format(resp))

143 if http_code == 202:

144 if wait:

145 # Wait for status for SDNC instance deletion

146 self._wait(sdnc_id_for_wait, wait, deleteFlag=True)

147 else:

148 print("Deletion in progress")

149 elif http_code == 204:

150 print("Deleted")

151 elif resp and "result" in resp:

152 print("Deleted")

153 else:

154 msg = resp or ""

155 # if resp:

156 # try:

157 # msg = json.loads(resp)

158 # except ValueError:

159 # msg = resp

160 raise ClientException(

161 "failed to delete SDN controller {} - {}".format(name, msg)

162 )

163

164 def list(self, filter=None):

165 """Returns a list of SDN controllers"""

166 self._logger.debug("")

167 self._client.get_token()

168 filter_string = ""

169 if filter:

170 filter_string = "?{}".format(filter)

171 _, resp = self._http.get2_cmd("{}{}".format(self._apiBase, filter_string))

172 # print('RESP: {}'.format(resp))

173 if resp:

174 return json.loads(resp)

175 return list()

176

177 def get(self, name):

178 """Returns an SDN controller based on name or id"""

179 self._logger.debug("")

180 self._client.get_token()

181 if utils.validate_uuid4(name):

182 for sdnc in self.list():

183 if name == sdnc["_id"]:

184 return sdnc

185 else:

186 for sdnc in self.list():

187 if name == sdnc["name"]:

188 return sdnc

189 raise NotFound("SDN controller {} not found".format(name))