Example #1
0
    def do(self):
        if self.host.hostname == self.host.address:
            self.host.hostname = add_dns_record(
                databaseinfra=self.infra,
                name=self.instance.vm_name,
                ip=self.host.address,
                type=HOST,
                is_database=self.instance.is_database
            )
            self.host.save()

        self.instance.dns = add_dns_record(
            databaseinfra=self.infra,
            name=self.instance.vm_name,
            ip=self.instance.address,
            type=INSTANCE,
            is_database=self.instance.is_database
        )

        self.provider.create_database_dns_for_ip(
            databaseinfra=self.infra,
            ip=self.instance.address
        )

        self.instance.save()
Example #2
0
    def do(self):
        if self.host.hostname == self.host.address:
            self.host.hostname = add_dns_record(
                databaseinfra=self.infra,
                name=self.instance.vm_name,
                ip=self.host.address,
                type=HOST,
                is_database=self.instance.is_database
            )
            self.host.save()

        self.instance.dns = add_dns_record(
            databaseinfra=self.infra,
            name=self.instance.vm_name,
            ip=self.instance.address,
            type=INSTANCE,
            is_database=self.instance.is_database
        )

        self.provider.create_database_dns_for_ip(
            databaseinfra=self.infra,
            ip=self.instance.address
        )

        self.instance.save()
