def list(cls, cloud, output="table", tenant=None): try: provider = CloudProvider(cloud).provider # if tenant is None: # tenant = provider.tenant result = provider.list_limits(tenant)["absolute"] (order, header) = CloudProvider(cloud).get_attributes("limits") return attribute_printer(result, header=header, output=output) except Exception as e: return e
def list(cls, cloud, tenant, output="table"): try: provider = CloudProvider(cloud).provider result = provider.list_quota(cloud) (order, header) = CloudProvider(cloud).get_attributes("quota") return attribute_printer(result, header=header, output=output) except Exception as e: import sys print(sys.exc_info()[0]) return e
def list(cls, cloud=None, names=None, output='table', live=False): try: if live: cls.refresh(cloud) elements = cls.cm.find(kind="vm", category=cloud) result = [] if "all" in names: for element in elements: result.append(element) elif names is not None: for element in elements: if element["name"] in names: result.append(element) (order, header) = CloudProvider(cloud).get_attributes("ip") return Printer.write(result, order=order, header=header, output=output) except Exception as ex: Console.error(ex.message)
def __init__(self, *args, **kwargs): # Use the table defined in the model, but we need to look up # the provider object dynamically kwargs['cloud'] = kwargs.get('cloud', Default.cloud) kwargs['image'] = kwargs.get('image', Default.image) kwargs['username'] = kwargs.get('username', Image.guess_username(kwargs['image'])) kwargs['flavor'] = kwargs.get('flavor', Default.flavor) kwargs['key'] = kwargs.get('key', Default.key) kwargs['secgroup'] = kwargs.get('secgroup', Default.secgroup) super(Cluster, self).__init__(*args, **kwargs) self.provider = CloudProvider(self.cloud).provider.cloud_type # put this cluster in the database, the 'name' attribute must # be unique try: self.cm.insert(self) except IntegrityError as e: line = 'UNIQUE constraint failed: {}.name'\ .format(self.__tablename__) if line in e.message: raise ClusterNameClashException(self.__tablename__, self.name)
def stop(cls, **kwargs): arg = dotdict(kwargs) cloud_provider = CloudProvider(arg.cloud).provider for server in kwargs["servers"]: cloud_provider.stop_vm(server) Console.ok("Machine {:} is being stopped on {:} Cloud...".format( server, cloud_provider.cloud))
def test_002(self): """ test flavor list :return: """ HEADING() from pprint import pprint cloud = "chameleon-ec2" provider = CloudProvider(cloud).provider # print (provider, type(provider)) # r = provider.list_flavor(cloud) # pprint(r) kind = 'flavor' r = provider.list(kind, cloud) pprint(r) assert 't2.small' in str(r) r = provider.list_flavor(cloud) pprint(r) assert 't2.small' in str(r) r = provider.provider.list_sizes(cloud) pprint(r) assert 't2.small' in str(r)
def test_003(self): """ test vm list :return: """ HEADING() from pprint import pprint cloud = "chameleon-ec2" provider = CloudProvider(cloud).provider print(provider, type(provider)) # pprint (provider.__dict__) # pprint (dir(provider)) #r = provider.list_flavor(cloud) #pprint(r) for kind in [ "image" ]: # ["image", "vm", "flavor", "key"]: # , "flavor", "vm", "limits", "quota"]: r = provider.list(kind, cloud) pprint(r) assert True
def enable_ssh(cls, secgroup_name='default', cloud="general"): ret = False cloud_provider = CloudProvider(cloud).provider.provider secgroups = cloud_provider.security_groups.list() for asecgroup in secgroups: if asecgroup.name == secgroup_name: rules = asecgroup.rules rule_exists = False # structure of a secgroup rule: # {u'from_port': 22, u'group': {}, u'ip_protocol': u'tcp', u'to_port': 22, u'parent_group_id': u'UUIDHERE', u'ip_range': {u'cidr': u'0.0.0.0/0'}, u'id': u'UUIDHERE'} for arule in rules: if arule["from_port"] == 22 and \ arule["to_port"] == 22 and \ arule["ip_protocol"] == 'tcp' and \ arule["ip_range"] == {'cidr': '0.0.0.0/0'}: # print (arule["id"]) rule_exists = True break if not rule_exists: cloud_provider.security_group_rules.create( asecgroup.id, ip_protocol='tcp', from_port=22, to_port=22, cidr='0.0.0.0/0') # else: # print ("The rule allowing ssh login did exist!") ret = True break # print ("*" * 80) # d = SecGroup.convert_list_to_dict(secgroups) # print (d) return ret
def delete_rule(cls, cloud, secgroup, from_port, to_port, protocol, cidr): try: args = { "groupid": secgroup.uuid, "fromPort": from_port, "toPort": to_port, "protocol": protocol, "cidr": cidr } rule = cls.cm_db.find("secgrouprule", output="object", **args).first() if rule is not None: # get the nova client for cloud cloud_provider = CloudProvider(cloud).provider # delete the rule from the cloud cloud_provider.delete_secgroup_rule(rule.uuid) # delete the local db record cls.cm_db.delete(rule) return "Rule [{} | {} | {} | {}] deleted" \ .format(from_port, to_port, protocol, cidr) else: return None except Exception as ex: Console.error(ex.message, ex) return
def delete_rule(cls, cloud, secgroup, from_port, to_port, protocol, cidr): try: args = { "group": secgroup["uuid"], "fromPort": from_port, "toPort": to_port, "protocol": protocol, "cidr": cidr } rule = cls.cm.find(kind="secgrouprule", output="object", scope="first", **args) if rule is not None: # get the nova client for cloud cloud_provider = CloudProvider(cloud).provider # delete the rule from the cloud cloud_provider.delete_secgroup_rule(rule.uuid) # delete the local db record cls.cm.delete(rule) return "Rule [{fromPort} | {toPort} | {protocol} | {cidr}] deleted" \ .format(**args) else: return None except Exception as ex: Console.error("delete rule") return
def delete(cls, category='general', group=None, name=None): # name is anme of the rule if category=='general': if name is None and group is not None: # delete the entire group cls.cm.delete(kind="secgrouprule", group=group) elif name is not None and group is not None: # delete specific rule cls.cm.delete(name=name, kind="secgrouprule", group=group) elif name is None and group is None: # delete all groups cls.cm.delete(kind="secgrouprule") if group == Default.secgroup or Default.secgroup is None: cls.reset_defaults() else: provider = CloudProvider(category).provider # delete on cloud if group is not None: provider.delete_secgroup(name) # delete the entire group elif group is None: # delete all groups pass
def list(cls, **kwargs): """ This method lists all VMs of the cloud """ try: if "name_or_id" in kwargs and kwargs["name_or_id"] is not None: if cls.isUuid(kwargs["name_or_id"]): elements = cls.cm.find("vm", category=kwargs["cloud"], uuid=kwargs["name_or_id"]) else: elements = cls.cm.find("vm", category=kwargs["cloud"], label=kwargs["name_or_id"]) else: elements = cls.cm.find("vm", category=kwargs["cloud"]) # print(elements) # order = ['id', 'uuid', 'name', 'cloud'] (order, header) = CloudProvider(kwargs["cloud"]).get_attributes("vm") # order = None if "name_or_id" in kwargs and kwargs["name_or_id"] is not None: return attribute_printer(list(elements.values())[0], output=kwargs["output_format"]) else: return dict_printer(elements, order=order, output=kwargs["output_format"]) except Exception as ex: Console.error(ex.message, ex)
def list_floating_ip(cls, cloudname): """ Method to list floating ips :param cloudname: :return: floating ip list """ try: floating_ips = cls.get_floating_ip_list(cloudname) for floating_ip in list(floating_ips.values()): # Get instance_id associated with instance instance_id = floating_ip["instance_id"] if instance_id is not None: try: instance_name = cls.find_instance_name( cloudname=cloudname, instance_id=instance_id) # Assign it to the dict floating_ip["instance_name"] = instance_name except Exception as ex: Console.error(ex.message) continue else: # If no instance associated, keep None floating_ip["instance_name"] = None (order, header) = CloudProvider(cloudname).get_attributes("floating_ip") return dict_printer(floating_ips, order=order, header=header) except Exception as ex: Console.error(ex.message, ex) return
def list_rules_cloud(cls, cloud, groupname): provider = CloudProvider(cloud).provider groups = provider.list_secgroup(cloud) for id in groups: group = groups[id] if groupname == group["name"]: return group["rules"] return None
def delete_all_rules_cloud(cls, cloud, groupname): rules = cls.list_rules_cloud(cloud, groupname) provider = CloudProvider(cloud).provider if rules: for rule in rules: ruleid = rule['id'] provider.delete_secgroup_rule(ruleid) return
def delete_secgroup(cls, name=None, cloud=None): try: # Find the secgroup from the cloud cloud_provider = CloudProvider(cloud).provider result = cloud_provider.delete_secgroup(name) return result except Exception as ex: Console.error("delete group")
def delete(cls, **kwargs): cloud_provider = CloudProvider(kwargs["cloud"]).provider for server in kwargs["servers"]: cloud_provider.delete_vm(server) print("Machine {:} is being deleted on {:} Cloud...".format(server, cloud_provider.cloud)) # Explicit refresh called after VM delete, to update db. cls.refresh(cloud=kwargs["cloud"])
def delete_secgroup(cls, label, cloud): try: # Find the secgroup from the cloud cloud_provider = CloudProvider(cloud).provider result = cloud_provider.delete_secgroup(label) return result except Exception as ex: Console.error(ex.message, ex)
def list_floating_ip_pool(cls, cloudname): """ Method to list floating ip pool :param cloudname: :return: """ try: cloud_provider = CloudProvider(cloudname).provider floating_ip_pools = cloud_provider.list_floating_ip_pools() (order, header ) = CloudProvider(cloudname).get_attributes("floating_ip_pool") return Printer.write(floating_ip_pools, order=order, header=header) except Exception as ex: Console.error(ex.message) pass
def rename(cls, **kwargs): cloud_provider = CloudProvider(kwargs["cloud"]).provider new_name = kwargs["new_name"] for server in kwargs["servers"]: cloud_provider.rename_vm(server, new_name) print("Machine {:} renamed to {:} on {:} Cloud...".format(server, new_name, cloud_provider.cloud)) # Explicit refresh called after VM delete, to update db. cls.refresh(cloud=kwargs["cloud"])
def delete_rule_cloud(cls, cloud, groupname, rulename): ret = None provider = CloudProvider(cloud).provider ruleid = cls.get_rule_cloud(cloud, groupname, rulename) if ruleid: ret = provider.delete_secgroup_rule(ruleid) #else: # Console.error("Rule does not exist - Rule:{}, Group:{}"\ # .format(rulename, groupname), traceflag=False) return ret
def get_group_cloud(cls, cloud, groupname): provider = CloudProvider(cloud).provider groups = provider.list_secgroup(cloud) ret = None for groupkey in groups: group = groups[groupkey] if group["name"] == groupname: ret = group break return ret
def get_from_cloud(cls, cloud, live=False, format="table"): """ This method lists all keys of the cloud :param cloud: the cloud name :return: a SSHKeyManager (dict of keys) """ try: return CloudProvider(cloud).provider.list_key(cloud) except Exception as ex: Console.error(ex.message)
def list_on_cloud(cls, cloud, live=False, format="table"): """ This method lists all flavors of the cloud :param cloud: the cloud name """ try: keys = CloudProvider(cloud).provider.list_key(cloud) for key in keys: keys[key]["category"] = cloud if keys is None or keys is []: return None (order, header) = CloudProvider(cloud).get_attributes("key") return Printer.write(keys, order=order, header=header, output=format) except Exception as ex: Console.error(ex.message)
def list(cls, cloud, kind): """ This method lists all flavors of the cloud :param cloud: the cloud name :param kind: the kind of the attribute """ try: (order, header) = CloudProvider(cloud).get_attributes(kind) return order, header except Exception as ex: Console.error(ex.message)
def delete_all_rules_cloud(cls, cloud, groupname): rules = cls.list_rules_cloud(cloud, groupname) provider = CloudProvider(cloud).provider if rules: for rule in rules: ruleid = rule['id'] # only refresh those defined with a protocol # This leaves the default rule defined by # allowing the same secgroup untouched if rule['ip_protocol']: provider.delete_secgroup_rule(ruleid) return
def get_floating_ip_list(cls, cloudname): """ Method to get the floating IP list :param cloudname: :return: floating_ips """ try: cloud_provider = CloudProvider(cloudname).provider floating_ips = cloud_provider.list_floating_ips() return floating_ips except Exception as ex: Console.error(ex.message)
def unreserve_fixed_ip(cls, cloudname, fixed_ip_addr): """ Unreserve a fixed ip address :param cloudname: :param fixed_ip_addr: :return: """ try: cloud_provider = CloudProvider(cloudname).provider cloud_provider.unreserve_fixed_ip(fixed_ip_addr=fixed_ip_addr) return "Success." except Exception as ex: Console.error(ex.message) return ex
def list(cls, group=None, name=None, category='general', output='table', scope='all'): """ This method queries the database to fetch list of secgroups filtered by cloud. :param cloud: :return: """ query = dotdict({ "kind": "secgrouprule", "scope": "all" }) if category is "general": if group is not None: query.group = group if name is not None: query.name = name query.category = category elements = cls.cm.find(**query) else: elements = CloudProvider(category).provider.list_secgroup_rules(category) if elements is None: return None else: # pprint(elements) # # BUG this should not depend on cloud, but on "general" # # (order, header) = CloudProvider(cloud).get_attributes("secgroup") order = ['name', 'group', 'fromPort', 'toPort', 'cidr', 'protocol'] header = None return Printer.write(elements, order=order, header=header, output=output)
def delete(cls, name=None, cloud=None): if cloud is not None and name is not None: result = CloudProvider(cloud).provider.delete_key_from_cloud(name) elif cloud is not None and name is None: # # get a list of keys from cloud # loop over all keys and use the provider delete from cloud to delete that key Console.error("delete all keys from cloud not yet implemented") if name is None: cls.cm.delete(kind="key", provider="general") else: cls.cm.delete(name=name, kind="key", provider="general")