planetstack/openstack/driver.py

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