def _get_current_resource(self, uuid, values): try: r_type = json.loads(values['type']).replace('_', '-') return Resource(r_type, uuid=uuid) except KeyError: printo("[%s] incomplete, no type" % uuid) return False
def wrapper(*args): if JSON_OUTPUT: old_stdout = sys.stdout sys.stdout = my_stdout = StringIO() start = time.time() try: r = fun(*args) except (Exception, NotFound) as e: if JSON_OUTPUT: r = -1 printo(text_type(e)) else: raise end = time.time() if JSON_OUTPUT: sys.stdout = old_stdout if r == -1: total = -1 elif isinstance(r, list): total = len(r) else: total = 1 printo( json_log(fun, total, my_stdout.getvalue(), (end - start) * 1000.0)) my_stdout.close() return r
def __call__(self, uuids=None, cassandra_servers=None, force=False, **kwargs): super(CheckBadRefs, self).__call__(**kwargs) self.force = force pool = ConnectionPool('config_db_uuid', server_list=cassandra_servers) uuid_cf = ColumnFamily(pool, 'obj_uuid_table') if uuids: def uuids_g(): for uuid in uuids: yield uuid else: def uuids_g(): for k, v in uuid_cf.get_range(column_count=1, filter_empty=True): yield k for uuid in uuids_g(): values = dict(uuid_cf.xget(uuid)) res = self._get_current_resource(uuid, values) bad_refs = self._check_resource_refs(uuid, values) if not res or bad_refs: printo(self._props_to_json(values)) if not res and not self.check: if self.force or continue_prompt(message="Delete ?"): self._delete(uuid_cf, uuid)
def wrapper(*args): old_stdout = sys.stdout sys.stdout = my_stdout = StringIO() root = logging.getLogger() ch = logging.StreamHandler(my_stdout) ch.setLevel(logging.INFO) formatter = logging.Formatter( '%(asctime)s - %(name)s - %(levelname)s - %(message)s') ch.setFormatter(formatter) root.addHandler(ch) def cleanup(): sys.stdout = old_stdout root.removeHandler(ch) output = my_stdout.getvalue() my_stdout.close() return output try: fun(*args) output = cleanup() printo(output) # return a list for log_json count return range(1, output.count('\n')) except CommandError as e: raise CommandError("%s:\n%s" % (text_type(e), cleanup()))
def wrapper(*args): r = fun(*args) if len(r) > 1: printo('Found %d %s:' % (len(r), fun.__doc__.strip())) for r_ in r: printo(' - %s/%s - %s' % (r_.type, r_.uuid, r_.fq_name)) return r
def __call__(self, **kwargs): super(MigrateHostRoutes, self).__call__(**kwargs) for irt in self.resources: if irt.fq_name[-1].startswith(NEUTRON_IRT_PREFIX): printo("Found IRT to migrate %s" % irt.fq_name) if not self.check: self._migrate(irt)
def clean_acl_without_sg(acls): for acl in acls: try: acl.delete() printo('Deleted %s' % acl) except ResourceNotFound: continue
def clean_vn_with_iip_without_vmi(iips): for iip in iips: try: iip.delete() printo('Deleted %s' % iip) except ResourceNotFound: continue
def _is_stale_snat(self, si): """Return True if the snat SI is stale. """ if 'logical_router_back_refs' not in si: printo('[%s] No logical router attached to SI' % si.uuid) return True return False
def _check_ref(self, ref, uuid): _, ref_type, ref_uuid = ref.split(':') try: Resource(ref_type.replace('_', '-'), uuid=ref_uuid, check=True) return False except ResourceNotFound: printo("[%s] broken ref to missing %s" % (uuid, ref)) return True
def _clean_kv(self, session, stale_subnets, dry_run=False): if continue_prompt("Do you really want to delete these entries ?"): for key in stale_subnets: if not dry_run: session.remove_kv_store(key) printo( "Entry with key \"%s\" has been removed from the KV store" % key)
def test_printo(self): origout = sys.stdout tmpout = io.BytesIO() sys.stdout = tmpout utils.printo('é', encoding='ascii') utils.printo('é', encoding='utf-8') sys.stdout = origout self.assertEqual(tmpout.getvalue(), b'?\n\xc3\xa9\n')
def clean_ri_without_vn(ris): # This will leave RTs, but check_unused_rt will remove # them later for ri in ris: try: ri.delete() printo('Deleted %s' % ri) except ResourceNotFound: pass
def add(self, vn, mode, name): prop = mode_map[mode] if prop not in vn: vn[prop] = {'route_target': []} if name in vn[prop]['route_target']: raise CommandError('RT %s already added' % name) vn[prop]['route_target'].append(name) vn.save() printo('RT %s added to VN' % name)
def check_duplicate_public_ips(g): """duplicate public ips """ r = g.V().hasLabel(within('floating_ip', 'instance_ip')) \ .property('ip_address', __.values('floating_ip_address', 'instance_ip_address')).group().by('ip_address').unfold() \ .filter(lambda: "it.get().value.size() > 1 && it.get().value.findAll{it.label.value == 'floating_ip'} != []").toList() if len(r) > 0: printo('Found %d %s:' % (len(r), check_duplicate_public_ips.__doc__.strip())) return r
def _get_stale_subnets(self, kv, healthy_kv): stale_subnets = [] for _dict in kv: key = _dict['key'] value = _dict['value'] if not (key in healthy_kv and str(value) == healthy_kv[key]): stale_subnets.append(key) printo("Current KV store contains %d stale entries." % len(stale_subnets)) return stale_subnets
def _check(self, project): if project.fq_name == FQName('default-domain:default-project'): return keystone_uuid = project.uuid.replace('-', '') try: self.kclient.tenants.get(keystone_uuid) except HttpError as e: if e.http_status == 404: printo(self.current_path(project)) else: raise
def delete(self, vn, mode, name): prop = mode_map[mode] rt_list = vn.get(prop, {}).get('route_target', []) try: rt_list.remove(name) except ValueError: printo('RT %s not found on VN' % name) return vn[prop]['route_target'] = rt_list vn.save() printo('RT %s deleted from VN' % name)
def _clean_lbaas_si(self, si): printo('[%s] Cleaning stale lbaas' % si.uuid) for pool in si.get('loadbalancer_pool_back_refs', []): pool.fetch() for vip in pool.get('virtual_ip_back_refs', []): vip.fetch() vip_vmis = vip.get('virtual_machine_interface_refs', []) self._delete_res(si, vip) for vmi in vip_vmis: self._delete_res(si, vmi) self._remove_back_ref(si, si, pool)
def _remove_vm(self, vmi, parent): logger.debug("trying to remove vmi vms") # VMs are not linked to the project vmi.fetch() for vm in vmi.refs.virtual_machine: if continue_prompt("Nova VM %s will be deleted" % vm.uuid): printo("deleting nova VM %s" % vm.uuid) self.nclient.servers.delete(vm.uuid) else: raise CommandError("Exiting.") self._delete(vmi)
def _delete(self, resource, parent=None): try: logger.debug("trying to delete %s" % self.current_path(resource)) resource.delete() printo("%s deleted" % self.current_path(resource)) except (ChildrenExists, BackRefsExists) as e: logger.debug("failed: %s" % e) action = self.actions[e.__class__].get( (resource.type, e.resources[0].type), self._delete) for r in e.resources: action(r, resource) self._delete(resource) except ResourceNotFound: pass
def _check_si(self, si): try: si.fetch() except ResourceNotFound: return for vm in si.get('virtual_machine_back_refs', []): vm.fetch() if len(vm.get('virtual_router_back_refs', [])) > 1: printo('SI %s VM %s is scheduled on %s' % ( si.path, vm.uuid, ", ".join([str(vr.fq_name) for vr in vm['virtual_router_back_refs']]))) if self.check is not True: self._clean_vm(vm)
def check_duplicate_ip_addresses(g): """networks with duplicate ip addresses """ r = g.V().hasLabel("virtual_network").as_('vn').flatMap( union( select('vn'), __.in_().hasLabel("instance_ip").has("instance_ip_address").group( ).by("instance_ip_address").unfold().filter( lambda: "it.get().value.size() > 1")).fold().filter( lambda: "it.get().size() > 1")).toList() if len(r) > 0: printo('Found %d %s:' % (len(r), check_duplicate_ip_addresses.__doc__.strip())) for dup in r: # FIXME: dup[0].label = 'virtual_network' # First item is the vn r_ = v_to_r(dup[0]) printo(' - %s/%s - %s' % (r_.type, r_.uuid, r_.fq_name)) for ips in dup[1:]: for ip, iips in ips.items(): printo(" %s:" % ip) for iip in iips: r_ = v_to_r(iip) printo(' - %s/%s - %s' % (r_.type, r_.uuid, r_.fq_name)) return r
def __call__(self, paths=None, **kwargs): super(MigrateSI110221, self).__call__(**kwargs) if not paths: resources = Collection('service-instance', fetch=True) else: resources = expand_paths( paths, predicate=lambda r: r.type == 'service-instance') for si in resources: si.fetch() try: si['service_template_refs'][0] except (KeyError, IndexError): printo('SI %s has no template, skipping.' % si.uuid) continue vms = si.get('virtual_machine_back_refs', []) if not vms: printo('SI %s has no VM, skipping.' % si.uuid) if all([si.fq_name[-1] in str(vm.fq_name) for vm in vms]): continue printo('Found lbaas SI to migrate %s (%s)' % (si.path, si.fq_name)) if not self.check: self._migrate_si(si) printo('Done')
def _is_stale_lbaas(self, si): """Return True if the lbaas SI is stale. """ if 'loadbalancer_pool_back_refs' not in si: printo('[%s] No pool attached to SI' % si.uuid) return True pool = si['loadbalancer_pool_back_refs'][0] pool.fetch() if 'virtual_ip_back_refs' not in pool: printo('[%s] No VIP attached to pool' % si.uuid) return True vip = pool['virtual_ip_back_refs'][0] vip.fetch() if 'virtual_machine_interface_refs' not in vip: printo('[%s] No VMI for VIP' % si.uuid) return True vip_vmi = vip['virtual_machine_interface_refs'][0] vip_vmi.fetch() if 'instance_ip_back_refs' not in vip_vmi: printo('[%s] No IIP found for VIP VMI' % si.uuid) return True return False
def chk(self, item): vn_uuid, subnet_uuid, subnet = item to_add = [] if self.subnet_uuid is not None and self.subnet_uuid != subnet_uuid: return to_add subnet_key = self._subnet_key(vn_uuid, subnet) try: self.session.search_kv_store(subnet_uuid) except HttpError: printo('Missing key %s for subnet %s' % (subnet_uuid, subnet_uuid)) to_add.append((subnet_uuid, subnet_key)) try: self.session.search_kv_store(subnet_key) except HttpError: printo('Missing key %s for subnet %s' % (subnet_key, subnet_uuid)) to_add.append((subnet_key, subnet_uuid)) return to_add
def _migrate_iip(self, old_iip, si, itf_type): new_fq_name = '%s__%s-%s' % (str(si.parent.fq_name).replace( ':', '__'), si.fq_name[-1], itf_type) # there is 2 left itf so migrate the iip only once if str(old_iip.fq_name) == new_fq_name: printo('Already migrated %s. Skip' % old_iip.fq_name) return old_iip self._delete_res(old_iip) iip = copy.deepcopy(old_iip) del iip['uuid'] iip['fq_name'] = FQName([new_fq_name]) iip['display_name'] = new_fq_name iip['name'] = new_fq_name self._create_res(iip) return iip
def __call__(self, on=False, off=False, **kwargs): super(RPF, self).__call__(**kwargs) for vn in self.resources: vn.fetch() if 'virtual_network_properties' not in vn: vn['virtual_network_properties'] = { "allow_transit": None, "forwarding_mode": None, "network_id": vn.get('virtual_network_id', None), "vxlan_network_identifier": None } if off: vn['virtual_network_properties']['rpf'] = 'disable' vn.save() elif on: vn['virtual_network_properties']['rpf'] = None vn.save() else: status = 'on' if vn['virtual_network_properties'].get( 'rpf') is None else 'off' printo("%s : %s" % (self.current_path(vn), status))
def show(self, vn): vns = [vn.uuid] import_export_list = vn.get('route_target_list', {}).get('route_target', []) import_list = vn.get('import_route_target_list', {}).get('route_target', []) export_list = vn.get('export_route_target_list', {}).get('route_target', []) table = [ ["VN", "import/export", "import", "export"], ] def add_row(vn, import_export_rt, import_rt, export_rt): table.append([ vn if vn else "", import_export_rt if import_export_rt else "", import_rt if import_rt else "", export_rt if export_rt else "" ]) map(add_row, vns, import_export_list, import_list, export_list) printo(format_table(table))
def _migrate_si(self, old_si): si_target = old_si.get('loadbalancer_pool_back_refs', [None])[0] if si_target is not None: si_target_uuid = si_target.uuid elif si_target is None: si_target = old_si.get('logical_router_back_refs', [None])[0] si_target_uuid = old_si.fq_name[-1] if si_target is None: printo('No pool or router attached to SI') return new_si = Resource( 'service-instance', fq_name=list(old_si.parent.fq_name) + [si_target_uuid], display_name=si_target_uuid, service_instance_properties=old_si['service_instance_properties'], parent=old_si.parent) new_si['service_template_refs'] = old_si['service_template_refs'] # SNAT si fq_name doesn't change so we create the same # resource and it will conflict re_use = False try: self._create_res(new_si) except Conflict: new_si = old_si re_use = True for old_vm in old_si.get('virtual_machine_back_refs', []): old_vm.fetch() self._remove_back_ref(old_si, old_vm) # VM index is the last char of the fq_name new_vm = self._migrate_vm(old_vm, str(old_vm.fq_name)[-1], new_si) self._add_back_ref(new_si, new_vm) if not re_use: self._remove_back_ref(old_si, si_target) self._delete_res(old_si) self._add_back_ref(new_si, si_target)
def test_set_std_printo(self): FAKE_STRING_NEW_LINE = b"fake string\n" FAKE_STRING_NO_NEW_LINE = "fake string" orig_stdout = sys.stdout orig_stderr = sys.stdout fake_stdout = io.BytesIO() fake_stderr = io.BytesIO() sys.stdout = fake_stdout sys.stderr = fake_stderr def clear_buffers(): fake_stdout.truncate(0) fake_stdout.seek(0) fake_stderr.truncate(0) fake_stderr.seek(0) utils.printo(FAKE_STRING_NO_NEW_LINE) self.assertEqual(fake_stdout.getvalue(), FAKE_STRING_NEW_LINE) self.assertEqual(fake_stderr.getvalue(), b'') clear_buffers() utils.printo(FAKE_STRING_NO_NEW_LINE, std_type='stdout') self.assertEqual(fake_stdout.getvalue(), FAKE_STRING_NEW_LINE) self.assertEqual(fake_stderr.getvalue(), b'') clear_buffers() utils.printo(FAKE_STRING_NO_NEW_LINE, std_type='stderr') self.assertEqual(fake_stdout.getvalue(), b'') self.assertEqual(fake_stderr.getvalue(), FAKE_STRING_NEW_LINE) clear_buffers() utils.printo(FAKE_STRING_NO_NEW_LINE, std_type='fake_std') self.assertEqual(fake_stdout.getvalue(), FAKE_STRING_NEW_LINE) self.assertEqual(fake_stderr.getvalue(), b'') clear_buffers() sys.stdout = orig_stdout sys.stderr = orig_stderr