provisioner.py 21.5 KB
Newer Older
1 2 3
from __future__ import (absolute_import, division,
                        print_function, unicode_literals)
import logging
4
import re
efikalti's avatar
efikalti committed
5
import argparse
6

7 8 9 10
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

from kamaki.clients import astakos, cyclades
11 12 13
from kamaki.clients import ClientError
from kamaki.clients.utils import https
from kamaki.cli.config import Config as KamakiConfig
efikalti's avatar
efikalti committed
14
from kamaki import defaults
efikalti's avatar
efikalti committed
15
from fokia.cluster_error_constants import *
16 17
from Crypto.PublicKey import RSA
from base64 import b64encode
18

efikalti's avatar
efikalti committed
19
if not defaults.CACERTS_DEFAULT_PATH:
20
    from ssl import get_default_verify_paths
21
    CA_CERTS_PATH = get_default_verify_paths().cafile or get_default_verify_paths().openssl_cafile
22 23
    if not CA_CERTS_PATH:
        raise
efikalti's avatar
efikalti committed
24
    https.patch_with_certs(CA_CERTS_PATH)
25

26

27
storage_templates = ['drdb', 'ext_vlmc']
28 29 30 31


class Provisioner:
    """
32
        provisions virtual machines on ~okeanos
33 34
    """

35
    def __init__(self, cloud_name):
36 37

        # Load .kamakirc configuration
38
        logger.info("Retrieving .kamakirc configuration")
39
        self.config = KamakiConfig()
40 41 42 43 44
        cloud_section = self.config._sections['cloud'].get(cloud_name)
        if not cloud_section:
            message = "Cloud '%s' was not found in you .kamakirc configuration file. " \
                      "Currently you have availablie in your configuration these clouds: %s"
            raise KeyError(message % (cloud_name, self.config._sections['cloud'].keys()))
45 46 47 48

        # Get the authentication url and token
        auth_url, auth_token = cloud_section['url'], cloud_section['token']

49
        logger.info("Initiating Astakos Client")
50 51
        self.astakos = astakos.AstakosClient(auth_url, auth_token)

52 53
        logger.info("Retrieving cyclades endpoint url")
        compute_url = self.astakos.get_endpoint_url(
54
            cyclades.CycladesComputeClient.service_type)
55 56
        logger.info("Initiating Cyclades client")
        self.cyclades = cyclades.CycladesComputeClient(compute_url, auth_token)
57

58 59 60 61 62 63 64 65 66
        # Create the network client
        networkURL = self.astakos.get_endpoint_url(
            cyclades.CycladesNetworkClient.service_type)
        self.network_client = cyclades.CycladesNetworkClient(networkURL, auth_token)

        # Constants
        self.Bytes_to_GB = 1024*1024*1024
        self.Bytes_to_MB = 1024*1024

67 68 69 70
        self.master = None
        self.ips = None
        self.slaves = None
        self.vpn = None
efikalti's avatar
efikalti committed
71
        self.subnet = None
72
        self.private_key = None
73
        self.image_id = 'c6f5adce-21ad-4ce3-8591-acfe7eb73c02'
74

75
    def find_flavor(self, **kwargs):
76 77
        """

78
        :param kwargs: should contains the keys that specify the specs
79
        :return: first flavor objects that matches the specs criteria
80
        """
81 82 83 84 85

        # Set all the default parameters
        kwargs.setdefault("vcpus", 1)
        kwargs.setdefault("ram", 1024)
        kwargs.setdefault("disk", 40)
86
        logger.info("Retrieving flavor")
87
        for flavor in self.cyclades.list_flavors(detail=True):
88 89
            if all([kwargs[key] == flavor[key] \
                    for key in set(flavor.keys()).intersection(kwargs.keys())]):
90 91 92
                return flavor
        return None

93
    def find_image(self, **kwargs):
94 95 96 97 98
        """
        :param image_name: Name of the image to filter by
        :param kwargs:
        :return: first image object that matches the name criteria
        """
99
        image_name = kwargs['image_name']
100 101

        logger.info("Retrieving image")
102
        for image in self.cyclades.list_images(detail=True):
103
            if image_name in image['name']:
104 105 106 107
                return image
        return None

    def find_project_id(self, **kwargs):
108
        """
109 110 111
        :param kwargs: name, state, owner and mode to filter project by
        :return: first project_id that matches the project name
        """