Example #3
0
    def do(self, workflow_dict):
        try:

            databaseinfra = workflow_dict['databaseinfra']
            LOG.info("Creating dns for VIP...")
            vip_ip = get_vip_ip_from_databaseinfra(databaseinfra=databaseinfra)

            vip_dns = add_dns_record(databaseinfra=databaseinfra,
                                     name=databaseinfra.name,
                                     ip=vip_ip,
                                     type=FOXHA)

            LOG.info("Updating databaseinfra endpoint...")
            databaseinfra.endpoint_dns = "{}:{}".format(vip_dns, 3306)
            databaseinfra.save()
            workflow_dict['databaseinfra'] = databaseinfra

            LOG.info("Creating dns for hosts...")
            for host_name in zip(workflow_dict['hosts'],
                                 workflow_dict['names']['vms']):
                host = host_name[0]

                host.hostname = add_dns_record(
                    databaseinfra=workflow_dict['databaseinfra'],
                    name=host_name[1],
                    ip=host.address,
                    type=HOST)
                host.save()

            LOG.info("Creating dns for instances...")
            for instance_name in zip(workflow_dict['instances'],
                                     workflow_dict['names']['vms']):
                instance = instance_name[0]

                instance.dns = add_dns_record(
                    databaseinfra=workflow_dict['databaseinfra'],
                    name=instance_name[1],
                    ip=instance.address,
                    type=INSTANCE)
                instance.save()

            LOG.info("Calling dnsapi provider...")
            DNSAPIProvider.create_database_dns(
                databaseinfra=workflow_dict['databaseinfra'])

            return True

        except Exception:
            traceback = full_stack()

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

            return False
    def do(self, workflow_dict):
        try:
            LOG.info("Creating dns for hosts...")
            for host_name in zip(workflow_dict['hosts'],
                                 workflow_dict['names']['vms']):
                host = host_name[0]
                LOG.info("Updating host dns - host: {}".format(host))

                host.hostname = add_dns_record(
                    databaseinfra=workflow_dict['databaseinfra'],
                    name=host_name[1],
                    ip=host.address,
                    type=HOST)
                host.save()
                LOG.info("DNS host updated - dns: {}".format(host.hostname))

            LOG.info("Creating dns for instances...")
            for instance_name in zip(workflow_dict['instances'],
                                     workflow_dict['names']['vms']):
                instance = instance_name[0]
                LOG.info(
                    "Updating instance dns - instance: {}".format(instance))

                instance.dns = add_dns_record(
                    databaseinfra=workflow_dict['databaseinfra'],
                    name=instance_name[1],
                    ip=instance.address,
                    type=INSTANCE)
                instance.save()
                LOG.info("DNS instance updated - dns: {}".format(instance.dns))

                if workflow_dict['qt'] == 1:
                    LOG.info("Updating databaseinfra dns endpoint")
                    databaseinfra = workflow_dict['databaseinfra']
                    databaseinfra.endpoint_dns = instance.dns + \
                        ':%i' % instance.port
                    databaseinfra.save()
                    workflow_dict['databaseinfra'] = databaseinfra

            LOG.info("Calling dnsapi provider...")
            DNSAPIProvider.create_database_dns(
                databaseinfra=workflow_dict['databaseinfra'])

            return True

        except Exception:
            traceback = full_stack()

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

            return False
    def do(self, workflow_dict):
        try:
            LOG.info("Creating dns for hosts...")
            for host_name in zip(workflow_dict['hosts'], workflow_dict['names']['vms']):
                host = host_name[0]
                LOG.info("Updating host dns - host: {}".format(host))

                host.hostname = add_dns_record(
                    databaseinfra=workflow_dict['databaseinfra'],
                    name=host_name[
                        1],
                    ip=host.address,
                    type=HOST)
                host.save()
                LOG.info("DNS host updated - dns: {}".format(host.hostname))

            LOG.info("Creating dns for instances...")
            for instance_name in zip(workflow_dict['instances'], workflow_dict['names']['vms']):
                instance = instance_name[0]
                LOG.info("Updating instance dns - instance: {}".format(instance))

                instance.dns = add_dns_record(
                    databaseinfra=workflow_dict['databaseinfra'],
                    name=instance_name[
                        1],
                    ip=instance.address,
                    type=INSTANCE)
                instance.save()
                LOG.info("DNS instance updated - dns: {}".format(instance.dns))

                if workflow_dict['qt'] == 1:
                    LOG.info("Updating databaseinfra dns endpoint")
                    databaseinfra = workflow_dict['databaseinfra']
                    databaseinfra.endpoint_dns = instance.dns + \
                        ':%i' % instance.port
                    databaseinfra.save()
                    workflow_dict['databaseinfra'] = databaseinfra

            LOG.info("Calling dnsapi provider...")
            DNSAPIProvider.create_database_dns(
                databaseinfra=workflow_dict['databaseinfra'])

            return True

        except Exception:
            traceback = full_stack()

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

            return False
    def do(self):
        if not self.is_valid:
            return

        vip = self.provider.create_vip(
            #TODO CHECK
            #self.infra, self.instance.port, self.team,
            self.infra,
            self.target_instance.port,
            self.team,
            self.equipments,
            self.vip_dns)

        if vip is None:
            return

        if not vip.original_vip:
            dns = add_dns_record(self.infra,
                                 self.infra.name,
                                 vip.vip_ip,
                                 FOXHA,
                                 is_database=False)
            self.infra.endpoint_dns = "{}:{}".format(dns, 3306)
            self.infra.endpoint = "{}:{}".format(vip.vip_ip, 3306)
            self.infra.save()
    def do(self):
        host = self.instance.hostname
        host.hostname = add_dns_record(databaseinfra=self.infra,
                                       name=self.instance.vm_name,
                                       ip=host.address,
                                       type=HOST)
        host.save()

        self.instance.dns = add_dns_record(databaseinfra=self.infra,
                                           name=self.instance.vm_name,
                                           ip=self.instance.address,
                                           type=INSTANCE)
        self.instance.save()

        self.provider.create_database_dns_for_ip(databaseinfra=self.infra,
                                                 ip=self.instance.address)
    def do(self):
        LOG.info('Creating DNS for {}'.format(self.instance))

        host = self.instance.hostname
        host.hostname = add_dns_record(databaseinfra=self.databaseinfra,
                                       name=self.instance.vm_name,
                                       ip=host.address,
                                       type=HOST)
        host.save()

        self.instance.dns = add_dns_record(databaseinfra=self.databaseinfra,
                                           name=self.instance.vm_name,
                                           ip=self.instance.address,
                                           type=INSTANCE)
        self.instance.save()

        DNSAPIProvider.create_database_dns_for_ip(
            databaseinfra=self.databaseinfra, ip=self.instance.address)
