def __init__(self, instance): super(Foreman, self).__init__(instance) self.credentials = get_or_none_credentials_for( self.environment, CredentialType.FOREMAN ) self._provider = None self.host_prov_client = HostProviderClient(self.environment)
def do(self): pod_metadata = self.client.read_namespaced_pod(self.pod_name, 'default') self.instance.address = pod_metadata.status.pod_ip self.instance.port = self.driver.default_port host = self.host host.address = self.instance.address host.save() hp_client = HostProviderClient(self.environment) hp_client.edit_host(host.identifier, payload={'address': host.address})
class VipProviderStep(BaseInstanceStep): def __init__(self, instance=None): super(VipProviderStep, self).__init__(instance) self.credentials = None self._provider = None self.host_prov_client = HostProviderClient(self.environment) @property def provider(self): if not self._provider: self._provider = Provider(self.instance, self.environment) return self._provider @property def vm_properties(self): if not (hasattr(self, '_vm_properties') and self._vm_properties): self._vm_properties = self.host_prov_client.get_vm_by_host( self.host) return self._vm_properties @property def equipments(self): equipments = [] for instance in self.infra.instances.all(): host = instance.hostname if host.future_host: host = host.future_host vm_info = self.host_prov_client.get_vm_by_host(host) equipment = { 'host_address': host.address, 'port': instance.port, 'identifier': vm_info.identifier } equipments.append(equipment) return equipments @property def team(self): ## TODO return "dbaas" if self.has_database: return self.database.team.name return self.create.team.name def do(self): raise NotImplementedError def undo(self): pass
class VipProviderStep(BaseInstanceStep): def __init__(self, instance=None): super(VipProviderStep, self).__init__(instance) self.credentials = None self._provider = None self.host_prov_client = HostProviderClient(self.environment) @property def provider(self): if not self._provider: self._provider = Provider(self.instance, self.environment) return self._provider @property def vm_properties(self): if not (hasattr(self, '_vm_properties') and self._vm_properties): self._vm_properties = self.host_prov_client.get_vm_by_host( self.host) return self._vm_properties @property def equipments(self): equipments = [] for instance in self.infra.instances.all(): host = instance.hostname if host.future_host: host = host.future_host vm_info = self.host_prov_client.get_vm_by_host(host) equipment = { 'host_address': host.address, 'port': instance.port, 'identifier': vm_info.identifier } equipments.append(equipment) return equipments @property def team(self): ## TODO return "dbaas" if self.has_database: return self.database.team.name return self.create.team.name def do(self): raise NotImplementedError def undo(self): pass
def do(self): host_provider_cli = HostProviderClient(self.infra.environment) vm = host_provider_cli.get_vm_by_host(self.host) cloudstack_offering_id = self.cs_provider.get_vm_offering_id( vm_id=vm.identifier, project_id=self.cs_credentials.project ) if cloudstack_offering_id == self.target_offering_id: return success = self.cs_provider.change_service_for_vm( vm.identifier, self.target_offering_id ) if not success: raise Exception("Could not change offering")
def equipments(self): equipments = [] host_provider_cli = HostProviderClient(self.infra.environment) for instance in self.infra.instances.all(): host = instance.hostname vm = host_provider_cli.get_vm_by_host(host) if vm is None: raise Exception( "Cannot get information for host {} for identifier {}". format(host, host.identifier)) equipment = Equipment( '{}-{}'.format(self.api.vm_name, vm.identifier), host.address, instance.port) equipments.append(equipment) return equipments
class Foreman(BaseInstanceStep): host_status = HostStatus def __init__(self, instance): super(Foreman, self).__init__(instance) self.credentials = get_or_none_credentials_for( self.environment, CredentialType.FOREMAN ) self._provider = None self.host_prov_client = HostProviderClient(self.environment) @property def provider(self): if self._provider is None: self._provider = get_foreman_provider(self.infra, self.credentials) return self._provider @property def fqdn(self): if self.host_status.is_up(self.host): script = 'hostname -f' output = self.host.ssh.run_script(script) return output['stdout'][0].strip() vm_properties = self.host_prov_client.get_vm_by_host(self.host) if vm_properties and vm_properties.fqdn: return vm_properties.fqdn raise FqdnNotFoundExepition("Fqdn is not found") @property def reverse_ip(self): if self.host_status.is_up(self.host): reverse_ip = subprocess.check_output( ("nslookup {} | grep 'name' | " "awk '/name = / {{print $4}}'".format( self.host.address)), shell=True) if reverse_ip.endswith('.'): return reverse_ip[:-1] return reverse_ip return self.fqdn @property def is_valid(self): return self.credentials is not None def do(self): raise NotImplementedError def undo(self): pass
def __init__(self, instance): super(VolumeProviderBase, self).__init__(instance) self._credential = None self.host_prov_client = HostProviderClient(self.environment)
class VolumeProviderBase(BaseInstanceStep): def __init__(self, instance): super(VolumeProviderBase, self).__init__(instance) self._credential = None self.host_prov_client = HostProviderClient(self.environment) @property def driver(self): return self.infra.get_driver() @property def credential(self): if not self._credential: self._credential = get_credentials_for( self.environment, CredentialType.VOLUME_PROVIDER) return self._credential @property def volume(self): return self.host.volumes.get(is_active=True) @property def inactive_volume(self): return self.host.volumes.filter(is_active=False).last() or None @property def volume_migrate(self): return self.host_migrate.host.volumes.get(is_active=True) @property def provider(self): return self.credential.project @property def base_url(self): return "{}/{}/{}/".format(self.credential.endpoint, self.provider, self.environment) @property def headers(self): header = {} if self.pool: header = self.pool.as_headers header["K8S-Namespace"] = self.infra.name return header @property def host_vm(self): return self.host_prov_client.get_vm_by_host(self.host) def create_volume(self, group, size_kb, to_address='', snapshot_id=None, is_active=True, zone=None, vm_name=None): url = self.base_url + "volume/new" data = { "group": group, "size_kb": size_kb, "to_address": to_address, "snapshot_id": snapshot_id, "zone": zone, "vm_name": vm_name } response = post(url, json=data, headers=self.headers) if not response.ok: raise IndexError(response.content, response) volume = Volume() volume.host = self.host volume.identifier = response.json()['identifier'] volume.total_size_kb = self.infra.disk_offering.size_kb volume.is_active = is_active volume.save() return volume def destroy_volume(self, volume): url = "{}volume/{}".format(self.base_url, volume.identifier) response = delete(url, headers=self.headers) if not response.ok: raise IndexError(response.content, response) volume.delete() def destroy_old_volume(self, volume): url = "{}remove-old-volume/{}".format(self.base_url, volume.identifier) response = delete(url, headers=self.headers) if not response.ok: raise IndexError(response.content, response) volume.delete() return response.json() def detach_disk(self, volume): url = "{}detach-disk/{}".format(self.base_url, volume.identifier) response = post(url, headers=self.headers) if not response.ok: raise IndexError(response.content, response) return response.json() def get_volume(self, volume): url = "{}volume/{}".format(self.base_url, volume.identifier) response = get(url, headers=self.headers) if not response.ok: raise IndexError(response.content, response) return response.json() def get_path(self, volume): vol = self.get_volume(volume) return vol['path'] def run_script(self, script, host=None): output = {} return_code = exec_remote_command_host(host or self.host, script, output) if return_code != 0: raise EnvironmentError('Could not execute script {}: {}'.format( return_code, output)) return output def take_snapshot(self): url = "{}snapshot/{}".format(self.base_url, self.volume.identifier) data = { "engine": self.engine.name, "db_name": self.database.name, "team_name": self.database.team.name } response = post(url, json=data, headers=self.headers) if not response.ok: raise IndexError(response.content, response) return response.json() def delete_snapshot(self, snapshot, force): url = "{}snapshot/{}?force={}".format(self.base_url, snapshot.snapshopt_id, force) response = delete(url, headers=self.headers) if not response.ok: raise IndexError(response.content, response) return response.json()['removed'] def restore_snapshot(self, snapshot): url = "{}snapshot/{}/restore".format(self.base_url, snapshot.snapshopt_id) response = post(url, headers=self.headers) if not response.ok: raise IndexError(response.content, response) return response.json() def add_access(self, volume, host, access_type=None): url = "{}access/{}".format(self.base_url, volume.identifier) data = {"to_address": host.address} if access_type: data['access_type'] = access_type response = post(url, json=data, headers=self.headers) if not response.ok: raise IndexError(response.content, response) return response.json() def get_snapshot_state(self, snapshot): url = "{}snapshot/{}/state".format(self.base_url, snapshot.snapshopt_id) response = get(url, headers=self.headers) if not response.ok: raise VolumeProviderGetSnapshotState(response.content, response) return response.json()['state'] def _get_command(self, url, payload, exception_class): response = get(url, json=payload, headers=self.headers) if not response.ok: raise exception_class(response.content, response) return response.json()['command'] def get_create_pub_key_command(self, host_ip): url = "{}commands/create_pub_key".format(self.base_url) return self._get_command(url, {'host_ip': host_ip}, VolumeProviderCreatePubKeyCommand) def get_remove_pub_key_command(self, host_ip): url = "{}commands/remove_pub_key".format(self.base_url) return self._get_command(url, {'host_ip': host_ip}, VolumeProviderRemovePubKeyCommand) def get_add_hosts_allow_command(self, host_ip): url = "{}commands/add_hosts_allow".format(self.base_url) return self._get_command(url, {'host_ip': host_ip}, VolumeProviderAddHostAllowCommand) def get_remove_hosts_allow_command(self, host_ip): url = "{}commands/remove_hosts_allow".format(self.base_url) return self._get_command(url, {'host_ip': host_ip}, VolumeProviderRemoveHostAllowCommand) def remove_access(self, volume, host): url = "{}access/{}/{}".format(self.base_url, volume.identifier, host.address) response = delete(url, headers=self.headers) if not response.ok: raise IndexError(response.content, response) return response.json() def get_mount_command(self, volume, data_directory="/data", fstab=True): url = "{}commands/{}/mount".format(self.base_url, volume.identifier) data = { 'with_fstab': fstab, 'data_directory': data_directory, 'host_vm': self.host_vm.name, 'host_zone': self.host_vm.zone } response = post(url, json=data, headers=self.headers) if not response.ok: raise IndexError(response.content, response) return response.json()['command'] def get_copy_files_command(self, snapshot, source_dir, dest_dir, snap_dir=''): # snap = volume.backups.order_by('created_at').first() url = "{}commands/copy_files".format(self.base_url) data = { 'snap_identifier': snapshot.snapshopt_id, 'source_dir': source_dir, 'dest_dir': dest_dir, 'snap_dir': snap_dir } response = post(url, json=data, headers=self.headers) if not response.ok: raise IndexError(response.content, response) return response.json()['command'] def get_scp_from_snapshot_command(self, snapshot, source_dir, dest_ip, dest_dir): url = "{}snapshots/{}/commands/scp".format(self.base_url, snapshot.snapshopt_id) data = { 'source_dir': source_dir, 'target_ip': dest_ip, 'target_dir': dest_dir } response = get(url, json=data, headers=self.headers) if not response.ok: raise VolumeProviderScpFromSnapshotCommand(response.content, response) return response.json()['command'] def get_umount_command(self, volume, data_directory="/data"): url = "{}commands/{}/umount".format(self.base_url, volume.identifier) data = {'data_directory': data_directory} response = post(url, json=data, headers=self.headers) if not response.ok: raise IndexError(response.content, response) return response.json()['command'] def clean_up(self, volume): url = "{}commands/{}/cleanup".format(self.base_url, volume.identifier) response = get(url, headers=self.headers) if not response.ok: raise IndexError(response.content, response) command = response.json()['command'] if command: self.run_script(command) def do(self): raise NotImplementedError def undo(self): pass
def __init__(self, instance=None): super(VipProviderStep, self).__init__(instance) self.credentials = None self._provider = None self.host_prov_client = HostProviderClient(self.environment)
def __init__(self, instance=None): super(VipProviderStep, self).__init__(instance) self.credentials = None self._provider = None self.host_prov_client = HostProviderClient(self.environment)
class VipProviderStep(BaseInstanceStep): def __init__(self, instance=None): super(VipProviderStep, self).__init__(instance) self.credentials = None self._provider = None self.host_prov_client = HostProviderClient(self.environment) @property def provider(self): if not self._provider: self._provider = Provider(self.instance, self.environment) return self._provider @property def vm_properties(self): if not (hasattr(self, '_vm_properties') and self._vm_properties): self._vm_properties = self.host_prov_client.get_vm_by_host( self.host) return self._vm_properties @property def equipments(self): equipments = [] ## TODO CHECK for instance in self.infra.instances.filter(future_instance=None): host = instance.hostname if host.future_host: host = host.future_host vm_info = self.host_prov_client.get_vm_by_host(host) equipment = { 'host_address': host.address, 'port': instance.port, 'identifier': vm_info.identifier, 'zone': vm_info.zone, 'group': vm_info.group, 'name': vm_info.name } equipments.append(equipment) return equipments @property def team(self): # @TODO return "dbaas" if self.has_database: return self.database.team.name return self.create.team.name @property def current_vip(self): vip = Vip.objects.filter(infra=self.infra) if vip.exists(): return vip.last() return None @property def current_instance_group(self): if not self.current_vip: return None return VipInstanceGroup.objects.filter(vip=self.current_vip) def do(self): raise NotImplementedError def undo(self): pass