112
        filter = {
113 114 115 116
            'name': kwargs.get("project_name"),
            'state': kwargs.get("project_state"),
            'owner': kwargs.get("project_owner"),
            'mode': kwargs.get("project_mode"),
117
        }
118
        logger.info("Retrieving project")
119 120
        return self.astakos.get_projects(**filter)[0]

121
    def create_vm(self, vm_name=None, image_id=None, ip=None, personality=None, **kwargs):
122 123
        """
        :param vm_name: Name of the virtual machine to create
124
        :param image_id: image id if you want another image than the default
125 126 127
        :param kwargs: passed to the functions called for detail options
        :return:
        """
128
        flavor_id = self.find_flavor(**kwargs)['id']
129 130 131 132
        # Get image
        if image_id == None:
            image_id = self.image_id
        else:
133
            image_id = self.find_image(**kwargs)['id']
134
        project_id = self.find_project_id(**kwargs)['id']
efikalti's avatar
efikalti committed
135
        networks = list()
136 137 138 139 140
        if ip != None:
            ip_obj = dict()
            ip_obj['uuid'] = ip['floating_network_id']
            ip_obj['fixed_ip'] = ip['floating_ip_address']
            networks.append(ip_obj)
efikalti's avatar
efikalti committed
141
        networks.append({'uuid': kwargs['net_id']})
142 143
        if personality == None:
            personality = []
144
        try:
145
            okeanos_response = self.cyclades.create_server(name=vm_name, flavor_id=flavor_id,
146 147
                                                           image_id=image_id,
                                                           project_id=project_id,
148
                                                           networks=networks, personality=personality)
149
        except ClientError as ex:
150 151
            raise ex
        return okeanos_response
152

153
    def create_lambda_cluster(self, vm_name, **kwargs):
154 155 156
        """
        :param vm_name: hostname of the master
        :param kwargs: contains specifications of the vms.
157
        :return: dictionary object with the nodes of the cluster if it was successfully created
158 159 160 161 162
        """
        quotas = self.get_quotas()
        vcpus = kwargs['slaves'] * kwargs['vcpus_slave'] + kwargs['vcpus_master']
        ram = kwargs['slaves'] * kwargs['ram_slave'] + kwargs['ram_master']
        disk = kwargs['slaves'] * kwargs['disk_slave'] + kwargs['disk_master']
163
        project_id = self.find_project_id(**kwargs)['id']
164 165 166 167 168 169 170 171
        response = self.check_all_resources(quotas, cluster_size=kwargs['cluster_size'],
                                              vcpus=vcpus,
                                              ram=ram,
                                              disk=disk,
                                              ip_request=kwargs['ip_request'],
                                              network_request=kwargs['network_request'],
                                              project_name=kwargs['project_name'])
        if response:
172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194
            # Get ssh keys
            key = RSA.generate(2048)
            self.private_key = key.exportKey('PEM')
            pub_key = key.publickey().exportKey('OpenSSH') + ' root'
            public = dict(contents=b64encode(pub_key),
                          path='/root/.ssh/id_rsa.pub',
                          owner='root', group='root', mode=0600)
            authorized = dict(contents=b64encode(pub_key),
                          path='/root/.ssh/authorized_keys',
                          owner='root', group='root', mode=0600)
            private = dict(contents=b64encode(self.private_key),
                          path='/root/.ssh/id_rsa',
                          owner='root', group='root', mode=0600)

            master_personality = []
            master_personality.append(authorized)
            master_personality.append(public)
            master_personality.append(private)
            slave_personality = []
            slave_personality.append(authorized)
            print(master_personality)
            print(slave_personality)

195
            # Create private network for cluster
196 197
            self.vpn = self.create_vpn('lambda-vpn', project_id=project_id)
            vpn_id = self.vpn['id']
198 199 200 201
            self.create_private_subnet(vpn_id)

            #reserve ip
            ip_request=kwargs['ip_request']
202
            self.ips = list()
efikalti's avatar
efikalti committed
203
            for i in range(ip_request):
204
                ip = self.reserve_ip(project_id=project_id)
205
                self.ips.append(ip)
206

207 208
            ip = None
            # Create master
209 210
            if len(self.ips) > 0:
                ip = self.ips[0]
211 212 213 214 215 216 217
            self.master = self.create_vm(vm_name=vm_name, ip=ip,
                                         net_id=vpn_id,
                                         vcpus=kwargs['vcpus_master'],
                                         ram=kwargs['ram_master'],
                                         disk=kwargs['disk_master'],
                                         personality=master_personality,
                                         **kwargs)