Example #9
0
    def do(self):
        if not self.is_valid:
            return

        vip = self.provider.create_vip(self.equipments, 3306, self.vip_dns)
        dns = add_dns_record(self.infra, self.infra.name, vip.vip_ip, FOXHA)

        self.infra.endpoint = "{}:{}".format(vip.vip_ip, 3306)
        self.infra.endpoint_dns = "{}:{}".format(dns, 3306)
        self.infra.save()
Example #10
0
 def do(self):
     if not self.is_valid:
         return
     self.vip = self.future_vip
     self._env = self.environment
     dns = add_dns_record(self.infra,
                          self.infra.name,
                          self.vip.vip_ip,
                          FOXHA,
                          is_database=False)
     assert self.infra.endpoint_dns == "{}:3306".format(dns)
     return super(RegisterDNSVipMigrate, self).do()
    def do(self):
        if not self.is_valid:
            return

        vip = self.provider.create_vip(
            self.infra, self.instance.port, self.team,
            self.equipments, self.vip_dns)
        dns = add_dns_record(self.infra, self.infra.name, vip.vip_ip, FOXHA, is_database=False)

        self.infra.endpoint = "{}:{}".format(vip.vip_ip, 3306)
        self.infra.endpoint_dns = "{}:{}".format(dns, 3306)
        self.infra.save()
Example #12
0
 def do(self):
     if not self.is_valid:
         return
     self.vip = self.future_vip
     self._env = self.environment
     dns = add_dns_record(
         self.infra,
         self.infra.name,
         self.vip.vip_ip,
         FOXHA,
         is_database=False
     )
     assert self.infra.endpoint_dns == "{}:3306".format(dns)
     return super(RegisterDNSVipMigrate, self).do()
    def do(self):
        if not self.is_valid:
            return

        dns = add_dns_record(self.infra,
                             self.infra.name,
                             self.vip_ip,
                             FOXHA,
                             is_database=False)

        if dns is None:
            return

        self.infra.endpoint_dns = "{}:{}".format(dns, 3306)
        self.infra.save()
