plstackapi/openstack/driver.py

   1 from plstackapi.planetstack.config import Config
   2 from plstackapi.openstack.client import OpenStackClient
   3
   4 class OpenStackDriver:
   5
   6     def __init__(self, config = None, client=None):
   7         if config:
   8             self.config = Config(config)
   9         else:
  10             self.config = Config()
  11
  12         self.admin_client = OpenStackClient()
  13         self.admin_user = self.admin_client.keystone.users.find(name=self.admin_client.keystone.username)
  14
  15         if client:
  16             self.shell = client
  17         else:
  18             self.shell = OpenStackClient()
  19
  20     def create_role(self, name):
  21         roles = self.shell.keystone.roles.findall(name=name)
  22         if not roles:
  23             role = self.shell.keystone.roles.create(name)
  24         else:
  25             role = roles[0]
  26         return role
  27
  28     def delete_role(self, filter):
  29         roles = self.shell.keystone.roles.findall(**filter)
  30         for role in roles:
  31             self.shell.keystone.roles.delete(role)
  32         return 1
  33
  34     def create_tenant(self, tenant_name, enabled, description):
  35         """Create keystone tenant. Suggested fields: name, description, enabled"""
  36         tenants = self.shell.keystone.tenants.findall(name=tenant_name)
  37         if not tenants:
  38             fields = {'tenant_name': tenant_name, 'enabled': enabled,
  39                       'description': description}
  40             tenant = self.shell.keystone.tenants.create(**fields)
  41         else:
  42             tenant = tenants[0]
  43
  44         # always give the admin user the admin role to any tenant created
  45         # by the driver.
  46         self.add_user_role(self.admin_user.id, tenant.id, 'admin')
  47         return tenant
  48
  49     def update_tenant(self, id, **kwds):
  50         return self.shell.keystone.tenants.update(id, **kwds)
  51
  52     def delete_tenant(self, id):
  53         tenants = self.shell.keystone.tenants.findall(id=id)
  54         for tenant in tenants:
  55             self.shell.keystone.tenants.delete(tenant)
  56         return 1
  57
  58     def create_user(self, name, email, password, enabled):
  59         users = self.shell.keystone.users.findall(email=email)
  60         if not users:
  61             fields = {'name': name, 'email': email, 'password': password,
  62                       'enabled': enabled}
  63             user = self.shell.keystone.users.create(**fields)
  64         else:
  65             user = users[0]
  66         return user
  67
  68     def delete_user(self, id):
  69         users = self.shell.keystone.users.findall(id=id)
  70         for user in users:
  71             self.shell.keystone.users.delete(user)
  72         return 1
  73
  74     def add_user_role(self, user_id, tenant_id, role_name):
  75         user = self.shell.keystone.users.find(id=user_id)
  76         tenant = self.shell.keystone.tenants.find(id=tenant_id)
  77         role = self.shell.keystone.roles.find(name=role_name)
  78
  79         role_found = False
  80         user_roles = user.list_roles(tenant.id)
  81         for user_role in user_roles:
  82             if user_role.name == role.name:
  83                 role_found = True
  84         if not role_found:
  85             tenant.add_user(user, role)
  86
  87         return 1
  88
  89     def delete_user_role(self, user_id, tenant_id, role_name):
  90         user = self.shell.keystone.users.find(id=user_id)
  91         tenant = self.shell.keystone.tenants.find(id=tenant_id)
  92         role = self.shell.keystone.roles.find(name=role_name)
  93
  94         role_found = False
  95         user_roles = user.list_roles(tenant.id)
  96         for user_role in user_roles:
  97             if user_role.name == role.name:
  98                 role_found = True
  99         if role_found:
 100             tenant.remove_user(user, role)
 101
 102         return 1
 103
 104     def update_user(self, id, **kwds):
 105         return self.shell.keystone.users.update(id, **kwds)
 106
 107     def create_router(self, name, set_gateway=True):
 108         routers = self.shell.quantum.list_routers(name=name)['routers']
 109         if routers:
 110             router = routers[0]
 111         else:
 112             router = self.shell.quantum.create_router({'router': {'name': name}})['router']
 113         # add router to external network
 114         if set_gateway:
 115             nets = self.shell.quantum.list_networks()['networks']
 116             for net in nets:
 117                 if net['router:external'] == True:
 118                     self.shell.quantum.add_gateway_router(router['id'],
 119                                                           {'network_id': net['id']})
 120
 121         return router
 122
 123     def delete_router(self, id):
 124         routers = self.shell.quantum.list_routers(id=id)['routers']
 125         for router in routers:
 126             self.shell.quantum.delete_router(router['id'])
 127             # remove router form external network
 128             #nets = self.shell.quantum.list_networks()['networks']
 129             #for net in nets:
 130             #    if net['router:external'] == True:
 131             #        self.shell.quantum.remove_gateway_router(router['id'])
 132
 133     def add_router_interface(self, router_id, subnet_id):
 134         router = self.shell.quantum.show_router(router_id)['router']
 135         subnet = self.shell.quantum.show_subnet(subnet_id)['subnet']
 136         if router and subnet:
 137             self.shell.quantum.add_interface_router(router_id, {'subnet_id': subnet_id})
 138
 139     def delete_router_interface(self, router_id, subnet_id):
 140         router = self.shell.quantum.show_router(router_id)
 141         subnet = self.shell.quantum.show_subnet(subnet_id)
 142         if router and subnet:
 143             self.shell.quantum.remove_interface_router(router_id, {'subnet_id': subnet_id})
 144
 145     def create_network(self, name):
 146         nets = self.shell.quantum.list_networks(name=name)['networks']
 147         if nets:
 148             net = nets[0]
 149         else:
 150             net = self.shell.quantum.create_network({'network': {'name': name}})['network']
 151         return net
 152
 153     def delete_network(self, id):
 154         nets = self.shell.quantum.list_networks()['networks']
 155         for net in nets:
 156             if net['id'] == id:
 157                 # delete_all ports
 158                 self.delete_network_ports(net['id'])
 159                 # delete all subnets:
 160                 for subnet_id in net['subnets']:
 161                     self.delete_subnet(subnet_id)
 162                 self.shell.quantum.delete_network(net['id'])
 163         return 1
 164
 165     def delete_network_ports(self, network_id):
 166         ports = self.shell.quantum.list_ports()['ports']
 167         for port in ports:
 168             if port['network_id'] == network_id:
 169                 self.shell.quantum.delete_port(port['id'])
 170         return 1
 171
 172     def delete_subnet_ports(self, subnet_id):
 173         ports = self.shell.quantum.list_ports()['ports']
 174         for port in ports:
 175             delete = False
 176             for fixed_ip in port['fixed_ips']:
 177                 if fixed_ip['subnet_id'] == subnet_id:
 178                     delete=True
 179                     break
 180             if delete:
 181                 self.shell.quantum.delete_port(port['id'])
 182         return 1
 183
 184     def create_subnet(self, name, network_id, cidr_ip, ip_version, start, end):
 185         #nets = self.shell.quantum.list_networks(name=network_name)['networks']
 186         #if not nets:
 187         #    raise Exception, "No such network: %s" % network_name
 188         #net = nets[0]
 189
 190         subnet = None
 191         subnets = self.shell.quantum.list_subnets()['subnets']
 192         for snet in subnets:
 193             if snet['cidr'] == cidr_ip and snet['network_id'] == network_id:
 194                 subnet = snet
 195
 196         if not subnet:
 197             allocation_pools = [{'start': start, 'end': end}]
 198             subnet = {'subnet': {'name': name,
 199                                  'network_id': network_id,
 200                                  'ip_version': ip_version,
 201                                  'cidr': cidr_ip,
 202                                  'dns_nameservers': ['8.8.8.8', '8.8.8.4'],
 203                                  'allocation_pools': allocation_pools}}
 204             subnet = self.shell.quantum.create_subnet(subnet)['subnet']
 205
 206         # TODO: Add route to external network
 207         # e.g. #  route add -net 10.0.3.0/24 dev br-ex gw 10.100.0.5
 208         return subnet
 209
 210     def update_subnet(self, id, fields):
 211         return self.shell.quantum.update_subnet(id, fields)
 212
 213     def delete_subnet(self, id):
 214         #return self.shell.quantum.delete_subnet(id=id)
 215         # inefficient but fault tolerant
 216         subnets = self.shell.quantum.list_subnets()['subnets']
 217         for subnet in subnets:
 218             if subnet['id'] == id:
 219                 self.delete_subnet_ports(subnet['id'])
 220                 self.shell.quantum.delete_subnet(id)
 221         return
 222
 223     def create_keypair(self, name, key):
 224         keys = self.shell.nova.keypairs.findall(name=name)
 225         if keys:
 226             key = keys[0]
 227         else:
 228             key = self.shell.nova.keypairs.create(name=name, public_key=key)
 229         return key
 230
 231     def delete_keypair(self, id):
 232         keys = self.shell.nova.keypairs.findall(id=id)
 233         for key in keys:
 234             self.shell.nova.keypairs.delete(key)
 235         return 1
 236
 237     def spawn_instance(self, name, key_name=None, hostname=None, image_id=None, security_group=None, pubkeys=[]):
 238         flavor_name = self.config.nova_default_flavor
 239         flavor = self.shell.nova.flavors.find(name=flavor_name)
 240         #if not image:
 241         #    image = self.config.nova_default_imave
 242         if not security_group:
 243             security_group = self.config.nova_default_security_group
 244
 245         authorized_keys = "\n".join(pubkeys)
 246         files = {'/root/.ssh/authorized_keys': authorized_keys}
 247
 248         hints = {}
 249         availability_zone = None
 250         if hostname:
 251             availability_zone = 'nova:%s' % hostname
 252         server = self.shell.nova.servers.create(
 253                                             name=name,
 254                                             key_name = key_name,
 255                                             flavor=flavor.id,
 256                                             image=image_id,
 257                                             security_group = security_group,
 258                                             files=files,
 259                                             scheduler_hints=hints,
 260                                             availability_zone=availability_zone)
 261         return server
 262
 263     def destroy_instance(self, id):
 264         servers = self.shell.nova.servers.findall(id=id)
 265         for server in servers:
 266             self.shell.nova.servers.delete(server)