218 219

            # Create slaves
220
            self.slaves = list()
221
            for i in range(kwargs['slaves']):
222
                ip = None
efikalti's avatar
efikalti committed
223 224
                if len(self.ips) > i+1:
                    ip = self.ips[i+1]
225
                slave_name = 'lambda-node' + str(i+1)
226 227 228 229 230 231 232 233
                slave = self.create_vm(vm_name=slave_name,
                                       ip=ip,
                                       net_id=vpn_id,
                                       vcpus=kwargs['vcpus_slave'],
                                       ram=kwargs['ram_slave'],
                                       disk=kwargs['disk_slave'],
                                       personality=slave_personality,
                                       **kwargs)
234
                self.slaves.append(slave)
235

236 237 238 239 240
            # Wait for VMs to complete being built
            self.cyclades.wait_server(server_id=self.master['id'])
            for slave in self.slaves:
                self.cyclades.wait_server(slave['id'])

241 242
            # Create cluster dictionary object
            inventory = dict()
243 244
            inventory["master"] = self.master
            inventory["slaves"] = self.slaves
245 246
            return inventory

247
    def get_cluster_details(self):
248 249 250
        """
        :returns: dictionary of basic details for the cluster
        """
251 252
        details = dict()

253
        nodes = dict()
254 255 256
        master = dict()
        master['id'] = self.master['id']
        master['name'] = self.master['name']
257
        master['adminPass'] = self.master['adminPass']
258
        nodes['master'] = master
259

260
        slaves = list()
261 262 263 264 265
        for slave in self.slaves:
            slave_obj = dict()
            slave_obj['id'] = slave['id']
            slave_obj['name'] = slave['name']
            name = slave_obj['name']
266 267
            slaves.append(slave_obj)
        nodes['slaves'] = slaves
268

269
        details['nodes'] = nodes
270 271 272 273 274 275
        vpn = dict()
        vpn['id'] = self.vpn['id']
        vpn['type'] = self.vpn['type']
        details['vpn'] = vpn

        details['ips'] = self.ips
efikalti's avatar
efikalti committed
276 277 278 279 280 281
        ips_list = list()
        for ip in self.ips:
            ip_obj = dict()
            ip_obj['floating_network_id'] = ip['floating_network_id']
            ip_obj['floating_ip_address'] = ip['floating_ip_address']
            ip_obj['id'] = ip['id']
efikalti's avatar
efikalti committed
282
            ips_list.append(ip_obj)
efikalti's avatar
efikalti committed
283
        details['ips'] = ips_list
efikalti's avatar
efikalti committed
284 285 286 287 288 289

        subnet = dict()
        subnet['id'] = self.subnet['id']
        subnet['cidr'] = self.subnet['cidr']
        subnet['gateway_ip'] = self.subnet['gateway_ip']
        details['subnet'] = subnet
290 291
        return details

292 293 294 295 296
    def get_private_key(self):
        """
        :returns: Private key of master
        """
        return self.private_key
297

298
    def create_vpn(self, network_name, project_id):
299 300 301
        """
        Creates a virtual private network
        :param network_name: name of the network
302
        :return: the virtual network object
303 304 305 306 307
        """
        try:
            # Create vpn with custom type and the name given as argument
            vpn = self.network_client.create_network(
                        type=self.network_client.network_types[1],
308 309
                        name=network_name,
                        project_id=project_id)
310
            return vpn
311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327
        except ClientError as ex:
            raise ex
        return okeanos_response

    def destroy_vpn(self, id):
        """
        Destroy a virtual private network
        :param id: id of the network we want to destroy
        :return: True if successfull
        """
        try:
            self.network_client.delete_network(id)
            return True
        except ClientError as ex:
            raise ex
        return okeanos_response

328
    def reserve_ip(self,project_id):
329 330 331 332 333
        """
        Reserve ip
        :return: the ip object if successfull
        """
        try:
334
            ip = self.network_client.create_floatingip(project_id=project_id)
335 336 337 338 339
            return ip
        except ClientError as ex:
            raise ex
        return okeanos_response

340
    def create_private_subnet(self, net_id, cidr='192.168.0.0/24', gateway_ip='192.168.0.1'):
341 342 343 344 345 346 347 348 349
        """
        Creates a private subnets and connects it with this network
        :param net_id: id of the network
        :return: the id of the subnet if successfull
        """
        try:
            subnet = self.network_client.create_subnet(net_id, cidr,
                                                       gateway_ip=gateway_ip,
                                                       enable_dhcp=True)
