planetstack/openstack/driver.py

   1 import commands
   2 import hashlib
   3 from planetstack.config import Config
   4 from core.models import Deployment
   5
   6 try:
   7     from openstack.client import OpenStackClient
   8     has_openstack = True
   9 except:
  10     has_openstack = False
  11
  12 manager_enabled = Config().api_nova_enabled
  13
  14 class OpenStackDriver:
  15
  16     def __init__(self, config = None, client=None):
  17         if config:
  18             self.config = Config(config)
  19         else:
  20             self.config = Config()
  21
  22         if client:
  23             self.shell = client
  24
  25         self.enabled = manager_enabled
  26         self.has_openstack = has_openstack
  27         self.deployment = None
  28         self.admin_user = None
  29
  30     def client_driver(self, caller=None, tenant=None, deployment=None):
  31         admin_driver = self.admin_driver(tenant=tenant, deployment=deployment)
  32         if caller:
  33             auth = {'username': caller.email,
  34                     'password': hashlib.md5(caller.password).hexdigest()[:6],
  35                     'tenant': tenant}
  36             client = OpenStackClient(deployment=admin_driver.deployment, **auth)
  37         else:
  38             client = OpenStackClient(tenant=tenant, deployment=admin_driver.deployment)
  39
  40         driver = OpenStackDriver(client=client)
  41         driver.admin_user = admin_driver.admin_user
  42         driver.deployment = admin_driver.deployment
  43         return driver
  44
  45     def admin_driver(self, tenant=None, deployment=None):
  46         deployment = Deployment.objects.get(name=deployment)
  47         client = OpenStackClient(tenant=tenant, deployment=deployment)
  48         driver = OpenStackDriver(client=client)
  49         driver.admin_user = client.keystone.users.find(name=deployment.admin_user)
  50         driver.deployment = deployment
  51         return driver
  52
  53     def create_role(self, name):
  54         roles = self.shell.keystone.roles.findall(name=name)
  55         roles_title = self.shell.keystone.roles.findall(name=name.title())
  56         roles_found = roles + roles_title
  57         if not roles_found:
  58             role = self.shell.keystone.roles.create(name)
  59         else:
  60             role = roles_found[0]
  61         return role
  62
  63     def delete_role(self, filter):
  64         roles = self.shell.keystone.roles.findall(**filter)
  65         for role in roles:
  66             self.shell.keystone.roles.delete(role)
  67         return 1
  68
  69     def create_tenant(self, tenant_name, enabled, description):
  70         """Create keystone tenant. Suggested fields: name, description, enabled"""
  71         tenants = self.shell.keystone.tenants.findall(name=tenant_name)
  72         if not tenants:
  73             fields = {'tenant_name': tenant_name, 'enabled': enabled,
  74                       'description': description}
  75             tenant = self.shell.keystone.tenants.create(**fields)
  76         else:
  77             tenant = tenants[0]
  78
  79         # always give the admin user the admin role to any tenant created
  80         # by the driver.
  81         self.add_user_role(self.admin_user.id, tenant.id, 'admin')
  82         return tenant
  83
  84     def update_tenant(self, id, **kwds):
  85         return self.shell.keystone.tenants.update(id, **kwds)
  86
  87     def delete_tenant(self, id):
  88         ctx = self.shell.nova_db.ctx
  89         tenants = self.shell.keystone.tenants.findall(id=id)
  90         for tenant in tenants:
  91             # nova does not automatically delete the tenant's instances
  92             # so we manually delete instances before deleteing the tenant
  93             instances = self.shell.nova_db.instance_get_all_by_filters(ctx,
  94                        {'project_id': tenant.id}, 'id', 'asc')
  95             client = OpenStackClient(tenant=tenant.name)
  96             driver = OpenStackDriver(client=client)
  97             for instance in instances:
  98                 driver.destroy_instance(instance.id)
  99             self.shell.keystone.tenants.delete(tenant)
 100         return 1
 101
 102     def create_user(self, name, email, password, enabled):
 103         users = self.shell.keystone.users.findall(email=email)
 104         if not users:
 105             fields = {'name': name, 'email': email, 'password': password,
 106                       'enabled': enabled}
 107             user = self.shell.keystone.users.create(**fields)
 108         else:
 109             user = users[0]
 110         return user
 111
 112     def delete_user(self, id):
 113         users = self.shell.keystone.users.findall(id=id)
 114         for user in users:
 115             # delete users keys
 116             keys = self.shell.nova.keypairs.findall()
 117             for key in keys:
 118                 self.shell.nova.keypairs.delete(key)
 119             self.shell.keystone.users.delete(user)
 120         return 1
 121
 122     def get_admin_role(self):
 123         role = None
 124         for admin_role_name in ['admin', 'Admin']:
 125             roles = self.shell.keystone.roles.findall(name=admin_role_name)
 126             if roles:
 127                 role = roles[0]
 128                 break
 129         return role
 130
 131     def add_user_role(self, kuser_id, tenant_id, role_name):
 132         user = self.shell.keystone.users.find(id=kuser_id)
 133         tenant = self.shell.keystone.tenants.find(id=tenant_id)
 134         # admin role can be lowercase or title. Look for both
 135         role = None
 136         if role_name.lower() == 'admin':
 137             role = self.get_admin_role()
 138         else:
 139             # look up non admin role or force exception when admin role isnt found
 140             role = self.shell.keystone.roles.find(name=role_name)
 141
 142         role_found = False
 143         user_roles = user.list_roles(tenant.id)
 144         for user_role in user_roles:
 145             if user_role.name == role.name:
 146                 role_found = True
 147         if not role_found:
 148             tenant.add_user(user, role)
 149
 150         return 1
 151
 152     def delete_user_role(self, kuser_id, tenant_id, role_name):
 153         user = self.shell.keystone.users.find(id=kuser_id)
 154         tenant = self.shell.keystone.tenants.find(id=tenant_id)
 155         # admin role can be lowercase or title. Look for both
 156         role = None
 157         if role_name.lower() == 'admin':
 158             role = self.get_admin_role()
 159         else:
 160             # look up non admin role or force exception when admin role isnt found
 161             role = self.shell.keystone.roles.find(name=role_name)
 162
 163         role_found = False
 164         user_roles = user.list_roles(tenant.id)
 165         for user_role in user_roles:
 166             if user_role.name == role.name:
 167                 role_found = True
 168         if role_found:
 169             tenant.remove_user(user, role)
 170
 171         return 1
 172
 173     def update_user(self, id, fields):
 174         if 'password' in fields:
 175             self.shell.keystone.users.update_password(id, fields['password'])
 176         if 'enabled' in fields:
 177             self.shell.keystone.users.update_enabled(id, fields['enabled'])
 178         return 1
 179
 180     def create_router(self, name, set_gateway=True):
 181         routers = self.shell.quantum.list_routers(name=name)['routers']
 182         if routers:
 183             router = routers[0]
 184         else:
 185             router = self.shell.quantum.create_router({'router': {'name': name}})['router']
 186         # add router to external network
 187         if set_gateway:
 188             nets = self.shell.quantum.list_networks()['networks']
 189             for net in nets:
 190                 if net['router:external'] == True:
 191                     self.shell.quantum.add_gateway_router(router['id'],
 192                                                           {'network_id': net['id']})
 193
 194         return router
 195
 196     def delete_router(self, id):
 197         routers = self.shell.quantum.list_routers(id=id)['routers']
 198         for router in routers:
 199             self.shell.quantum.delete_router(router['id'])
 200             # remove router form external network
 201             #nets = self.shell.quantum.list_networks()['networks']
 202             #for net in nets:
 203             #    if net['router:external'] == True:
 204             #        self.shell.quantum.remove_gateway_router(router['id'])
 205
 206     def add_router_interface(self, router_id, subnet_id):
 207         router = self.shell.quantum.show_router(router_id)['router']
 208         subnet = self.shell.quantum.show_subnet(subnet_id)['subnet']
 209         if router and subnet:
 210             self.shell.quantum.add_interface_router(router_id, {'subnet_id': subnet_id})
 211
 212     def delete_router_interface(self, router_id, subnet_id):
 213         router = self.shell.quantum.show_router(router_id)
 214         subnet = self.shell.quantum.show_subnet(subnet_id)
 215         if router and subnet:
 216             self.shell.quantum.remove_interface_router(router_id, {'subnet_id': subnet_id})
 217
 218     def create_network(self, name, shared=False):
 219         nets = self.shell.quantum.list_networks(name=name)['networks']
 220         if nets:
 221             net = nets[0]
 222         else:
 223             net = self.shell.quantum.create_network({'network': {'name': name, 'shared': shared}})['network']
 224         return net
 225
 226     def delete_network(self, id):
 227         nets = self.shell.quantum.list_networks()['networks']
 228         for net in nets:
 229             if net['id'] == id:
 230                 # delete_all ports
 231                 self.delete_network_ports(net['id'])
 232                 # delete all subnets:
 233                 for subnet_id in net['subnets']:
 234                     self.delete_subnet(subnet_id)
 235                 self.shell.quantum.delete_network(net['id'])
 236         return 1
 237
 238     def delete_network_ports(self, network_id):
 239         ports = self.shell.quantum.list_ports()['ports']
 240         for port in ports:
 241             if port['network_id'] == network_id:
 242                 self.shell.quantum.delete_port(port['id'])
 243         return 1
 244
 245     def delete_subnet_ports(self, subnet_id):
 246         ports = self.shell.quantum.list_ports()['ports']
 247         for port in ports:
 248             delete = False
 249             for fixed_ip in port['fixed_ips']:
 250                 if fixed_ip['subnet_id'] == subnet_id:
 251                     delete=True
 252                     break
 253             if delete:
 254                 self.shell.quantum.delete_port(port['id'])
 255         return 1
 256
 257     def create_subnet(self, name, network_id, cidr_ip, ip_version, start, end):
 258         #nets = self.shell.quantum.list_networks(name=network_name)['networks']
 259         #if not nets:
 260         #    raise Exception, "No such network: %s" % network_name
 261         #net = nets[0]
 262
 263         subnet = None
 264         subnets = self.shell.quantum.list_subnets()['subnets']
 265         for snet in subnets:
 266             if snet['cidr'] == cidr_ip and snet['network_id'] == network_id:
 267                 subnet = snet
 268
 269         if not subnet:
 270             # HACK: Add metadata route -- Neutron does not reliably supply this
 271             metadata_ip = cidr_ip.replace("0/24", "3")
 272
 273             allocation_pools = [{'start': start, 'end': end}]
 274             subnet = {'subnet': {'name': name,
 275                                  'network_id': network_id,
 276                                  'ip_version': ip_version,
 277                                  'cidr': cidr_ip,
 278                                  #'dns_nameservers': ['8.8.8.8', '8.8.4.4'],
 279                                  'host_routes': [{'destination':'169.254.169.254/32','nexthop':metadata_ip}],
 280                                  'gateway_ip': None,
 281                                  'allocation_pools': allocation_pools}}
 282             subnet = self.shell.quantum.create_subnet(subnet)['subnet']
 283             # self.add_external_route(subnet)
 284
 285         return subnet
 286
 287     def update_subnet(self, id, fields):
 288         return self.shell.quantum.update_subnet(id, fields)
 289
 290     def delete_subnet(self, id):
 291         #return self.shell.quantum.delete_subnet(id=id)
 292         # inefficient but fault tolerant
 293         subnets = self.shell.quantum.list_subnets()['subnets']
 294         for subnet in subnets:
 295             if subnet['id'] == id:
 296                 self.delete_subnet_ports(subnet['id'])
 297                 self.shell.quantum.delete_subnet(id)
 298                 self.delete_external_route(subnet)
 299         return 1
 300
 301     def get_external_routes(self):
 302         status, output = commands.getstatusoutput('route')
 303         routes = output.split('\n')[3:]
 304         return routes
 305
 306     def add_external_route(self, subnet, routes=[]):
 307         if not routes:
 308             routes = self.get_external_routes()
 309
 310         ports = self.shell.quantum.list_ports()['ports']
 311
 312         gw_ip = subnet['gateway_ip']
 313         subnet_id = subnet['id']
 314
 315         # 1. Find the port associated with the subnet's gateway
 316         # 2. Find the router associated with that port
 317         # 3. Find the port associated with this router and on the external net
 318         # 4. Set up route to the subnet through the port from step 3
 319         ip_address = None
 320         for port in ports:
 321             for fixed_ip in port['fixed_ips']:
 322                 if fixed_ip['subnet_id'] == subnet_id and fixed_ip['ip_address'] == gw_ip:
 323                     gw_port = port
 324                     router_id = gw_port['device_id']
 325                     router = self.shell.quantum.show_router(router_id)['router']
 326                     if router and router.get('external_gateway_info'):
 327                         ext_net = router['external_gateway_info']['network_id']
 328                         for port in ports:
 329                             if port['device_id'] == router_id and port['network_id'] == ext_net:
 330                                 ip_address = port['fixed_ips'][0]['ip_address']
 331
 332         if ip_address:
 333             # check if external route already exists
 334             route_exists = False
 335             if routes:
 336                 for route in routes:
 337                     if subnet['cidr'] in route and ip_address in route:
 338                         route_exists = True
 339             if not route_exists:
 340                 cmd = "route add -net %s dev br-ex gw %s" % (subnet['cidr'], ip_address)
 341                 s, o = commands.getstatusoutput(cmd)
 342                 #print cmd, "\n", s, o
 343
 344         return 1
 345
 346     def delete_external_route(self, subnet):
 347         ports = self.shell.quantum.list_ports()['ports']
 348
 349         gw_ip = subnet['gateway_ip']
 350         subnet_id = subnet['id']
 351
 352         # 1. Find the port associated with the subnet's gateway
 353         # 2. Find the router associated with that port
 354         # 3. Find the port associated with this router and on the external net
 355         # 4. Set up route to the subnet through the port from step 3
 356         ip_address = None
 357         for port in ports:
 358             for fixed_ip in port['fixed_ips']:
 359                 if fixed_ip['subnet_id'] == subnet_id and fixed_ip['ip_address'] == gw_ip:
 360                     gw_port = port
 361                     router_id = gw_port['device_id']
 362                     router = self.shell.quantum.show_router(router_id)['router']
 363                     ext_net = router['external_gateway_info']['network_id']
 364                     for port in ports:
 365                         if port['device_id'] == router_id and port['network_id'] == ext_net:
 366                             ip_address = port['fixed_ips'][0]['ip_address']
 367
 368         if ip_address:
 369             cmd = "route delete -net %s" % (subnet['cidr'])
 370             commands.getstatusoutput(cmd)
 371
 372         return 1
 373
 374     def create_keypair(self, name, public_key):
 375         keys = self.shell.nova.keypairs.findall(name=name)
 376         if keys:
 377             key = keys[0]
 378             # update key
 379             if key.public_key != public_key:
 380                 self.delete_keypair(key.id)
 381                 key = self.shell.nova.keypairs.create(name=name, public_key=public_key)
 382         else:
 383             key = self.shell.nova.keypairs.create(name=name, public_key=public_key)
 384         return key
 385
 386     def delete_keypair(self, id):
 387         keys = self.shell.nova.keypairs.findall(id=id)
 388         for key in keys:
 389             self.shell.nova.keypairs.delete(key)
 390         return 1
 391
 392     def get_private_networks(self, tenant=None):
 393         if not tenant:
 394             tenant = self.shell.nova.tenant
 395         tenant = self.shell.keystone.tenants.find(name=tenant)
 396         search_opts = {"tenant_id": tenant.id, "shared": False}
 397         private_networks = self.shell.quantum.list_networks(**search_opts)
 398         return private_networks
 399
 400     def get_shared_networks(self):
 401         search_opts = {"shared": True}
 402         shared_networks = self.shell.quantum.list_networks(**search_opts)
 403         return shared_networks
 404
 405     def get_network_subnet(self, network_id):
 406         subnet_id = None
 407         subnet = None
 408         if network_id:
 409             os_networks = self.shell.quantum.list_networks(id=network_id)["networks"]
 410             if os_networks:
 411                 os_network = os_networks[0]
 412                 if os_network['subnets']:
 413                     subnet_id = os_network['subnets'][0]
 414                     os_subnets = self.shell.quantum.list_subnets(id=subnet_id)['subnets']
 415                     if os_subnets:
 416                         subnet = os_subnets[0]['cidr']
 417
 418         return (subnet_id, subnet)
 419
 420     def spawn_instance(self, name, key_name=None, availability_zone=None, hostname=None, image_id=None, security_group=None, pubkeys=[], nics=None, metadata=None, userdata=None, flavor_name=None):
 421         if not flavor_name:
 422             flavor_name = self.config.nova_default_flavor
 423
 424         flavor = self.shell.nova.flavors.find(name=flavor_name)
 425
 426         if not security_group:
 427             security_group = self.config.nova_default_security_group
 428
 429         files = {}
 430         #if pubkeys:
 431         #    files["/root/.ssh/authorized_keys"] = "\n".join(pubkeys).encode('base64')
 432         hints = {}
 433
 434         # determine availability zone and compute host
 435         availability_zone_filter = None
 436         if not availability_zone:
 437             availability_zone_filter = 'nova'
 438         else:
 439             availability_zone_filter = availability_zone
 440         if hostname:
 441             availability_zone_filter += ':%s' % hostname.split('.')[0]
 442
 443         server = self.shell.nova.servers.create(
 444                                             name=name,
 445                                             key_name = key_name,
 446                                             flavor=flavor.id,
 447                                             image=image_id,
 448                                             security_group = security_group,
 449                                             #files = files,
 450                                             scheduler_hints=hints,
 451                                             availability_zone=availability_zone_filter,
 452                                             nics=nics,
 453                                             networks=nics,
 454                                             meta=metadata,
 455                                             userdata=userdata)
 456         return server
 457
 458     def destroy_instance(self, id):
 459         if (self.shell.nova.tenant=="admin"):
 460             # findall() is implemented as a list() followed by a python search of the
 461             # list. Since findall() doesn't accept "all_tenants", we do this using
 462             # list() ourselves. This allows us to delete an instance as admin.
 463             servers = self.shell.nova.servers.list(search_opts={"all_tenants": True})
 464         else:
 465             servers = self.shell.nova.servers.list()
 466         for server in servers:
 467             if server.id == id:
 468                 result=self.shell.nova.servers.delete(server)
 469
 470     def update_instance_metadata(self, id, metadata):
 471         servers = self.shell.nova.servers.findall(id=id)
 472         for server in servers:
 473             self.shell.nova.servers.set_meta(server, metadata)
 474             # note: set_meta() returns a broken Server() object. Don't try to
 475             # print it in the shell or it will fail in __repr__.
 476
 477     def delete_instance_metadata(self, id, metadata):
 478         # note: metadata is a dict. Only the keys matter, not the values.
 479         servers = self.shell.nova.servers.findall(id=id)
 480         for server in servers:
 481             self.shell.nova.servers.delete_meta(server, metadata)
 482