def volume_refresh(self, print_objs):
"""
List all the successfuly created
volumes
:returns: volumes object
:rtype: NoneType
"""
driver = self._get_driver()
volumes = driver.list_volumes()
db_client = Evemongo_client()
db_client.delete(VOLUME)
e = {}
n = 1
for vol in volumes:
#print(vol)
data = {}
data['id'] = vol.id
data['name'] = vol.name
data['size'] = vol.size
data['driver'] = vol.driver.name
e[n] = data
n = n + 1
db_client.post(VOLUME, data)
if print_objs == True :
Console.ok(str(Printer.dict_table(e, order=['id','name', 'size','driver'])))
return volumes
def host_list(self):
"""List of docker containers
:returns: None
:rtype: NoneType
"""
try:
scode, hosts = Rest.get('Host')
except Exception as e:
Console.error(e.message)
return
if len(hosts) == 0:
print("No hosts exist")
return
n = 1
e = {}
for host in hosts:
d = {}
d['Ip'] = str(host['Ip'])
d['Name'] = str(host['Name'])
d['Port'] = str(host['Port'])
d['Swarmmode'] = str(host['Swarmmode'])
e[n] = d
n = n + 1
Console.ok(str(Printer.dict_table(e, order=['Ip', 'Name', 'Port', 'Swarmmode'])))
def volume_delete(self, volume_name):
"""
Deletes the volumes
with specified volume_name
:returns: None
:rtype: NoneType
"""
driver = self._get_driver()
volume_objs = self.volume_refresh(False)
e = {}
isDeleted = False
for vol in volume_objs:
if vol.name == volume_name :
isDeleted = driver.destroy_volume(vol)
#print(vol)
data = {}
data['id'] = vol.id
data['name'] = vol.name
data['size'] = vol.size
data['driver'] = vol.driver.name
e[1] = data
break
Console.ok(str(Printer.dict_table(e, order=['id','name', 'size', 'driver'])))
print("Is deleted - ", isDeleted)
return
def container_list(self, kwargs=None):
"""List of docker containers
:returns: None
:rtype: NoneType
"""
try:
scode, containers = Rest.get('Container')
except docker.errors.APIError as e:
Console.error(e.explanation)
return
if len(containers) == 0:
print("No containers exist")
return
n = 1
e = {}
for container in containers:
d = {}
d['Ip'] = container['Ip']
d['Id'] = container['Id']
d['Name'] = container['Name']
d['Image'] = container['Config']['Image']
d['Status'] = container['State']['Status']
d['StartedAt'] = container['State']['StartedAt']
e[n] = d
n = n + 1
Console.ok(str(Printer.dict_table(e, order=['Ip', 'Id', 'Name', 'Image', 'Status', 'StartedAt'])))
def node_refresh(self, show_list):
"""
List the all instance
of node
:returns: nodes object
:rtype: NoneType
"""
# get driver
driver = self._get_driver()
#List the running vm's
nodes = driver.list_nodes()
db_client = Evemongo_client()
db_client.delete(NODE)
n = 0 ;
e = {}
for node in nodes:
# parse flavors
data = {}
data['uuid'] = str(node.uuid)
data['name'] = str(node.name)
data['state'] = str(node.state)
data['provider'] = str(node.driver.name)
e[n] = data
n = n + 1
db_client.post(NODE, data)
if show_list:
Console.ok(str(Printer.dict_table(e, order=['uuid', 'name', 'state', 'provider'])))
return nodes
def location_refresh(self, print_location):
"""
List all
available locations
:returns: location objects
:rtype: NoneType
"""
driver = self._get_driver()
locations = driver.list_locations()
db_client = Evemongo_client()
db_client.delete(LOCATION)
n = 1
e = {}
#<EC2NodeLocation: id=0, name=us-west-1a, country=USA, availability_zone=<ExEC2AvailabilityZone: name=us-west-1a,
# zone_state=available, region_name=us-west-1> driver=Amazon EC2>,
for location in locations:
data = {}
data['id'] = location.id
data['name'] = location.name
data['country'] = location.country
data['availability_zone'] = location.availability_zone.name
data['zone_state'] = location.availability_zone.zone_state
data['region_name'] = location.availability_zone.region_name
#data['provider'] = location.driver.name
e[n] = data
n = n + 1
db_client.post(LOCATION, data)
if print_location == True:
Console.ok(str(Printer.dict_table(e, order=['id','name','country', 'availability_zone', 'zone_state','region_name','provider'])))
return locations
def images_list(self, kwargs=None):
"""List of docker images
:returns: None
:rtype: NoneType
"""
try:
scode, images = Rest.get('Image')
except docker.errors.APIError as e:
Console.error(e.explanation)
return
if len(images) == 0:
Console.info("No images exist")
return
n = 1
e = {}
for image in images:
d = {}
d['Ip'] = image['Ip']
d['Id'] = image['Id']
if image['RepoTags'] == None:
d['Repository'] = image['RepoDigests'][0]
else:
d['Repository'] = image['RepoTags'][0]
# d['Size'] = image['Size']
d['Size(GB)'] = round(image['Size'] / float(1 << 30), 2) # Converting the size to GB
e[n] = d
n = n + 1
Console.ok(str(Printer.dict_table(e, order=['Ip', 'Id', 'Repository', 'Size(GB)'])))
def keypair_create(self, key_pair):
"""
Creates the key pair
required for node object
:returns: None
:rtype: NoneType
"""
driver = self._get_driver()
key_pair_obj = driver.create_key_pair(key_pair)
#print("keypair is created !",name)
n = 0 ;
e = {}
# parse flavors
data = {}
data['name'] = str(key_pair_obj.name)
data['fingerprint'] = str(key_pair_obj.fingerprint)
e[n] = data
n = n + 1
Console.ok(str(Printer.dict_table(e, order=['name', 'fingerprint', 'driver'])))
#Store the created keypair in db
db_client = Evemongo_client()
db_client.post(KEYPAIR, data)
return
def network_list(self, kwargs=None):
"""List of docker networks
:returns: None
:rtype: NoneType
"""
try:
scode, networks = Rest.get('Network')
except docker.errors.APIError as e:
Console.error(e.explanation)
return
if len(networks) == 0:
Console.info("No network exist")
return
n = 1
e = {}
data = []
for network in networks:
d = {}
d['Ip'] = network['Ip']
d['Id'] = network['Id']
d['Name'] = network['Name']
d['Containers'] = network['Containers']
e[n] = d
n = n + 1
Console.ok(str(Printer.dict_table(e, order=['Ip', 'Id', 'Name', 'Containers'])))
def keypair_refresh(self):
"""
List all the available key pair
associated with account
:returns: None
:rtype: NoneType
"""
driver = self._get_driver()
db_client = Evemongo_client()
db_client.delete(KEYPAIR)
key_pair_objs = driver.list_key_pairs()
n =1
e = {}
for kp in key_pair_objs:
data = {}
data['name'] = kp.name
data['fingerprint'] = kp.fingerprint
e[n] = data
n = n + 1
db_client.post(KEYPAIR, data)
Console.ok(str(Printer.dict_table(e, order=['name', 'fingerprint'])))
return
def node_refresh(self):
"""Refresh of swarm nodes
:returns: None
:rtype: NoneType
"""
filter = {}
filter['Swarmmode'] = 'Manager'
scode, hosts = Rest.get('Host', filter)
filter = {}
n = 1
e = {}
data = []
for host in hosts:
os.environ["DOCKER_HOST"] = host['Ip'] + ":" + str(host['Port'])
filter = {}
filter['Ip'] = os.environ["DOCKER_HOST"].split(':')[0]
self.client = docker.from_env()
try:
nodes = self.client.nodes.list()
except docker.errors.APIError as e:
Console.error(e.explanation)
return
if len(nodes) == 0:
Console.info("No nodes exist for manager" +
os.environ["DOCKER_HOST"].split(':'))
continue
n = 1
e = {}
data = []
for node in nodes:
d = {}
node_dict = node.__dict__['attrs']
d['Id'] = node_dict['ID']
data.append(node_dict)
d['Role'] = node_dict['Spec']['Role']
d['Status'] = node_dict['Status']['State']
if d['Role'] == 'manager':
d['Ip'] = node_dict['ManagerStatus']['Addr'].split(':')[0]
d['Manager Ip'] = ''
else:
d['Ip'] = node_dict['Status']['Addr']
d['Manager Ip'] = os.environ["DOCKER_HOST"].split(':')[0]
d['Host Name'] = node_dict['Description']['Hostname']
e[n] = d
n = n + 1
Console.ok(
str(
Printer.dict_table(e,
order=[
'Ip', 'Host Name', 'Id', 'Role',
'Status', 'Manager Ip'
])))
Rest.delete('Node')
Rest.post('Node', data)
def node_create_by_imageId(self, vm_name, config):#image_id, keypair_name, security_group_names, flavor_id):
"""
Created the node with
specified image id,
keypair name should be AWS1
rest of the parameter; security group
and flavor id are take bydefault
:returns: None
:rtype: NoneType
"""
# get driver
driver = self._get_driver()
db_client = Evemongo_client()
if "image_id" not in config :
image_id = self.configd["default"]['image']#'ami-0183d861'
else:
image_id = config["image_id"]
#print(image_id)
# Name of the existing keypair you want to use
if "keypair_name" not in config:
keypair_name = KEYPAIR_NAME_DEFAULT
else:
keypair_name = config["keypair_name"]
# A list of security groups you want this node to be added to
if "security_group_names" not in config:
security_group_names = ['default']
else:
security_group_names = config["security_group_names"]
if "flavor_id" not in config:
flavor_id = self.configd["default"]['flavor']
else:
flavor_id = config["flavor_id"]
sizes = driver.list_sizes()
size = [s for s in sizes if s.id == flavor_id][0]
image = driver.get_image(image_id)
# create node
node = driver.create_node(name=vm_name, size = size, image = image, ex_keyname = keypair_name, ex_securitygroup = security_group_names)
#print("The Node is Created --------------- :: ",node)
n = 0 ;
e = {}
data = {}
data['uuid'] = str(node.uuid)
data['name'] = str(node.name)
data['state'] = str(node.state)
data['public_ips'] = str(node.public_ips)
data['private_ips'] = str(node.private_ips)
data['provider'] = str(node.driver.name)
e[n] = data
n = n + 1
Console.ok(str(Printer.dict_table(e, order=['uuid', 'name', 'state', 'public_ips', 'private_ips','provider'])))
if bool(node) :
#Push the created node in db
db_client.post(NODE, data)
return
def service_refresh(self, kwargs=None):
"""List of docker images
:returns: None
:rtype: NoneType
"""
filter = {}
filter['Swarmmode'] = 'Manager'
scode, hosts = Rest.get('Host', filter)
filter = {}
n = 1
e = {}
data = []
for host in hosts:
os.environ["DOCKER_HOST"] = host['Ip'] + ":" + str(host['Port'])
filter = {}
filter['Ip'] = os.environ["DOCKER_HOST"].split(':')[0]
self.client = docker.from_env()
try:
services = self.client.services.list(**kwargs)
except docker.errors.APIError as e:
Console.error(e.explanation)
return
if len(services) == 0:
Console.info("No service exist on host" + host['Ip'])
continue
for servicem in services:
d = {}
service = servicem.__dict__['attrs']
service['Ip'] = os.environ["DOCKER_HOST"].split(':')[0]
data.append(service)
d['Ip'] = service['Ip']
d['Id'] = service['ID']
d['Name'] = service['Spec']['Name']
d['Image'] = service['Spec']['TaskTemplate']['ContainerSpec'][
'Image']
d['Replicas'] = service['Spec']['Mode']['Replicated'][
'Replicas']
e[n] = d
n = n + 1
Rest.delete('Service')
if len(data) == 0:
Console.info("No service exist ")
return
Rest.post('Service', data)
Console.ok(
str(
Printer.dict_table(
e, order=['Ip', 'Id', 'Name', 'Image', 'Replicas'])))
def images_refresh(self, kwargs=None):
"""List of docker images
:returns: None
:rtype: NoneType
"""
filter = {}
scode, hosts = Rest.get('Host', filter)
filter = {}
n = 1
e = {}
data = []
for host in hosts:
os.environ["DOCKER_HOST"] = host['Ip'] + ":" + str(host['Port'])
filter = {}
filter['Ip'] = os.environ["DOCKER_HOST"].split(':')[0]
if host['Swarmmode'] == 'Worker':
Rest.delete('Image', filter)
continue
self.client = docker.from_env()
try:
images = self.client.images.list(**kwargs)
except docker.errors.APIError as e:
Console.error(e.explanation)
return
if len(images) == 0:
Console.info("No images exist on host " + host['Ip'])
continue
for imagem in images:
image = imagem.__dict__['attrs']
image['Ip'] = os.environ["DOCKER_HOST"].split(':')[0]
data.append(image)
d = {}
d['Ip'] = os.environ["DOCKER_HOST"].split(':')[0]
d['Id'] = image['Id']
if image['RepoTags'] == None:
d['Repository'] = image['RepoDigests'][0]
else:
d['Repository'] = image['RepoTags'][0]
# d['Size'] = image['Size']
d['Size(GB)'] = round(image['Size'] / float(1 << 30), 2)
e[n] = d
n = n + 1
Rest.delete('Image', filter)
Rest.post('Image', data)
Console.ok(
str(
Printer.dict_table(
e, order=['Ip', 'Id', 'Repository', 'Size(GB)'])))
def container_refresh(self, kwargs=None):
"""List of docker containers
:returns: None
:rtype: NoneType
"""
filter = {}
scode, hosts = Rest.get('Host', filter)
filter = {}
n = 1
e = {}
data = []
for host in hosts:
os.environ["DOCKER_HOST"] = host['Ip'] + ":" + str(host['Port'])
self.client = docker.from_env()
filter['Ip'] = os.environ["DOCKER_HOST"].split(':')[0]
try:
containers = self.client.containers.list(all, **kwargs)
except docker.errors.APIError as e:
Console.error(e.explanation)
return
if len(containers) == 0:
print("No containers exist" + str(host['Ip']))
continue
for containerm in containers:
container = containerm.__dict__['attrs']
container['Ip'] = os.environ["DOCKER_HOST"].split(':')[0]
data.append(container)
d = {}
d['Ip'] = os.environ["DOCKER_HOST"].split(':')[0]
d['Id'] = container['Id']
d['Name'] = container['Name']
d['Image'] = container['Config']['Image']
d['Status'] = container['State']['Status']
d['StartedAt'] = container['State']['StartedAt']
e[n] = d
n = n + 1
Rest.delete('Container', filter)
Rest.post('Container', data)
Console.ok(
str(
Printer.dict_table(
e,
order=['Ip', 'Id', 'Name', 'Image', 'Status',
'StartedAt'])))
def network_refresh(self, kwargs=None):
"""List of docker networks
:returns: None
:rtype: NoneType
"""
filter = {}
scode, hosts = Rest.get('Host', filter)
filter = {}
n = 1
e = {}
data = []
for host in hosts:
os.environ["DOCKER_HOST"] = host['Ip'] + ":" + str(host['Port'])
filter = {}
filter['Ip'] = os.environ["DOCKER_HOST"].split(':')[0]
if host['Swarmmode'] == 'Worker':
Rest.delete('Network', filter)
continue
self.client = docker.from_env()
try:
networks = self.client.networks.list(**kwargs)
except docker.errors.APIError as e:
Console.error(e.explanation)
return
if len(networks) == 0:
Console.info("No network exist" + host['Ip'])
continue
for networkm in networks:
network = networkm.__dict__['attrs']
network['Ip'] = os.environ["DOCKER_HOST"].split(':')[0]
data.append(network)
d = {}
d['Ip'] = os.environ["DOCKER_HOST"].split(':')[0]
d['Id'] = network['Id']
d['Name'] = network['Name']
d['Containers'] = network['Containers']
e[n] = d
n = n + 1
r = Rest.delete('Network', filter)
r = Rest.post('Network', data)
Console.ok(
str(Printer.dict_table(e, order=['Ip', 'Id', 'Name',
'Containers'])))
def volume_create(self, volume_size, volume_name):
"""
Creates the volume with default
size of 1GB with specified volume name
location for volume will be fetch from
../cloudmesh.yaml file
:returns: None
:rtype: NoneType
"""
#Some test functionality
db_client = Evemongo_client()
#Some test functionality
flavor_id = self.configd["default"]['flavor']
location = self.configd["default"]['location']
driver = self._get_driver()
sizes = driver.list_sizes()
size = [s for s in sizes if s.id == flavor_id][0]
locations = self.location_refresh(False)
if len(locations) == 0:
print("Location not found!!")
else:
e = {}
for loc in locations:
if loc.availability_zone.region_name == location:
locObj = loc
#print(locObj)
storageVolume = driver.create_volume(volume_size, volume_name, location=locObj, snapshot=None)
#<StorageVolume id=vol-0e80356132e246a7b size=1 driver=Amazon EC2>
data = {}
data['id'] = storageVolume.id
data['name'] = volume_name
data['size'] = storageVolume.size
data['driver'] = storageVolume.driver.name
e[0] = data
# store it in mongodb
db_client.post(VOLUME, data)
Console.ok(str(Printer.dict_table(e, order=['id','name', 'size','driver'])))
else:
print("Location list does not match with selected location: ", location)
break
#print("======Created volume ========= :: ",storageVolume)
return
def keypair_list(self):
"""
List all the keypairs
stored in db
:returns: None
:rtype: NoneType
"""
db_client = Evemongo_client()
keys = db_client.get(KEYPAIR)
n= 1
e = {}
for key in keys:
e[n] = key
n = n + 1
Console.ok(str(Printer.dict_table(e, order=['name', 'fingerprint'])))
return
def location_list(self,print_location):
"""
List out all the available location
for the associated account
:returns: None
:rtype: NoneType
"""
db_client = Evemongo_client()
locations = db_client.get(LOCATION)
n = 1
e = {}
for location in locations:
e[n] = location
n = n + 1
if print_location:
Console.ok(str(Printer.dict_table(e, order=['id','name','country', 'availability_zone', 'zone_state','region_name','provider'])))
return locations
def node_delete(self, node_name):
"""
Delete the node who's
node_name is mentioned
:returns: None
:rtype: NoneType
"""
# get driver
#print("getting vm list")
driver = self._get_driver()
#List the running vm's
#Take the running node list
nodes = self.node_refresh(False)
node = {}
for n in nodes:
if n.name == node_name:
node = n
if node:
if bool(node) == False:
print("No node found to delete")
else:
isNodeDelete = driver.destroy_node(node)
n = 0 ;
e = {}
data = {}
data['uuid'] = str(node.uuid)
data['name'] = str(node.name)
data['state'] = str(node.state)
data['public_ips'] = str(node.public_ips)
data['private_ips'] = str(node.private_ips)
data['provider'] = str(node.driver.name)
e[n] = data
n = n + 1
Console.ok(str(Printer.dict_table(e, order=['uuid', 'name', 'state', 'public_ips', 'private_ips','provider'])))
print("Deleted Node is ---------------",isNodeDelete)
if isNodeDelete :
#Delete the node from db as well
print("Node deleted from db")
else:
Console.error("No such VM running at the movement")
return
def node_list(self):
"""
List all the nodes
stored in db
:returns: None
:rtype: NoneType
"""
db_client = Evemongo_client()
nodes = db_client.get(NODE)
n= 1
e = {}
for node in nodes:
e[n] = node
n = n + 1
Console.ok(str(Printer.dict_table(e, order=['uuid', 'name', 'state', 'provider'])))
return
def node_reboot(self, node_name):
"""
To reboot the node,
reboot time specific to
created node configuration
:returns: None
:rtype: NoneType
"""
driver = self._get_driver()
db_client = Evemongo_client()
#Take the running node list
nodes = self.node_refresh(False)
node = {}
for n in nodes:
if n.name == node_name:
node = n
break
if bool(node) == False:
Console.error("No node found to reboot")
else:
if node.state == NodeState.RUNNING:
isNodeReboot = node.reboot()
n = 0 ;
e = {}
data = {}
data['uuid'] = str(node.uuid)
data['name'] = str(node.name)
data['state'] = str(node.state)
data['public_ips'] = str(node.public_ips)
data['private_ips'] = str(node.private_ips)
data['provider'] = str(node.driver.name)
e[n] = data
n = n + 1
Console.ok(str(Printer.dict_table(e, order=['uuid', 'name', 'state', 'public_ips', 'private_ips','provider'])))
print("Node is NodeState.REBOOTING---------------",isNodeReboot)
if isNodeReboot :
#Delete the node from db as well
print("Node deleted from db")
#db_client.delete(NODE)
return
def flavor_list(self):
"""List of amazon images
get store it in db
:returns: None
:rtype: NoneType
"""
#fetch the list from db, parse and print
db_client = Evemongo_client()
sizes = db_client.get(FLAVOR)
n= 1
e = {}
for size in sizes:
e[n] = size
n = n + 1
Console.ok(str(Printer.dict_table(e, order=['id', 'name', 'ram', 'disk', 'price'])))
return
def image_list(self):
"""List of amazon images
from mongodb
:returns: None
:rtype: NoneType
"""
#Fetch the list of images from db
db_client = Evemongo_client()
images = db_client.get(IMAGE)
n= 1
e = {}
for image in images:
e[n] = image
n = n + 1
Console.ok(str(Printer.dict_table(e, order=['id', 'name', 'driver'])))
return
def node_list(self, kwargs=None):
"""List of docker swarm nodes
:returns: None
:rtype: NoneType
"""
scode, nodes = Rest.get('Node')
if len(nodes) == 0:
Console.info("No nodes exist")
return
n = 1
e = {}
data = []
for node in nodes:
d = {}
node_dict = node
d['Id'] = node_dict['ID']
data.append(node_dict)
d['Role'] = node_dict['Spec']['Role']
d['Status'] = node_dict['Status']['State']
if d['Role'] == 'manager':
d['Ip'] = node_dict['ManagerStatus']['Addr'].split(':')[0]
d['Manager Ip'] = ''
else:
d['Ip'] = node_dict['Status']['Addr']
d['Manager Ip'] = os.environ["DOCKER_HOST"].split(':')[0]
d['Host Name'] = node_dict['Description']['Hostname']
e[n] = d
n = n + 1
Console.ok(
str(
Printer.dict_table(e,
order=[
'Ip', 'Host Name', 'Id', 'Role',
'Status', 'Manager Ip'
])))
def volume_list(self, print_objs):
"""
List all the successfuly stored
volumes
:returns: None
:rtype: NoneType
"""
#Fetch the list of images from db
db_client = Evemongo_client()
volumes = db_client.get(VOLUME)
e = {}
n = 1
for vol in volumes:
e[n] = vol
n = n + 1
if print_objs == True :
Console.ok(str(Printer.dict_table(e, order=['id','name', 'size','driver'])))
return volumes
def image_refresh(self):
"""List of amazon images
get store it in db
:returns: None
:rtype: NoneType
"""
# get driver
driver = self._get_driver()
# get image list and print
images = driver.list_images()
db_client = Evemongo_client()
if len(images) == 0:
print("Error in fetching new list ...Showing existing images")
self.image_list()
else:
#r = db_client.delete(IMAGE)
#print(images)
#print("storing in db")
#db_client.perform_delete(IMAGE)
n = 0 ;
e = {}
for image in images:
# parse flavors
data = {}
data['id'] = str(image .id)
data['name'] = str(image.name)
data['driver'] = str(image.driver)
# store it in mongodb
db_client.post(IMAGE, data)
e[n] = data
n = n + 1
Console.ok(str(Printer.dict_table(e, order=['id', 'name', 'driver'])))
#print(images)
return
def keypair_get(self, key_pair):
"""
Get the keypair object
associated with name
:returns: keypar object
:rtype: NoneType
"""
driver = self._get_driver()
e = {}
key_pair_obj= {}
try:
key_pair_obj = driver.get_key_pair(key_pair)
except Exception:
Console.error("Key does not exist")
else:
data = {}
data['name'] = key_pair_obj.name
data['fingerprint'] = key_pair_obj.fingerprint
e[1] = data
Console.ok(str(Printer.dict_table(e, order=['name', 'fingerprint'])))
return key_pair_obj
def service_list(self, kwargs=None):
"""List of docker images
:returns: None
:rtype: NoneType
"""
try:
scode, services = Rest.get('Service')
# services = self.client.services.list(**kwargs)
except docker.errors.APIError as e:
Console.error(e.explanation)
return
if len(services) == 0:
Console.info("No Services exist")
return
n = 1
e = {}
for service in services:
d = {}
d['Ip'] = service['Ip']
d['Id'] = service['ID']
d['Name'] = service['Spec']['Name']
d['Image'] = service['Spec']['TaskTemplate']['ContainerSpec'][
'Image']
d['Replicas'] = service['Spec']['Mode']['Replicated']['Replicas']
# need to see if status needs to be added.
e[n] = d
n = n + 1
Console.ok(
str(
Printer.dict_table(
e, order=['Ip', 'Id', 'Name', 'Image', 'Replicas'])))
def flavor_refresh(self):
"""
List all the flavor list
available on Amazon EC2
:returns: None
:rtype: NoneType
"""
#get driver
driver = self._get_driver()
# get flavor list and print
sizes = driver.list_sizes()
#print(sizes)
n = 1
e = {}
db_client = Evemongo_client()
db_client.delete(FLAVOR)
for size in sizes:
# parse flavors
data = {}
data['id'] = size .id
data['name'] = size.name
data['ram'] = size.ram
data['disk'] = size.disk
data['price'] = size.price
e[n] = data
n = n + 1
# store it in mongodb
db_client.post(FLAVOR, data)
#print(data)
Console.ok(str(Printer.dict_table(e, order=['id', 'name', 'ram', 'disk', 'bandwidth', 'price'])))
#print("successfully stored in db", r)
return