efikalti's avatar
efikalti committed
350
            self.subnet = subnet
351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370
            return subnet['id']
        except ClientError as ex:
            raise ex
        return okeanos_response

    def connect_vm(self, vm_id, net_id):
        """
        Connects the vm with this id to the network with the net_id
        :param vm_id: id of the vm
        :param net_id: id of the network
        :return: returns True if successfull
        """
        try:
            port = self.network_client.create_port(network_id=net_id,
                                                   device_id=vm_id)
            return True
        except ClientError as ex:
            raise ex
        return okeanos_response

371
    def attach_authorized_ip(self, ip, vm_id):
372
        """
373
        Attach the authorized ip with this id to the vm
374 375 376 377 378 379 380 381 382 383 384 385 386
        :param fnet_id: id of the floating network of the ip
        :param vm_id: id of the vm
        :return: returns True if successfull
        """
        try:
            port = self.network_client.create_port(network_id=ip['floating_network_id'],
                                                   device_id=vm_id,
                                                   fixed_ips=[dict(ip_address=ip['floating_ip_address']), ])
            return True
        except ClientError as ex:
            raise ex
        return okeanos_response

387 388 389 390 391 392 393
    def get_quotas(self, **kwargs):
        """
        Get the user quotas for the defined project.
        :return: user quotas object
        """
        return self.astakos.get_quotas()

394 395 396 397 398
    def get_server_info(self, server_id):
        """
        """
        return self.cyclades.get_server_details(server_id=server_id)

399
    def get_server_authorized_ip(self, server_id):
400 401
        """
        :param server_id: id of the server
402
        :returns: the authorized ip of the server if it has one,else None
403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422
        """
        addresses =  self.get_server_info(server_id=server_id)['addresses']
        for key in list(addresses.keys()):
            ip = addresses[key][0]['addr']
            if '192.168.0' not in ip and not re.search('[a-zA-Z]', ip):
                return ip
        return None

    def get_server_private_ip(self, server_id):
        """
        :param server_id: id of the server
        :returns: the private ip of the server if it has one,else None
        """
        addresses =  self.get_server_info(server_id=server_id)['addresses']
        for key in list(addresses.keys()):
            ip = addresses[key][0]['addr']
            if '192.168.0' in ip:
                return ip
        return None

423 424 425 426 427 428 429 430 431 432
    def check_all_resources(self, quotas, **kwargs):
        """
        Checks user's quota for every requested resource.
        Returns True if everything available.
        :param **kwargs: arguments
        """
        project_id = self.find_project_id(**kwargs)['id']
        # quotas = self.get_quotas()

        # Check for VMs
efikalti's avatar
efikalti committed
433 434 435
        pending_vm = quotas[project_id]['cyclades.vm']['project_pending']
        limit_vm = quotas[project_id]['cyclades.vm']['project_limit']
        usage_vm = quotas[project_id]['cyclades.vm']['project_usage']
436 437 438 439 440 441
        available_vm = limit_vm - usage_vm - pending_vm
        if available_vm < kwargs['cluster_size']:
            msg = 'Cyclades VMs out of limit'
            raise ClientError(msg, error_quotas_cluster_size)
            return False
        # Check for CPUs
efikalti's avatar
efikalti committed
442 443 444
        pending_cpu = quotas[project_id]['cyclades.cpu']['project_pending']
        limit_cpu = quotas[project_id]['cyclades.cpu']['project_limit']
        usage_cpu = quotas[project_id]['cyclades.cpu']['project_usage']
445 446 447 448 449 450
        available_cpu = limit_cpu - usage_cpu - pending_cpu
        if available_cpu < kwargs['vcpus']:
            msg = 'Cyclades cpu out of limit'
            raise ClientError(msg, error_quotas_cpu)
            return False
        # Check for RAM
efikalti's avatar
efikalti committed
451 452 453
        pending_ram = quotas[project_id]['cyclades.ram']['project_pending']
        limit_ram = quotas[project_id]['cyclades.ram']['project_limit']
        usage_ram = quotas[project_id]['cyclades.ram']['project_usage']
454 455 456 457 458 459
        available_ram = (limit_ram - usage_ram - pending_ram) / self.Bytes_to_MB
        if available_ram < kwargs['ram']:
            msg = 'Cyclades ram out of limit'
            raise ClientError(msg, error_quotas_ram)
            return False
        # Check for Disk space
