예제 #1
0
    def _create_instance(self):
        inst = Instance()
        inst.address = '127.0.0.1'
        inst.port = 27017
        inst.is_active = True
        inst.databaseinfra = physical_factory.DatabaseInfraFactory.create(
            plan=self.plan
        )
        inst.status = 1
        inst.instance_type = 2
        inst.total_size_in_bytes = 100
        inst.used_size_in_bytes = 50
        #TODO: Fix that vm_name. See better way to set vm_name not on instance directly
        inst.vm_name = inst.dns

        return inst
def get_instances_for(infra, topology_path):
    instances = []
    group_instances = get_deploy_instances(topology_path)
    for count, group in enumerate(group_instances):
        for instance_type in group:
            instance_name = get_vm_name(infra.name_prefix, infra.name_stamp,
                                        count + 1)

            try:
                instance = infra.instances.get(
                    Q(hostname__hostname__startswith=instance_name)
                    | Q(dns__startswith=instance_name),
                    port=instance_type.port,
                )
            except Instance.DoesNotExist:
                instance = Instance()
                instance.dns = instance_name
                instance.databaseinfra = infra

                instance.port = instance_type.port
                instance.instance_type = instance_type.instance_type

            instance.vm_name = instance.dns
            instances.append(instance)

    return instances
예제 #3
0
def add_instances_to_database(self,
                              database,
                              user,
                              task,
                              number_of_instances=1):
    from workflow.workflow import steps_for_instances_with_rollback
    from util.providers import get_add_database_instances_steps
    from util import get_vm_name

    worker_name = get_worker_name()
    task = TaskHistory.register(self.request, user, task, worker_name)

    infra = database.infra
    plan = infra.plan
    driver = infra.get_driver()

    class_path = plan.replication_topology.class_path
    steps = get_add_database_instances_steps(class_path)

    instances = []
    last_vm_created = infra.last_vm_created

    for i in range(number_of_instances):
        last_vm_created += 1
        vm_name = get_vm_name(prefix=infra.name_prefix,
                              sufix=infra.name_stamp,
                              vm_number=last_vm_created)
        new_instance = Instance(databaseinfra=infra,
                                dns=vm_name,
                                port=driver.get_default_database_port())
        new_instance.vm_name = vm_name
        instances.append(new_instance)

    success = steps_for_instances_with_rollback(
        steps,
        instances,
        task,
    )

    if success:
        task.update_status_for(TaskHistory.STATUS_SUCCESS, 'Done')
    else:
        task.update_status_for(TaskHistory.STATUS_ERROR, 'Done')
def get_instances_for(infra, topology_path):
    instances = []
    number_of_vms = get_deploy_instances_size(topology_path)
    for i in range(number_of_vms):
        instance_name = get_vm_name(infra.name_prefix, infra.name_stamp, i + 1)

        try:
            instance = infra.instances.get(
                Q(hostname__hostname__startswith=instance_name) |
                Q(dns__startswith=instance_name)
            )
        except Instance.DoesNotExist:
            instance = Instance()
            instance.dns = instance_name
            instance.databaseinfra = infra

            driver = infra.get_driver()
            instance.port = driver.get_default_database_port()
            instance.instance_type = driver.get_default_instance_type()

        instance.vm_name = instance.dns
        instances.append(instance)

    return instances
