plstackapi/openstack/driver.py

   1 from plstackapi.planetstack.config import Config
   2 from plstackapi.openstack.shell import OpenStackShell
   3
   4 class OpenStackDriver:
   5
   6     def __init__(self, config = None):
   7         if config:
   8             self.config = Config(config)
   9         else:
  10             self.config = Config()
  11         self.shell = OpenStackShell()
  12
  13     def create_tenant(self, **kwds):
  14         """Create keystone tenant. Suggested fields: name, description, enabled"""
  15         required_fields = ['tenant_name', 'enabled', 'description']
  16         for field in required_fields:
  17             if field not in kwds:
  18                 raise Exception, "Must specify %s" % field
  19
  20         tenants = self.shell.keystone.tenants.findall(name=kwds['tenant_name'])
  21         if not tenants:
  22             tenant = self.shell.keystone.tenants.create(**kwds)
  23         else:
  24             tenant = tenants[0]
  25         return tenant
  26
  27     def update_tenant(self, id, **kwds):
  28         return self.shell.keystone.tenants.update(self.id, **kwds)
  29
  30     def delete_tenant(self, id):
  31         tenant = self.shell.keystone.tenants.find(id=id)
  32         return self.shell.keystone.tenants.delete(tenant)
  33
  34     def create_router(self, name):
  35         router = self.shell.quantum.create_router(name=name)
  36         # TODO: add router to external network
  37         return router
  38
  39     def delete_router(self, name):
  40         return self.shell.quantum.delete_router(name=name)
  41
  42     def create_network(self, name):
  43         return self.shell.quantum.create_network(name=name, admin_state_up=True)
  44
  45     def delete_network(self, name):
  46         nets = self.shell.quantum.list_networks(name=name)
  47         for net in nets:
  48             # delete all subnets:
  49             #subnets = self.api.client_shell.quantum.list_subnets(network_id=net['network_id'])['subnets']
  50             for subnet_id in net['subnets']:
  51                 self.delete_subnet(subnet_id)
  52             self.shell.quantum.delete_network(net['id'])
  53
  54     def create_subnet(self, network_name, cidr_ip, ip_version, start, end):
  55         nets = self.shell.quantum.list_networks(name=network_name)
  56         if not nets:
  57             raise Exception, "No such network: %s" % network_name
  58         nets = nets[0]
  59
  60         subnets = self.shell.quantum.list_subnets(name=self.name)
  61         allocation_pools = [{'start': start, 'end': end}]
  62         subnet = self.shell.quantum.create_subnet(network_id=net['id'],
  63                                                 ip_version=ip_version,
  64                                                 cidr=cidr_ip,
  65                                                 dns_nameservers=['8.8.8.8'],
  66                                                 allocation_pools=allocation_pools)
  67
  68         # TODO: Add route to external network
  69         # e.g. #  route add -net 10.0.3.0/24 dev br-ex gw 10.100.0.5
  70         return subnet
  71
  72     def delete_subnet(self, id):
  73         return self.client.quantum.delete_subnet(id=id)
  74
  75
  76     def create_keypair(self, name, key):
  77         keys = self.client.nova.keypairs.findall(name=name)
  78         if keys:
  79             raise Exception, "Key name already exists: %s" % name
  80         return self.client.nova.keypairs.create(name=name, public_key=key)
  81
  82     def delete_keypair(self, name):
  83         keys = self.client.nova.keypairs.findall(name=name)
  84         for key in keys:
  85             self.client.nova.keypairs.delete(key)
  86
  87     def spawn_instance(self, name, key_name=None, hostname=None, flavor=None, image=None, security_group=None, pubkeys=[]):
  88         if not flavor:
  89             flavor = self.config.nova_default_flavor
  90         if not image:
  91             image = self.config.nova_default_imave
  92         if not security_group:
  93             security_group = self.config.nova_default_security_group
  94
  95         authorized_keys = "\n".join(pubkeys)
  96         files = {'/root/.ssh/authorized_keys': authorized_keys}
  97
  98         flavor_id = self.shell.nova.flavors.find(name=flavor)
  99         images = self.shell.glance.get_images(name=image)
 100         if not images:
 101             raise Exception, "Image not found: " + image
 102         image_id = images[0]['id']
 103         hints = {}
 104         if hostname:
 105             hints['force_hosts']= hostname
 106         server = self.shell.nova.servers.create(
 107                                             name=name,
 108                                             key_name = key_name,
 109                                             flavor=flavor_id,
 110                                             image=image_id,
 111                                             security_group = security_group,
 112                                             files=files,
 113                                             scheduler_hints=hints)
 114         return server
 115
 116     def destroy_instance(self, name, id=None):
 117         args = {'name': name}
 118         if id:
 119             args['id'] = id
 120         servers = self.shell.nova.servers.findall(**args)
 121         for server in servers:
 122             if name == server.name:
 123                 if not id or id == server.id:
 124                     self.shell.nova.servers.delete(server)