efikalti's avatar
efikalti committed
460 461 462
        pending_cd = quotas[project_id]['cyclades.ram']['project_pending']
        limit_cd = quotas[project_id]['cyclades.disk']['project_limit']
        usage_cd = quotas[project_id]['cyclades.disk']['project_usage']
463 464 465 466 467
        available_cyclades_disk_GB = (limit_cd - usage_cd - pending_cd) / self.Bytes_to_GB
        if available_cyclades_disk_GB < kwargs['disk']:
            msg = 'Cyclades disk out of limit'
            raise ClientError(msg, error_quotas_cyclades_disk)
            return False
468
        # Check for authorized IPs
469
        list_float_ips = self.network_client.list_floatingips()
efikalti's avatar
efikalti committed
470 471 472
        pending_ips = quotas[project_id]['cyclades.floating_ip']['project_pending']
        limit_ips = quotas[project_id]['cyclades.floating_ip']['project_limit']
        usage_ips = quotas[project_id]['cyclades.floating_ip']['project_usage']
473 474 475 476 477
        available_ips = limit_ips - usage_ips - pending_ips
        for d in list_float_ips:
            if d['instance_id'] is None and d['port_id'] is None:
                available_ips += 1
        if available_ips < kwargs['ip_request']:
478
            msg = 'authorized IPs out of limit'
efikalti's avatar
efikalti committed
479
            raise ClientError(msg, error_get_ip)
480 481 482 483 484 485 486 487
            return False
        # Check for networks
        pending_net = quotas[project_id]['cyclades.network.private']['project_pending']
        limit_net = quotas[project_id]['cyclades.network.private']['project_limit']
        usage_net = quotas[project_id]['cyclades.network.private']['project_usage']
        available_networks = limit_net - usage_net - pending_net
        if available_networks < kwargs['network_request']:
            msg = 'Private Network out of limit'
efikalti's avatar
efikalti committed
488
            raise ClientError(msg, error_get_network_quota)
489 490 491
            return False
        return True

492 493 494

if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="Okeanos VM provisioning")
495
    parser.add_argument('--cloud', type=str, dest="cloud", default="~okeanos")
496 497 498
    parser.add_argument('--project-name', type=str, dest="project_name",
                        default="lambda.grnet.gr")
    parser.add_argument('--name', type=str, dest='name', default="to mikro debian sto livadi")
499

500 501 502 503 504 505 506 507

    parser.add_argument('--slaves', type=int, dest='slaves', default=1)
    parser.add_argument('--vcpus_master', type=int, dest='vcpus_master', default=4)
    parser.add_argument('--vcpus_slave', type=int, dest='vcpus_slave', default=4)
    parser.add_argument('--ram_master', type=int, dest='ram_master', default=4096)  # in MB
    parser.add_argument('--ram_slave', type=int, dest='ram_slave', default=4096)  # in MB
    parser.add_argument('--disk_master', type=int, dest='disk_master', default=40)  # in GB
    parser.add_argument('--disk_slave', type=int, dest='disk_slave', default=40)  # in GB
508
    parser.add_argument('--ip_request', type=int, dest='ip_request', default=1)
509 510 511 512
    parser.add_argument('--network_request', type=int, dest='network_request', default=1)
    parser.add_argument('--image_name', type=str, dest='image_name', default="debian")
    parser.add_argument('--cluster_size', type=int, dest='cluster_size', default=2)

513
    args = parser.parse_args()
514 515

    provisioner = Provisioner(cloud_name=args.cloud)
516
    """
517 518 519
    print(provisioner.create_vm(vm_name=args.name, project_name=args.project_name,
                             image_name="debian"))
    """
520

521

522
    response = provisioner.create_lambda_cluster(vm_name="lambda-master" , slaves=args.slaves,
523 524 525 526 527 528 529 530 531 532
                                          cluster_size=args.cluster_size,
                                          vcpus_master=args.vcpus_master,
                                          vcpus_slave=args.vcpus_slave,
                                          ram_master=args.ram_master,
                                          ram_slave=args.ram_slave,
                                          disk_master=args.disk_master,
                                          disk_slave=args.disk_slave,
                                          ip_request=args.ip_request,
                                          network_request=args.network_request,
                                          project_name=args.project_name)
533
    # print(response)
efikalti's avatar
efikalti committed
534 535
    # print(provisioner.get_cluster_details())
    # print(provisioner.get_private_key())