Example #14
0
    def do(self):
        if not self.is_valid:
            return

        vip = self.provider.create_vip(self.infra, self.instance.port,
                                       self.team, self.equipments,
                                       self.vip_dns)
        dns = add_dns_record(self.infra,
                             self.infra.name,
                             vip.vip_ip,
                             FOXHA,
                             is_database=False)

        self.infra.endpoint = "{}:{}".format(vip.vip_ip, 3306)
        self.infra.endpoint_dns = "{}:{}".format(dns, 3306)
        self.infra.save()
    def do(self, workflow_dict):
        try:
            LOG.info("Creating dns for hosts...")
            for host_name in zip(workflow_dict['hosts'],
                                 workflow_dict['names']['vms']):
                host = host_name[0]

                host.hostname = add_dns_record(
                    databaseinfra=workflow_dict['databaseinfra'],
                    name=host_name[1],
                    ip=host.address,
                    type=HOST)
                host.save()

            instances_redis = []
            instances_sentinel = []

            for instance in workflow_dict['instances']:
                if instance.instance_type == Instance.REDIS_SENTINEL:
                    instances_sentinel.append(instance)
                else:
                    instances_redis.append(instance)

            LOG.info("Creating dns for instances...")
            for instance_name in zip(instances_redis,
                                     workflow_dict['names']['vms']):
                instance = instance_name[0]

                instance.dns = add_dns_record(
                    databaseinfra=workflow_dict['databaseinfra'],
                    name=instance_name[1],
                    ip=instance.address,
                    type=INSTANCE)
                instance.save()

                if workflow_dict['qt'] == 1:
                    LOG.info("Updating databaseinfra dns endpoint")
                    databaseinfra = workflow_dict['databaseinfra']
                    databaseinfra.endpoint_dns = instance.dns + \
                        ':%i' % instance.port
                    databaseinfra.save()
                    workflow_dict['databaseinfra'] = databaseinfra

            LOG.info("Creating dns for sentinel instances...")
            for instance_name in zip(instances_sentinel,
                                     workflow_dict['names']['vms']):
                instance = instance_name[0]

                instance.dns = add_dns_record(
                    databaseinfra=workflow_dict['databaseinfra'],
                    name=instance_name[1],
                    ip=instance.address,
                    type=INSTANCE,
                    database_sufix='sentinel')
                instance.save()

            LOG.info("Calling dnsapi provider...")
            DNSAPIProvider.create_database_dns(
                databaseinfra=workflow_dict['databaseinfra'])

            return True

        except Exception:
            traceback = full_stack()

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

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

            if 'databaseinfraattr' in workflow_dict:

                LOG.info("Creating dns for databaseinfraattr...")
                for infra_attr in workflow_dict['databaseinfraattr']:

                    if infra_attr.is_write:
                        dnsname = workflow_dict['databaseinfra'].name
                    else:
                        dnsname = workflow_dict['databaseinfra'].name + '-r'

                    dnsname = add_dns_record(
                        databaseinfra=workflow_dict['databaseinfra'],
                        name=dnsname,
                        ip=infra_attr.ip,
                        type=FLIPPER)

                    infra_attr.dns = dnsname
                    infra_attr.save()

                    if infra_attr.is_write:
                        LOG.info("Updating databaseinfra dns endpoint")
                        databaseinfra = workflow_dict['databaseinfra']
                        databaseinfra.endpoint_dns = infra_attr.dns + ':%i' % 3306
                        databaseinfra.save()
                        workflow_dict['databaseinfra'] = databaseinfra

            LOG.info("Creating dns for hosts...")
            for host_name in zip(workflow_dict['hosts'],
                                 workflow_dict['names']['vms']):
                host = host_name[0]

                host.hostname = add_dns_record(
                    databaseinfra=workflow_dict['databaseinfra'],
                    name=host_name[1],
                    ip=host.address,
                    type=HOST)
                host.save()

            LOG.info("Creating dns for instances...")
            for instance_name in zip(workflow_dict['instances'],
                                     workflow_dict['names']['vms']):
                instance = instance_name[0]

                instance.dns = add_dns_record(
                    databaseinfra=workflow_dict['databaseinfra'],
                    name=instance_name[1],
                    ip=instance.address,
                    type=INSTANCE)
                instance.save()

                if workflow_dict['qt'] == 1:
                    LOG.info("Updating databaseinfra dns endpoint")
                    databaseinfra = workflow_dict['databaseinfra']
                    databaseinfra.endpoint_dns = instance.dns + ':%i' % instance.port
                    databaseinfra.save()
                    workflow_dict['databaseinfra'] = databaseinfra

            LOG.info("Calling dnsapi provider...")
            DNSAPIProvider.create_database_dns(
                databaseinfra=workflow_dict['databaseinfra'])

            return True

        except Exception, e:
            traceback = full_stack()

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

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

            if 'databaseinfraattr' in workflow_dict:

                LOG.info("Creating dns for databaseinfraattr...")
                for infra_attr in workflow_dict['databaseinfraattr']:

                    if infra_attr.is_write:
                        dnsname = workflow_dict['databaseinfra'].name
                    else:
                        dnsname = workflow_dict['databaseinfra'].name + '-r'

                    dnsname = add_dns_record(
                        databaseinfra=workflow_dict['databaseinfra'],
                        name=dnsname,
                        ip=infra_attr.ip,
                        type=FLIPPER)

                    infra_attr.dns = dnsname
                    infra_attr.save()

                    if infra_attr.is_write:
                        LOG.info("Updating databaseinfra dns endpoint")
                        databaseinfra = workflow_dict['databaseinfra']
                        databaseinfra.endpoint_dns = infra_attr.dns + \
                            ':%i' % 3306
                        databaseinfra.save()
                        workflow_dict['databaseinfra'] = databaseinfra

            LOG.info("Creating dns for hosts...")
            for host_name in zip(workflow_dict['hosts'], workflow_dict['names']['vms']):
                host = host_name[0]

                host.hostname = add_dns_record(
                    databaseinfra=workflow_dict['databaseinfra'],
                    name=host_name[
                        1],
                    ip=host.address,
                    type=HOST)
                host.save()

            LOG.info("Creating dns for instances...")
            for instance_name in zip(workflow_dict['instances'], workflow_dict['names']['vms']):
                instance = instance_name[0]

                instance.dns = add_dns_record(
                    databaseinfra=workflow_dict['databaseinfra'],
                    name=instance_name[
                        1],
                    ip=instance.address,
                    type=INSTANCE)
                instance.save()

                if workflow_dict['qt'] == 1:
                    LOG.info("Updating databaseinfra dns endpoint")
                    databaseinfra = workflow_dict['databaseinfra']
                    databaseinfra.endpoint_dns = instance.dns + \
                        ':%i' % instance.port
                    databaseinfra.save()
                    workflow_dict['databaseinfra'] = databaseinfra

            LOG.info("Calling dnsapi provider...")
            DNSAPIProvider.create_database_dns(
                databaseinfra=workflow_dict['databaseinfra'])

            return True

        except Exception:
            traceback = full_stack()

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

            return False
    def do(self, workflow_dict):
        try:
            LOG.info("Creating dns for hosts...")
            for host_name in zip(workflow_dict["hosts"], workflow_dict["names"]["vms"]):
                host = host_name[0]

                host.hostname = add_dns_record(
                    databaseinfra=workflow_dict["databaseinfra"], name=host_name[1], ip=host.address, type=HOST
                )
                host.save()

            instances_redis = []
            instances_sentinel = []

            for instance in workflow_dict["instances"]:
                if instance.instance_type == Instance.REDIS_SENTINEL:
                    instances_sentinel.append(instance)
                else:
                    instances_redis.append(instance)

            LOG.info("Creating dns for instances...")
            for instance_name in zip(instances_redis, workflow_dict["names"]["vms"]):
                instance = instance_name[0]

                instance.dns = add_dns_record(
                    databaseinfra=workflow_dict["databaseinfra"],
                    name=instance_name[1],
                    ip=instance.address,
                    type=INSTANCE,
                )
                instance.save()

                if workflow_dict["qt"] == 1:
                    LOG.info("Updating databaseinfra dns endpoint")
                    databaseinfra = workflow_dict["databaseinfra"]
                    databaseinfra.endpoint_dns = instance.dns + ":%i" % instance.port
                    databaseinfra.save()
                    workflow_dict["databaseinfra"] = databaseinfra

            LOG.info("Creating dns for sentinel instances...")
            for instance_name in zip(instances_sentinel, workflow_dict["names"]["vms"]):
                instance = instance_name[0]

                instance.dns = add_dns_record(
                    databaseinfra=workflow_dict["databaseinfra"],
                    name=instance_name[1],
                    ip=instance.address,
                    type=INSTANCE,
                    database_sufix="sentinel",
                )
                instance.save()

            LOG.info("Calling dnsapi provider...")
            DNSAPIProvider.create_database_dns(databaseinfra=workflow_dict["databaseinfra"])

            return True

        except Exception:
            traceback = full_stack()

            workflow_dict["exceptions"]["error_codes"].append(DBAAS_0007)
            workflow_dict["exceptions"]["traceback"].append(traceback)

            return False