예제 #5
0
    def do(self, workflow_dict):
        try:

            cs_credentials = get_credentials_for(
                environment=workflow_dict['environment'],
                credential_type=CredentialType.CLOUDSTACK)

            vm_credentials = get_credentials_for(
                environment=workflow_dict['environment'],
                credential_type=CredentialType.VM)

            cs_provider = CloudStackProvider(credentials=cs_credentials)

            offering = workflow_dict['offering']

            cs_plan_attrs = PlanAttr.objects.get(
                plan=workflow_dict['target_plan'])
            bundles = list(cs_plan_attrs.bundle.all())

            workflow_dict['target_hosts'] = []
            workflow_dict['target_instances'] = []

            for index, source_instance in enumerate(
                    workflow_dict['source_instances']):

                source_host = workflow_dict['source_hosts'][index]
                vm_name = source_host.hostname.split('.')[0]
                source_host_attr = HostAttr.objects.get(host=source_host)
                source_network_id = cs_provider.get_vm_network_id(
                    vm_id=source_host_attr.vm_id,
                    project_id=cs_credentials.project)

                if len(bundles) == 1:
                    bundle = bundles[0]
                else:
                    if index == 0:
                        bundle = LastUsedBundle.get_next_infra_bundle(
                            plan=workflow_dict['target_plan'], bundles=bundles)
                    else:
                        bundle = LastUsedBundle.get_next_bundle(
                            bundle=bundle, bundles=bundles)

                    if bundle.networkid == source_network_id:
                        bundle = LastUsedBundle.get_next_bundle(
                            bundle=bundle, bundles=bundles)

                LOG.debug(
                    "Deploying new vm on cs with bundle %s and offering %s" %
                    (bundle, offering))

                vm = cs_provider.deploy_virtual_machine(
                    offering=offering.serviceofferingid,
                    bundle=bundle,
                    project_id=cs_credentials.project,
                    vmname=vm_name,
                    affinity_group_id=cs_credentials.get_parameter_by_name(
                        'affinity_group_id'),
                )

                if not vm:
                    raise Exception(
                        "CloudStack could not create the virtualmachine")

                host = Host()
                host.address = vm['virtualmachine'][0]['nic'][0]['ipaddress']
                host.hostname = host.address
                host.save()
                workflow_dict['target_hosts'].append(host)

                source_host.future_host = host
                source_host.save()

                host_attr = HostAttr()
                host_attr.vm_id = vm['virtualmachine'][0]['id']
                host_attr.vm_user = vm_credentials.user
                host_attr.vm_password = vm_credentials.password
                host_attr.host = host
                host_attr.save()
                LOG.info("Host attrs custom attributes created!")

                instance = Instance()
                instance.address = host.address
                instance.dns = host.address
                instance.port = source_instance.port

                instance.is_active = source_instance.is_active
                instance.is_arbiter = source_instance.is_arbiter
                instance.instance_type = source_instance.instance_type
                instance.hostname = host

                instance.databaseinfra = workflow_dict['databaseinfra']
                instance.save()
                LOG.info("Instance created!")

                source_instance.future_instance = instance
                source_instance.save()

                workflow_dict['target_instances'].append(instance)

            return True
        except Exception:
            traceback = full_stack()

            workflow_dict['exceptions']['error_codes'].append(DBAAS_0020)
            workflow_dict['exceptions']['traceback'].append(traceback)

            return False
    def do(self, workflow_dict):
        try:
            if 'environment' not in workflow_dict or 'plan' not in workflow_dict:
                return False

            cs_credentials = get_credentials_for(
                environment=workflow_dict['environment'],
                credential_type=CredentialType.CLOUDSTACK)

            vm_credentials = get_credentials_for(
                environment=workflow_dict['environment'],
                credential_type=CredentialType.VM)

            cs_provider = CloudStackProvider(credentials=cs_credentials)

            cs_plan_attrs = PlanAttr.objects.get(plan=workflow_dict['plan'])

            workflow_dict['hosts'] = []
            workflow_dict['instances'] = []
            workflow_dict['databaseinfraattr'] = []
            workflow_dict['vms_id'] = []
            bundles = list(cs_plan_attrs.bundle.all())

            for index, vm_name in enumerate(workflow_dict['names']['vms']):
                offering = cs_plan_attrs.get_stronger_offering()

                if len(bundles) == 1:
                    bundle = bundles[0]
                else:
                    if index == 0:
                        bundle = LastUsedBundle.get_next_infra_bundle(
                            plan=workflow_dict['plan'], bundles=bundles)
                    else:
                        bundle = LastUsedBundle.get_next_bundle(
                            bundle=bundle, bundles=bundles)

                try:
                    DatabaseInfraOffering.objects.get(
                        databaseinfra=workflow_dict['databaseinfra'])
                except ObjectDoesNotExist:
                    LOG.info("Creating databaseInfra Offering...")
                    dbinfra_offering = DatabaseInfraOffering()
                    dbinfra_offering.offering = offering
                    dbinfra_offering.databaseinfra = workflow_dict[
                        'databaseinfra']
                    dbinfra_offering.save()

                LOG.debug(
                    "Deploying new vm on cs with bundle %s and offering %s" %
                    (bundle, offering))

                vm = cs_provider.deploy_virtual_machine(
                    offering=offering.serviceofferingid,
                    bundle=bundle,
                    project_id=cs_credentials.project,
                    vmname=vm_name,
                    affinity_group_id=cs_credentials.get_parameter_by_name(
                        'affinity_group_id'),
                )

                if not vm:
                    raise Exception(
                        "CloudStack could not create the virtualmachine")

                LOG.debug("New virtualmachine: %s" % vm)

                workflow_dict['vms_id'].append(vm['virtualmachine'][0]['id'])

                host = Host()
                host.address = vm['virtualmachine'][0]['nic'][0]['ipaddress']
                host.hostname = host.address
                host.cloud_portal_host = True
                host.save()
                LOG.info("Host created!")

                workflow_dict['hosts'].append(host)

                host_attr = HostAttr()
                host_attr.vm_id = vm['virtualmachine'][0]['id']
                host_attr.vm_user = vm_credentials.user
                host_attr.vm_password = vm_credentials.password
                host_attr.host = host
                host_attr.save()
                LOG.info("Host attrs custom attributes created!")

                instance = Instance()
                instance.address = host.address
                instance.port = 3306
                instance.hostname = host
                instance.databaseinfra = workflow_dict['databaseinfra']
                instance.instance_type = Instance.MYSQL
                instance.save()
                LOG.info("Instance created!")

                workflow_dict['instances'].append(instance)

                if workflow_dict['qt'] == 1:

                    LOG.info("Updating databaseinfra endpoint...")
                    databaseinfra = workflow_dict['databaseinfra']
                    databaseinfra.endpoint = instance.address + \
                        ":%i" % (instance.port)
                    databaseinfra.save()
                    workflow_dict['databaseinfra'] = databaseinfra

                    return True

            return True
        except Exception:
            traceback = full_stack()

            workflow_dict['exceptions']['error_codes'].append(DBAAS_0011)
            workflow_dict['exceptions']['traceback'].append(traceback)

            return False
