def get(self, identification=None):
if identification is not None:
result = requests.get(self.user.endpoint["glance"] + '/images/' +
identification,
headers=self.user.headers)
return utils.answer_detect(result)
result = requests.get(self.user.endpoint["glance"] + '/images',
headers=self.user.headers)
return utils.answer_detect(result)
def create(self, **kwargs):
params = {
"subnet": {}
}
params["subnet"]["network_id"] = kwargs["network_id"]
params["subnet"]["cidr"] = kwargs["cidr"]
params["subnet"]["ip_version"] = kwargs["ip_version"]
if kwargs.get("name"):
params["subnet"]["name"] = kwargs["name"]
if kwargs.get("enable_dhcp"):
params["subnet"]["enable_dhcp"] = kwargs["enable_dhcp"]
if kwargs.get("dns_nameservers"):
params["subnet"]["dns_nameservers"] = kwargs["dns_nameservers"]
if kwargs.get("allocation_pools"):
params["subnet"]["host_routes"] = kwargs["host_routes"]
if kwargs.get("gateway_ip"):
params["subnet"]["gateway_ip"] = kwargs["gateway_ip"]
if kwargs.get("host_routes"):
params["subnet"]["allocation_pools"] = kwargs["allocation_pools"]
if kwargs.get("description"):
params["subnet"]["description"] = kwargs["description"]
result = requests.post(self.user.endpoint['neutron'] + '/subnets', data=json.dumps(params),
headers=self.user.headers)
return utils.answer_detect(result)
def update(self, identification, **kwargs):
headers = {
'X-Auth-Token': self.user.token,
"Content-type": "application/openstack-images-v2.1-json-patch"
}
params = []
if kwargs.get("name"):
params.append({
"op": "replace",
"path": "/name",
"value": kwargs["name"]
})
if kwargs.get("protected") is not None:
params.append({
"op": "replace",
"path": "/protected",
"value": kwargs["protected"]
})
if kwargs.get("visibility"):
params.append({
"op": "replace",
"path": "/visibility",
"value": kwargs["visibility"]
})
result = requests.patch(url=self.user.endpoint['glance'] + '/images/' +
identification,
data=json.dumps(params),
headers=headers)
return utils.answer_detect(result)
def remove_interface(self, identification, **kwargs):
if kwargs.get("subnet_id") or kwargs.get("port_id"):
result = requests.put(self.user.endpoint['neutron'] + '/routers/' +
identification + '/remove_router_interface',
data=json.dumps(kwargs),
headers=self.user.headers)
return utils.answer_detect(result)
def create(self, identification, **kwargs):
url = self.user.endpoint[
"nova"] + "/servers/" + identification + "/metadata"
params = {"metadata": {"owner": kwargs.get("owner")}}
result = requests.get(url=url,
data=json.dumps(params),
headers=self.user.headers)
return utils.answer_detect(result)
def get(self, identification=None, **kwargs):
url = self.user.endpoint['neutron'] + '/subnets'
if identification is None:
if kwargs.get("network_id") is not None:
url = url + "?network_id=" + kwargs["network_id"]
result = requests.get(url=url, data=None, headers=self.user.headers)
else:
result = requests.get(url=url + '/' + identification,
data=None, headers=self.user.headers)
return utils.answer_detect(result)
def upload(self, upload_file, identification):
headers = {
'X-Auth-Token': self.user.token,
"Content-type": "application/octet-stream"
}
result = requests.put(url=self.user.endpoint['glance'] + '/images/' +
identification + '/file',
headers=headers,
data=upload_file)
return utils.answer_detect(result)
def update(self, identification, **kwargs):
params = {"network": {}}
if kwargs.get("name"):
params["network"]["name"] = kwargs.get("name")
if kwargs.get("shared") is not None:
params["network"]["shared"] = kwargs.get("shared")
result = requests.put(self.user.endpoint['neutron'] + '/networks/' +
identification,
data=json.dumps(params),
headers=self.user.headers)
return utils.answer_detect(result)
def get(self, identification=None):
if identification is None:
result = requests.get(self.user.endpoint['neutron'] + '/routers',
data=None,
headers=self.user.headers)
else:
result = requests.get(self.user.endpoint['neutron'] + '/routers/' +
identification,
data=None,
headers=self.user.headers)
return utils.answer_detect(result)
def update(self, identification, **kwargs):
list_result = []
url = self.user.endpoint['nova'] + '/servers'
params = {"server": {}}
if kwargs.get("name") is not None:
params["server"]["name"] = kwargs["name"]
if kwargs.get("OS-DCF:diskConfig") is not None:
params["server"]["OS-DCF:diskConfig"] = kwargs["OS-DCF:diskConfig"]
result = requests.put(url=url + '/' + identification,
data=json.dumps(params),
headers=self.user.headers)
return utils.answer_detect(result)
def update(self, identification, **kwargs):
params = {"router": {}}
if kwargs.get("name"):
params["router"]["name"] = kwargs["name"]
if kwargs.get("description"):
params["router"]["description"] = kwargs["description"]
result = requests.put(self.user.endpoint['neutron'] + '/routers/' +
identification,
data=json.dumps(params),
headers=self.user.headers)
return utils.answer_detect(result)
def create(self, **kwargs):
params = {"router": {}}
if kwargs.get("name"):
params["router"]["name"] = kwargs["name"]
if kwargs.get("project_id"):
params["router"]["project_id"] = kwargs["project_id"]
if kwargs.get("description"):
params["router"]["description"] = kwargs["description"]
result = requests.post(self.user.endpoint['neutron'] + '/routers',
data=json.dumps(params),
headers=self.user.headers)
return utils.answer_detect(result)
def get(self, identification=None, **kwargs):
url = self.user.endpoint['neutron'] + '/networks'
if identification is None:
if kwargs.get("project_id"):
url = url + '?project_id=' + kwargs["project_id"]
result = requests.get(url=url,
data=None,
headers=self.user.headers)
else:
result = requests.get(self.user.endpoint['neutron'] +
'/networks/' + identification,
data=None,
headers=self.user.headers)
return utils.answer_detect(result)
def create(self, **kwargs):
url = self.user.endpoint['nova'] + '/servers'
params = {"server": {"networks": [], "metadata": {}}}
params["server"]["name"] = kwargs["name"]
params["server"]["flavorRef"] = kwargs["flavorRef"]
if kwargs.get("net_uuid") is not None:
params["server"]["networks"].append({"uuid": kwargs["net_uuid"]})
if kwargs.get("port_id") is not None:
params["server"]["networks"].append({"port": kwargs["port_id"]})
# blank,image,snapshot,volume and image,snapshot,volume need <destination_type> is volume
if kwargs.get("source_type"):
params["server"]["block_device_mapping_v2"] = [{
"boot_index":
0,
"source_type":
kwargs["source_type"]
}]
# local or volume
if kwargs.get("destination_type"):
params["server"]["block_device_mapping_v2"][0][
"destination_type"] = kwargs["destination_type"]
if kwargs.get("source_uuid") is not None:
params["server"]["block_device_mapping_v2"][0]["uuid"] = kwargs[
"source_uuid"]
if kwargs.get("delete_on_termination") is not None:
params["server"]["block_device_mapping_v2"][0][
"delete_on_termination"] = kwargs["delete_on_termination"]
if kwargs.get("volume_size") is not None:
params["server"]["block_device_mapping_v2"][0][
"volume_size"] = kwargs["volume_size"]
if kwargs.get("destination_type") is not None:
params["server"]["block_device_mapping_v2"][0][
"destination_type"] = kwargs["destination_type"]
if kwargs.get("imageRef") is not None:
params["server"]["imageRef"] = kwargs["imageRef"]
mode = 'local'
if kwargs.get("OS-DCF:diskConfig"):
params["server"]["OS-DCF:diskConfig"] = kwargs["OS-DCF:diskConfig"]
if kwargs.get("security_groups"):
params["server"]["security_groups"] = kwargs["security_groups"]
if kwargs.get("tags"):
params["server"]["tags"] = [kwargs["tags"]]
if kwargs.get("owner"):
params["server"]["metadata"]["owner"] = kwargs["owner"]
result = requests.post(url=url,
data=json.dumps(params),
headers=self.user.headers)
return utils.answer_detect(result)
def get(self, owner=None, identification=None):
list_result = []
url = self.user.endpoint['nova'] + '/servers'
# TODO(dc): system user access nova
# if self.user.flag == 'sys':
# result = requests.get(self.user.endpoint['nova'], data=None,
# headers=self.user.headers).json()
# for i in range(len(result["servers"])):
# dict_result.append(self.struc_server(result["servers"]))
# return dict_result
if identification is not None:
result = requests.get(url=url + '/detail' + '?uuid=' +
identification,
data=None,
headers=self.user.headers)
# if utils.answer_detect(result, flag='dict')['detect']['code'] == 1:
# return list_result.append(struc_server(result.json()["servers"][0]))
# else:
# return utils.answer_detect(result)
return utils.answer_detect(result)
result = requests.get(url=url + '/detail',
data=None,
headers=self.user.headers)
# if utils.answer_detect(result, flag='dict')['detect']['code'] == 1:
# result_dict = result.json()
# result_len = len(result_dict["servers"])
# for i in range(result_len):
# if not result_dict["servers"][i]["metadata"]:
# continue
# if owner is None:
# list_result.append(struc_server(result_dict["servers"][i]))
# elif owner == result_dict["servers"][i]["metadata"]["owner"]:
# list_result.append(struc_server(result_dict["servers"][i]))
# return list_result
# else:
# return utils.answer_detect(result)
return utils.answer_detect(result)
def update(self, identification, **kwargs):
params = {
"subnet": {}
}
if kwargs.get("name"):
params["subnet"]["name"] = kwargs["name"]
if kwargs.get("enable_dhcp"):
params["subnet"]["enable_dhcp"] = kwargs["enable_dhcp"]
if kwargs.get("dns_nameservers"):
params["subnet"]["dns_nameservers"] = kwargs["dns_nameservers"]
if kwargs.get("allocation_pools"):
params["subnet"]["host_routes"] = kwargs["host_routes"]
if kwargs.get("gateway_ip"):
params["subnet"]["gateway_ip"] = kwargs["gateway_ip"]
result = requests.put(self.user.endpoint['neutron'] + '/subnets/' + identification,
data=json.dumps(params), headers=self.user.headers)
return utils.answer_detect(result)
def create(self, **kwargs):
url = self.user.endpoint['neutron'] + '/ports'
params = {
"port": {
"network_id": kwargs.get("network_id"),
"fixed_ips": [{}]
}
}
if kwargs.get("subnet_id") is not None:
params["port"]["fixed_ips"][0]["subnet_id"] = kwargs.get(
"subnet_id")
if kwargs.get("ip_address") is not None:
params["port"]["fixed_ips"][0]["ip_address"] = kwargs.get(
"ip_address")
result = requests.post(url=url,
data=json.dumps(params),
headers=self.user.headers)
return utils.answer_detect(result)
def manipulate_with_params(self, action, identification, **kwargs):
url = self.user.endpoint[
'nova'] + '/servers/' + identification + '/action'
action_set = {
"snapshot": {
"createImage": {}
},
"live_migrate": {
"os-migrateLive": {
"block_migration": "auto",
"force": False
}
},
"rebuild": {
"rebuild": {}
},
"rescue": {
"rescue": {}
},
"resize": {
"resize": {}
},
}
if action == "snapshot":
action_set[action]["createImage"]["name"] = kwargs["name"]
if action == "livemigrate":
action_set[action]["livemigrate"]["migrateLive"]["host"] = kwargs[
"host_id"]
if action == "rebuild":
action_set[action]["rebuild"]["imageRef"] = kwargs[""]
if kwargs.get("name"):
action_set[action]["rebuild"]["name"] = kwargs["name"]
if kwargs.get("key_name"):
action_set[action]["rebuild"]["key_name"] = kwargs["key_name"]
if action == "rescue":
if kwargs.get("imageRef"):
action_set[action]["rescue"]["rescue_image_ref"] = kwargs[
"imageRef"]
if action == "resize":
action_set[action]["resize"]["flavorRef"] = kwargs["flavorRef"]
result = requests.post(url=url,
data=json.dumps(action_set[action]),
headers=self.user.headers)
return utils.answer_detect(result)
def create(self, **kwargs):
params = {"name": kwargs["name"], "disk_format": kwargs["disk_format"]}
if kwargs.get("container_format"):
params["container_format"] = kwargs["container_format"]
if kwargs.get("min_disk"):
params["min_disk"] = kwargs["min_disk"]
if kwargs.get("min_ram"):
params["min_ram"] = kwargs["min_ram"]
if kwargs.get("protected") is not None:
params["protected"] = kwargs["protected"]
if kwargs.get("visibility"):
params["visibility"] = kwargs["visibility"]
if kwargs.get("tags"):
params["tags"] = kwargs["tags"]
result = requests.post(url=self.user.endpoint['glance'] + '/images',
data=json.dumps(params),
headers=self.user.headers)
return utils.answer_detect(result, flag='dict')
def create(self, **kwargs):
list_result = []
params = {"flavor": {}}
params["flavor"]["name"] = kwargs["name"]
params["flavor"]["ram"] = kwargs["ram"]
params["flavor"]["vcpus"] = kwargs["vcpus"]
params["flavor"]["disk"] = kwargs["disk"]
if kwargs.get("id") is not None:
params["flavor"]["id"] = kwargs["identification"]
if kwargs.get("os-flavor-access:is_public") is not None:
params["flavor"]["os-flavor-access:is_public"] = kwargs[
"os-flavor-access:is_public"]
result = requests.post(self.user.endpoint["nova"] + '/flavors',
data=json.dumps(params),
headers=self.user.headers)
# if utils.answer_detect(result, flag='dict')['detect']['code'] == 1:
# return list_result.append(struct_flavor(result.json()["flavor"]))
# return utils.answer_detect(result)
return utils.answer_detect(result)
def create(self, **kwargs):
params = {"floatingip": {}}
params["floatingip"]["project_id"] = kwargs["project_id"]
if kwargs.get("fixed_ip_address"):
params["floatingip"]["fixed_ip_address"] = kwargs[
"fixed_ip_address"]
if kwargs.get("floating_ip_address"):
params["floatingip"]["fixed_ip_address"] = kwargs[
"floating_ip_address"]
if kwargs.get("subnet_id"):
params["floatingip"]["subnet_id"] = kwargs["subnet_id"]
if kwargs.get("description"):
params["floatingip"]["description"] = kwargs["description"]
result = requests.post(self.user.endpoint['neutron'] + '/floatingips',
data=json.dumps(params),
headers=self.user.headers)
return utils.answer_detect(result)
def get(self, identification=None, **kwargs):
if identification is not None:
result = requests.get(self.user.endpoint["nova"] +
'/flavors/detail/' + identification,
headers=self.user.headers)
else:
result = requests.get(self.user.endpoint["nova"] +
'/flavors/detail' + '?project_id=' +
kwargs.get("project_id"),
headers=self.user.headers)
# result_dict = result.json()
# result_len = len(result_dict)
# # This id obj return
# list_result = []
# if utils.answer_detect(result, flag='dict')['detect']['code'] == 1:
# for i in range(result_len):
# list_result.append(struct_flavor(result_dict["flavors"][i]))
# return list_result
# else:
# return utils.answer_detect(result)
return utils.answer_detect(result)
def create(self, **kwargs):
params = {"network": {}}
if kwargs.get("name"):
params["network"]["name"] = kwargs["name"]
# if kwargs.get("dns_domain"):
# params["network"]["dns_domain"] = kwargs["dns_domain"]
if kwargs.get("project_id") is not None:
params["network"]["project_id"] = kwargs["project_id"]
if kwargs.get("provider:network_type") is not None:
params["network"]["provider:network_type"] = kwargs[
"provider:network_type"]
if kwargs.get("provider:physical_network") is not None:
params["network"]["provider:physical_network"] = kwargs[
"provider:physical_network"]
if kwargs.get("shared") is not None:
params["network"]["shared"] = kwargs["shared"]
if kwargs.get("description") is not None:
params["network"]["description"] = kwargs["description"]
result = requests.post(self.user.endpoint['neutron'] + '/networks',
data=json.dumps(params),
headers=self.user.headers)
return utils.answer_detect(result)
def delete(self, identification):
result = requests.delete(self.user.endpoint['neutron'] + '/subnets/' + identification,
data=None, headers=self.user.headers)
return utils.answer_detect(result)
def delete(self, identification):
result = requests.delete(url=self.user.endpoint['glance'] +
'/images/' + identification,
headers=self.user.headers)
return utils.answer_detect(result)
def get(self, identification):
url = self.user.endpoint[
"nova"] + "/servers/" + identification + "/metadata"
result = requests.get(url=url, data=None, headers=self.user.headers)
return utils.answer_detect(result)
def delete(self, identification):
result = requests.delete(self.user.endpoint["nova"] + '/flavors/' +
identification,
headers=self.user.headers)
return utils.answer_detect(result)
def get(self):
result = requests.get(self.user.endpoint["cinder"] + '/' +
self.user.project.identification +
'/volumes/detail',
headers=self.user.headers)
return utils.answer_detect(result)
def delete(self, identification):
url = self.user.endpoint['nova'] + '/servers'
result = requests.delete(url=url + '/' + identification,
headers=self.user.headers)
return utils.answer_detect(result)
def manipulate_without_params(self, action, identification):
url = self.user.endpoint[
'nova'] + '/servers/' + identification + '/action'
action_set = {
"start": {
"os-start": None
},
"stop": {
"os-stop": None
},
"pause": {
"pause": None
},
"unpause": {
"unpause": None
},
"suspend": {
"suspend": None
},
"unsuspend": {
"unsuspend": None
},
"lock": {
"lock": None
},
"unlock": {
"unlock": None
},
"shelve": {
"shelve": None
},
"unshelve": {
"unshelve": None
},
"shelveOffload": {
"shelveOffload": None
},
"hard_reboot": {
"reboot": {
"type": "HARD"
}
},
"soft_reboot": {
"reboot": {
"type": "SOFT"
}
},
"revert_resize": {
"revertResize": None
},
"confirm_resize": {
"confirmResize": None
},
"unrescue": {
"unrescue": None
}
}
result = requests.post(url=url,
data=json.dumps(action_set[action]),
headers=self.user.headers)
return utils.answer_detect(result)