예제 #7
0
def create_database(
    name, plan, environment, team, project, description, task,
    subscribe_to_email_events=True, is_protected=False, user=None,
    retry_from=None
):
    topology_path = plan.replication_topology.class_path

    number_of_vms = get_deploy_instances_size(topology_path)
    name = slugify(name)
    base_name = gen_infra_names(name, number_of_vms)

    infra = get_or_create_infra(base_name, plan, environment, retry_from)

    instances = []
    for i in range(number_of_vms):
        try:
            instance_name = '{}-0{}-{}'.format(
                base_name['name_prefix'], i+1, base_name['name_stamp']
            )
            instance = infra.instances.get(
                Q(hostname__hostname__startswith=instance_name) |
                Q(dns__startswith=instance_name)
            )
        except Instance.DoesNotExist:
            instance = Instance()
            instance.dns = base_name['vms'][i]
            instance.databaseinfra = infra

            driver = infra.get_driver()
            instance.port = driver.get_default_database_port()
            instance.instance_type = driver.get_default_instance_type()

        instance.vm_name = instance.dns
        instances.append(instance)

    database_create = DatabaseCreate()
    database_create.task = task
    database_create.name = name
    database_create.plan = plan
    database_create.environment = environment
    database_create.team = team
    database_create.project = project
    database_create.description = description
    database_create.subscribe_to_email_events = subscribe_to_email_events
    database_create.is_protected = is_protected
    database_create.user = '******'
    database_create.infra = infra
    database_create.database = infra.databases.first()
    database_create.save()

    steps = get_deploy_settings(topology_path)

    since_step = None
    if retry_from:
        since_step = retry_from.current_step

    if steps_for_instances(
        steps, instances, task, database_create.update_step,
        since_step=since_step
    ):
        database_create.set_success()
        task.set_status_success('Database created')
    else:
        database_create.set_error()
        task.set_status_error(
            'Could not create database\n'
            'Please check error message and do retry'
        )
    def do(self, workflow_dict):
        try:
            if 'environment' not in workflow_dict and 'plan' not in workflow_dict:
                return False

            cs_credentials = get_credentials_for(
                environment=workflow_dict['environment'],
                credential_type=CredentialType.CLOUDSTACK)

            vm_credentials = get_credentials_for(
                environment=workflow_dict['environment'],
                credential_type=CredentialType.VM)

            cs_provider = CloudStackProvider(credentials=cs_credentials)

            cs_plan_attrs = PlanAttr.objects.get(plan=workflow_dict['plan'])

            workflow_dict['hosts'] = []
            workflow_dict['instances'] = []
            workflow_dict['databaseinfraattr'] = []
            workflow_dict['vms_id'] = []
            bundles = list(cs_plan_attrs.bundle.all())

            for index, vm_name in enumerate(workflow_dict['names']['vms']):

                if len(bundles) == 1:
                    bundle = bundles[0]
                else:
                    bundle = LastUsedBundle.get_next_bundle(
                        plan=workflow_dict['plan'], bundle=bundles)

                if index == 2:
                    offering = cs_plan_attrs.get_weaker_offering()
                else:
                    offering = cs_plan_attrs.get_stronger_offering()

                try:
                    DatabaseInfraOffering.objects.get(
                        databaseinfra=workflow_dict['databaseinfra'])
                except ObjectDoesNotExist:
                    LOG.info("Creating databaseInfra Offering...")
                    dbinfra_offering = DatabaseInfraOffering()
                    dbinfra_offering.offering = offering
                    dbinfra_offering.databaseinfra = workflow_dict[
                        'databaseinfra']
                    dbinfra_offering.save()

                LOG.debug(
                    "Deploying new vm on cs with bundle %s and offering %s" % (bundle, offering))

                vm = cs_provider.deploy_virtual_machine(
                    offering=offering.serviceofferingid,
                    bundle=bundle,
                    project_id=cs_credentials.project,
                    vmname=vm_name,
                    affinity_group_id=cs_credentials.get_parameter_by_name(
                        'affinity_group_id'),
                )

                if not vm:
                    raise Exception(
                        "CloudStack could not create the virtualmachine")

                LOG.debug("New virtualmachine: %s" % vm)

                workflow_dict['vms_id'].append(vm['virtualmachine'][0]['id'])

                host = Host()
                host.address = vm['virtualmachine'][0]['nic'][0]['ipaddress']
                host.hostname = host.address
                host.cloud_portal_host = True
                host.save()
                LOG.info("Host created!")

                workflow_dict['hosts'].append(host)

                host_attr = HostAttr()
                host_attr.vm_id = vm['virtualmachine'][0]['id']
                host_attr.vm_user = vm_credentials.user
                host_attr.vm_password = vm_credentials.password
                host_attr.host = host
                host_attr.save()
                LOG.info("Host attrs custom attributes created!")

                if index in (0, 1):
                    instance = Instance()
                    instance.address = host.address
                    instance.port = 6379
                    instance.is_active = True
                    instance.hostname = host
                    instance.databaseinfra = workflow_dict['databaseinfra']
                    instance.instance_type = Instance.REDIS
                    instance.save()
                    LOG.info("Instance created!")

                    workflow_dict['instances'].append(instance)

                if workflow_dict['qt'] == 1:

                    LOG.info("Updating databaseinfra endpoint...")
                    databaseinfra = workflow_dict['databaseinfra']
                    databaseinfra.endpoint = instance.address + \
                        ":%i" % (instance.port)
                    databaseinfra.save()
                    workflow_dict['databaseinfra'] = databaseinfra

                else:

                    instance = Instance()
                    instance.address = host.address
                    instance.port = 26379
                    instance.is_active = True
                    instance.hostname = host
                    instance.databaseinfra = workflow_dict['databaseinfra']
                    instance.instance_type = Instance.REDIS_SENTINEL
                    instance.save()
                    LOG.info("Instance created!")
                    workflow_dict['instances'].append(instance)

            return True
        except Exception:
            traceback = full_stack()

            workflow_dict['exceptions']['error_codes'].append(DBAAS_0011)
            workflow_dict['exceptions']['traceback'].append(traceback)

            return False
    def _create_instance(self):
        inst = Instance()
        inst.address = '127.0.0.1'
        inst.port = 27017
        inst.is_active = True
        inst.databaseinfra = physical_factory.DatabaseInfraFactory.create(
            plan=self.plan)
        inst.status = 1
        inst.instance_type = 2
        inst.total_size_in_bytes = 100
        inst.used_size_in_bytes = 50
        #TODO: Fix that vm_name. See better way to set vm_name not on instance directly
        inst.vm_name = inst.dns

        return inst
	def do(self, workflow_dict):
		try:
			if not 'environment' in workflow_dict and not 'plan' in workflow_dict:
				return False

			cs_credentials = get_credentials_for(
				environment=workflow_dict['environment'],
				credential_type=CredentialType.CLOUDSTACK)

			vm_credentials = get_credentials_for(
				environment=workflow_dict['environment'],
				credential_type=CredentialType.VM)

			cs_provider = CloudStackProvider(credentials=cs_credentials)

			cs_plan_attrs = PlanAttr.objects.get(plan=workflow_dict['plan'])

			workflow_dict['hosts'] = []
			workflow_dict['instances'] = []
			workflow_dict['databaseinfraattr'] = []
			workflow_dict['vms_id'] = []
			bundles = list(cs_plan_attrs.bundle.all())

			for index, vm_name in enumerate(workflow_dict['names']['vms']):

				if bundles.__len__()==1:
					bundle = bundles[0]
				else:
					bundle = LastUsedBundle.get_next_bundle(plan=workflow_dict['plan'], bundle= bundles)

				if workflow_dict['enginecod'] == workflow_dict['MONGODB'] and index == 2:
					offering = cs_plan_attrs.get_weaker_offering()
				else:
					offering = cs_plan_attrs.get_stronger_offering()

				LOG.debug("Deploying new vm on cs with bundle %s and offering %s" % (bundle,offering))

				vm = cs_provider.deploy_virtual_machine(
					offering=offering.serviceofferingid,
					bundle= bundle,
					project_id=cs_credentials.project,
					vmname=vm_name,
				)

				if not vm:
					raise Exception("CloudStack could not create the virtualmachine")

				LOG.debug("New virtualmachine: %s" % vm)

				workflow_dict['vms_id'].append(vm['virtualmachine'][0]['id'])

				host = Host()
				host.address = vm['virtualmachine'][0]['nic'][0]['ipaddress']
				host.hostname = host.address
				host.cloud_portal_host = True
				host.save()
				LOG.info("Host created!")

				workflow_dict['hosts'].append(host)

				host_attr = HostAttr()
				host_attr.vm_id = vm['virtualmachine'][0]['id']
				host_attr.vm_user = vm_credentials.user
				host_attr.vm_password = vm_credentials.password
				host_attr.host = host
				host_attr.save()
				LOG.info("Host attrs custom attributes created!")

				instance = Instance()
				instance.address = host.address
				if workflow_dict['enginecod'] == workflow_dict['MYSQL']:
					instance.port = 3306
				elif workflow_dict['enginecod'] == workflow_dict['MONGODB']:
					instance.port = 27017
				instance.is_active = True
				if workflow_dict['enginecod'] == workflow_dict['MONGODB'] and index == 2:
					instance.is_arbiter = True
				else:
					instance.is_arbiter = False

				instance.hostname = host
				instance.databaseinfra = workflow_dict['databaseinfra']
				instance.save()
				LOG.info("Instance created!")

				workflow_dict['instances'].append(instance)

				if  workflow_dict['qt']==1:

					LOG.info("Updating databaseinfra endpoint...")
					databaseinfra = workflow_dict['databaseinfra']
					databaseinfra.endpoint = instance.address + ":%i" %(instance.port)
					databaseinfra.save()
					workflow_dict['databaseinfra'] = databaseinfra

					return True

			return True
		except Exception as e:
			traceback = full_stack()

			workflow_dict['exceptions']['error_codes'].append(DBAAS_0011)
			workflow_dict['exceptions']['traceback'].append(traceback)

			return False
    def do(self, workflow_dict):
        try:

            cs_credentials = get_credentials_for(
                environment=workflow_dict['target_environment'],
                credential_type=CredentialType.CLOUDSTACK)

            vm_credentials = get_credentials_for(
                environment=workflow_dict['target_environment'],
                credential_type=CredentialType.VM)

            cs_provider = CloudStackProvider(credentials=cs_credentials)

            target_offering = workflow_dict['target_offering']

            cs_plan_attrs = PlanAttr.objects.get(
                plan=workflow_dict['target_plan'])
            bundles = list(cs_plan_attrs.bundle.all())

            workflow_dict['target_hosts'] = []
            workflow_dict['target_instances'] = []

            for index, source_host in enumerate(workflow_dict['source_hosts']):

                sentinel_source_instance = Instance.objects.filter(
                    hostname=source_host,
                    instance_type=Instance.REDIS_SENTINEL)[0]
                if index < 2:
                    redis_source_instance = Instance.objects.filter(
                        hostname=source_host, instance_type=Instance.REDIS)[0]

                vm_name = source_host.hostname.split('.')[0]

                if len(bundles) == 1:
                    bundle = bundles[0]
                else:
                    bundle = LastUsedBundle.get_next_bundle(
                        plan=workflow_dict['target_plan'], bundle=bundles)

                if index == 2:
                    offering = cs_plan_attrs.get_weaker_offering()
                else:
                    offering = target_offering

                vm = cs_provider.deploy_virtual_machine(
                    offering=offering.serviceofferingid,
                    bundle=bundle,
                    project_id=cs_credentials.project,
                    vmname=vm_name,
                    affinity_group_id=cs_credentials.get_parameter_by_name(
                        'affinity_group_id'),
                )

                if not vm:
                    raise Exception(
                        "CloudStack could not create the virtualmachine")

                host = Host()
                host.address = vm['virtualmachine'][0]['nic'][0]['ipaddress']
                host.hostname = host.address
                host.save()
                workflow_dict['target_hosts'].append(host)

                source_host.future_host = host
                source_host.save()

                host_attr = HostAttr()
                host_attr.vm_id = vm['virtualmachine'][0]['id']
                host_attr.vm_user = vm_credentials.user
                host_attr.vm_password = vm_credentials.password
                host_attr.host = host
                host_attr.save()
                LOG.info("Host attrs custom attributes created!")

                if index < 2:

                    redis_instance = Instance()
                    redis_instance.address = host.address
                    redis_instance.dns = host.address
                    redis_instance.port = redis_source_instance.port

                    redis_instance.is_active = redis_source_instance.is_active
                    redis_instance.is_arbiter = redis_source_instance.is_arbiter
                    redis_instance.instance_type = redis_source_instance.instance_type
                    redis_instance.hostname = host

                    redis_instance.databaseinfra = workflow_dict[
                        'databaseinfra']
                    redis_instance.save()
                    LOG.info("Instance created!")

                    redis_source_instance.future_instance = redis_instance
                    redis_source_instance.save()

                    workflow_dict['target_instances'].append(redis_instance)

                sentinel_instance = Instance()
                sentinel_instance.address = host.address
                sentinel_instance.dns = host.address
                sentinel_instance.port = sentinel_source_instance.port

                sentinel_instance.is_active = sentinel_source_instance.is_active
                sentinel_instance.is_arbiter = sentinel_source_instance.is_arbiter
                sentinel_instance.instance_type = sentinel_source_instance.instance_type
                sentinel_instance.hostname = host

                sentinel_instance.databaseinfra = workflow_dict[
                    'databaseinfra']
                sentinel_instance.save()
                LOG.info("Instance created!")

                sentinel_source_instance.future_instance = sentinel_instance
                sentinel_source_instance.save()

                workflow_dict['target_instances'].append(sentinel_instance)

            return True
        except Exception:
            traceback = full_stack()

            workflow_dict['exceptions']['error_codes'].append(DBAAS_0020)
            workflow_dict['exceptions']['traceback'].append(traceback)

            return False
    def do(self, workflow_dict):
        try:

            cs_credentials = get_credentials_for(
                environment=workflow_dict['target_environment'],
                credential_type=CredentialType.CLOUDSTACK)

            vm_credentials = get_credentials_for(
                environment=workflow_dict['target_environment'],
                credential_type=CredentialType.VM)

            cs_provider = CloudStackProvider(credentials=cs_credentials)

            target_offering = workflow_dict['target_offering']

            cs_plan_attrs = PlanAttr.objects.get(plan=workflow_dict['target_plan'])
            bundles = list(cs_plan_attrs.bundle.all())

            workflow_dict['target_hosts'] = []
            workflow_dict['target_instances'] = []

            for index, source_instance in enumerate(workflow_dict['source_instances']):

                source_host = workflow_dict['source_hosts'][index]
                vm_name = source_host.hostname.split('.')[0]

                if len(bundles) == 1:
                    bundle = bundles[0]
                else:
                    bundle = LastUsedBundle.get_next_bundle(plan=workflow_dict['target_plan'], bundle=bundles)

                if index == 2:
                    offering = cs_plan_attrs.get_weaker_offering()
                else:
                    offering = target_offering

                vm = cs_provider.deploy_virtual_machine(offering=offering.serviceofferingid,
                                                        bundle=bundle,
                                                        project_id=cs_credentials.project,
                                                        vmname=vm_name,
                                                        affinity_group_id=cs_credentials.get_parameter_by_name('affinity_group_id'),
                                                        )

                if not vm:
                    raise Exception("CloudStack could not create the virtualmachine")

                host = Host()
                host.address = vm['virtualmachine'][0]['nic'][0]['ipaddress']
                host.hostname = host.address
                host.save()
                workflow_dict['target_hosts'].append(host)

                source_host.future_host = host
                source_host.save()

                host_attr = HostAttr()
                host_attr.vm_id = vm['virtualmachine'][0]['id']
                host_attr.vm_user = vm_credentials.user
                host_attr.vm_password = vm_credentials.password
                host_attr.host = host
                host_attr.save()
                LOG.info("Host attrs custom attributes created!")

                instance = Instance()
                instance.address = host.address
                instance.dns = host.address
                instance.port = source_instance.port

                instance.is_active = source_instance.is_active
                instance.is_arbiter = source_instance.is_arbiter
                instance.instance_type = source_instance.instance_type
                instance.hostname = host

                instance.databaseinfra = workflow_dict['databaseinfra']
                instance.save()
                LOG.info("Instance created!")

                source_instance.future_instance = instance
                source_instance.save()

                workflow_dict['target_instances'].append(instance)

            return True
        except Exception:
            traceback = full_stack()

            workflow_dict['exceptions']['error_codes'].append(DBAAS_0020)
            workflow_dict['exceptions']['traceback'].append(traceback)

            return False
    def do(self, workflow_dict):
        try:
            if not 'environment' in workflow_dict and not 'plan' in workflow_dict:
                return False

            cs_credentials = get_credentials_for(
                environment=workflow_dict['environment'],
                credential_type=CredentialType.CLOUDSTACK)

            vm_credentials = get_credentials_for(
                environment=workflow_dict['environment'],
                credential_type=CredentialType.VM)

            cs_provider = CloudStackProvider(credentials=cs_credentials)

            cs_plan_attrs = PlanAttr.objects.get(plan=workflow_dict['plan'])

            workflow_dict['hosts'] = []
            workflow_dict['instances'] = []
            workflow_dict['databaseinfraattr'] = []
            workflow_dict['vms_id'] = []
            bundles = list(cs_plan_attrs.bundle.all())

            for index, vm_name in enumerate(workflow_dict['names']['vms']):

                if bundles.__len__() == 1:
                    bundle = bundles[0]
                else:
                    bundle = LastUsedBundle.get_next_bundle(
                        plan=workflow_dict['plan'], bundle=bundles)

                if workflow_dict['enginecod'] == workflow_dict[
                        'MONGODB'] and index == 2:
                    offering = cs_plan_attrs.get_weaker_offering()
                else:
                    offering = cs_plan_attrs.get_stronger_offering()

                try:
                    DatabaseInfraOffering.objects.get(
                        databaseinfra=workflow_dict['databaseinfra'])
                except ObjectDoesNotExist, e:
                    LOG.info("Creating databaseInfra Offering...")
                    dbinfra_offering = DatabaseInfraOffering()
                    dbinfra_offering.offering = offering
                    dbinfra_offering.databaseinfra = workflow_dict[
                        'databaseinfra']
                    dbinfra_offering.save()

                LOG.debug(
                    "Deploying new vm on cs with bundle %s and offering %s" %
                    (bundle, offering))

                vm = cs_provider.deploy_virtual_machine(
                    offering=offering.serviceofferingid,
                    bundle=bundle,
                    project_id=cs_credentials.project,
                    vmname=vm_name,
                )

                if not vm:
                    raise Exception(
                        "CloudStack could not create the virtualmachine")

                LOG.debug("New virtualmachine: %s" % vm)

                workflow_dict['vms_id'].append(vm['virtualmachine'][0]['id'])

                host = Host()
                host.address = vm['virtualmachine'][0]['nic'][0]['ipaddress']
                host.hostname = host.address
                host.cloud_portal_host = True
                host.save()
                LOG.info("Host created!")

                workflow_dict['hosts'].append(host)

                host_attr = HostAttr()
                host_attr.vm_id = vm['virtualmachine'][0]['id']
                host_attr.vm_user = vm_credentials.user
                host_attr.vm_password = vm_credentials.password
                host_attr.host = host
                host_attr.save()
                LOG.info("Host attrs custom attributes created!")

                instance = Instance()
                instance.address = host.address
                if workflow_dict['enginecod'] == workflow_dict['MYSQL']:
                    instance.port = 3306
                elif workflow_dict['enginecod'] == workflow_dict['MONGODB']:
                    instance.port = 27017
                elif workflow_dict['enginecod'] == workflow_dict['REDIS']:
                    instance.port = 6379
                instance.is_active = True
                if workflow_dict['enginecod'] == workflow_dict[
                        'MONGODB'] and index == 2:
                    instance.is_arbiter = True
                else:
                    instance.is_arbiter = False

                instance.hostname = host
                instance.databaseinfra = workflow_dict['databaseinfra']
                instance.save()
                LOG.info("Instance created!")

                workflow_dict['instances'].append(instance)

                if workflow_dict['qt'] == 1:

                    LOG.info("Updating databaseinfra endpoint...")
                    databaseinfra = workflow_dict['databaseinfra']
                    databaseinfra.endpoint = instance.address + ":%i" % (
                        instance.port)
                    databaseinfra.save()
                    workflow_dict['databaseinfra'] = databaseinfra

                    return True

            return True