@Override public String call(String arg) { return destinationMaker.isManagedByUs(arg) ? arg : null; } });
private void httpSend() { buildSchema(msg); String ip = destMaker.getNodeInfo(managementNodeId).getNodeIP(); httpSend(ip); }
@Override public void nodeLeft(ManagementNodeInventory inv) { final String nodeId = inv.getUuid(); if (!destinationMaker.getManagementNodesInHashRing().contains(nodeId)) { logger.debug(String.format("the management node[uuid:%s] is not in our hash ring, ignore this node-left call", nodeId)); return; } ManagementNodeChangeListener l = (ManagementNodeChangeListener) destinationMaker; l.nodeLeft(inv); CollectionUtils.safeForEach(lifeCycleExtension, new ForEachFunction<ManagementNodeChangeListener>() { @Override public void run(ManagementNodeChangeListener arg) { arg.nodeLeft(inv); } }); }
destinationMaker.getManagementNodesInHashRing().forEach(nodeUuid -> { if (!nodeUuidsInDb.contains(nodeUuid)) { logger.warn(String.format("found that a management node[uuid:%s] had no heartbeat in database but still in our hash ring," + inv = new ManagementNodeInventory(); inv.setUuid(nodeUuid); inv.setHostName(destinationMaker.getNodeInfo(nodeUuid).getNodeIP()); if (!destinationMaker.getManagementNodesInHashRing().contains(n.getUuid())) { new Runnable() { @Override
@Override public String makeTargetServiceIdByResourceUuid(String serviceId, String resourceUuid) { DebugUtils.Assert(serviceId!=null, "serviceId cannot be null"); DebugUtils.Assert(resourceUuid!=null, "resourceUuid cannot be null"); String mgmtUuid = destMaker.makeDestination(resourceUuid); return serviceId + "." + mgmtUuid; }
private void eventSend() { buildSchema(msg); localSend(); destMaker.getAllNodeInfo().forEach(node -> { if (!node.getNodeUuid().equals(Platform.getManagementServerId())) { httpSend(node.getNodeIP()); } }); }
@Override public String makeTargetServiceIdByResourceUuid(String serviceId, String resourceUuid) { DebugUtils.Assert(serviceId!=null, "serviceId cannot be null"); DebugUtils.Assert(resourceUuid!=null, "resourceUuid cannot be null"); String mgmtUuid = destMaker.makeDestination(resourceUuid); return toServiceId(serviceId, mgmtUuid); }
@Override public void reScanVolume() { volumeUuids.clear(); volumeUuids.addAll(getNeedRefreshSizeVolumeUuids().stream() .filter(it -> destMaker.isManagedByUs(it)) .collect(Collectors.toList())); }
@Override public void nodeJoin(ManagementNodeInventory inv) { final String nodeId = inv.getUuid(); if (destinationMaker.getManagementNodesInHashRing().contains(nodeId)) { logger.debug(String.format("the management node[uuid:%s] is already in our hash ring, ignore this node-join call", nodeId)); return; } ManagementNodeChangeListener l = (ManagementNodeChangeListener) destinationMaker; l.nodeJoin(inv); CollectionUtils.safeForEach(lifeCycleExtension, new ForEachFunction<ManagementNodeChangeListener>() { @Override public void run(ManagementNodeChangeListener arg) { arg.nodeJoin(inv); } }); }
@Override protected void scripts() { long count = sql("select count(h) from HostVO h", Long.class).find(); sql("select h.uuid from HostVO h", String.class).limit(1000).paginate(count, (List<String> hostUuids) -> { List<String> byUs = hostUuids.stream().filter(huuid -> { if (skipExisting) { return destMaker.isManagedByUs(huuid) && !trackers.containsKey(huuid); } else { return destMaker.isManagedByUs(huuid); } }).collect(Collectors.toList()); trackHost(byUs); }); } }.execute();
@Override protected void scripts() { long count = sql("select count(bs) from BackupStorageVO bs", Long.class).find(); sql("select bs.uuid from BackupStorageVO bs", String.class).limit(1000).paginate(count, (List<String> bsUuids) -> { List<String> byUs = bsUuids.stream() .filter(bsUuid -> destMaker.isManagedByUs(bsUuid)) .collect(Collectors.toList()); track(byUs); }); } }.execute();
@Override protected void scripts() { long count = sql("select count(ps) from PrimaryStorageVO ps", Long.class).find(); sql("select ps.uuid from PrimaryStorageVO ps", String.class).limit(1000).paginate(count, (List<String> psUuids) -> { List<String> byUs = psUuids.stream() .filter(psUuid -> destMaker.isManagedByUs(psUuid)) .collect(Collectors.toList()); track(byUs); }); } }.execute();
private List<String> getPrimaryStorageManagedByUs(boolean skipConnected) { List<String> ret = new ArrayList<>(); SimpleQuery<PrimaryStorageVO> q = dbf.createQuery(PrimaryStorageVO.class); q.select(PrimaryStorageVO_.uuid); if (skipConnected) { // treat connecting as disconnected q.add(PrimaryStorageVO_.status, Op.NOT_EQ, PrimaryStorageStatus.Connected); } List<String> uuids = q.listValue(); for (String uuid : uuids) { if (destMaker.isManagedByUs(uuid)) { ret.add(uuid); } } return ret; }
private List<String> getBackupStorageManagedByUs(boolean skipConnected) { List<String> ret = new ArrayList<String>(); SimpleQuery<BackupStorageVO> q = dbf.createQuery(BackupStorageVO.class); q.select(BackupStorageVO_.uuid); if (skipConnected) { // treat connecting as disconnected q.add(BackupStorageVO_.status, SimpleQuery.Op.NOT_EQ, BackupStorageStatus.Connected); } List<String> uuids = q.listValue(); for (String uuid : uuids) { if (destMaker.isManagedByUs(uuid)) { ret.add(uuid); } } return ret; }
private List<String> getTargetVmUuids() { List<String> result = new ArrayList<>(); List<String> allVmUuids = Q.New(VmInstanceVO.class) .select(VmInstanceVO_.uuid) .eq(VmInstanceVO_.type, VmInstanceConstant.USER_VM_TYPE) .eq(VmInstanceVO_.hypervisorType, VmInstanceConstant.KVM_HYPERVISOR_TYPE) .listValues(); for (String vmUuid : allVmUuids) { if (destinationMaker.isManagedByUs(vmUuid)) { result.add(vmUuid); } } if (result.isEmpty()) { return result; } List<String> hasCdRomVmUuids = Q.New(VmCdRomVO.class) .select(VmCdRomVO_.vmInstanceUuid) .in(VmCdRomVO_.vmInstanceUuid, result) .listValues(); result.removeAll(hasCdRomVmUuids); return result; } }
private void loadOrphanJobs() { List<GarbageCollectorVO> vos = Q.New(GarbageCollectorVO.class) .eq(GarbageCollectorVO_.status, GCStatus.Idle) .isNull(GarbageCollectorVO_.managementNodeUuid) .list(); int count = 0; for (GarbageCollectorVO vo : vos) { if (!destinationMaker.isManagedByUs(vo.getUuid())) { continue; } loadGCJob(vo); count ++; } logger.debug(String.format("[GC] loaded %s orphan jobs", count)); }
private Bucket getHostManagedByUs() { int qun = 10000; long amount = dbf.count(HostVO.class); int times = (int) (amount / qun) + (amount % qun != 0 ? 1 : 0); List<String> connected = new ArrayList<String>(); List<String> disconnected = new ArrayList<String>(); int start = 0; for (int i = 0; i < times; i++) { SimpleQuery<HostVO> q = dbf.createQuery(HostVO.class); q.select(HostVO_.uuid, HostVO_.status); q.setLimit(qun); q.setStart(start); List<Tuple> lst = q.listTuple(); start += qun; for (Tuple t : lst) { String huuid = t.get(0, String.class); if (!destMaker.isManagedByUs(huuid)) { continue; } HostStatus state = t.get(1, HostStatus.class); if (state == HostStatus.Connected) { connected.add(huuid); } else { // for Disconnected and Connecting, treat as Disconnected disconnected.add(huuid); } } } return Bucket.newBucket(connected, disconnected); }
private List<String> getHostManagedByUs() { int qun = 10000; long amount = dbf.count(HostVO.class); int times = (int) (amount / qun) + (amount % qun != 0 ? 1 : 0); List<String> hostUuids = new ArrayList<String>(); int start = 0; for (int i = 0; i < times; i++) { SimpleQuery<KVMHostVO> q = dbf.createQuery(KVMHostVO.class); q.select(HostVO_.uuid); // disconnected host will be handled by HostManager q.add(HostVO_.status, SimpleQuery.Op.EQ, HostStatus.Connected); q.setLimit(qun); q.setStart(start); List<String> lst = q.listValue(); start += qun; for (String huuid : lst) { if (!destMaker.isManagedByUs(huuid)) { continue; } hostUuids.add(huuid); } } return hostUuids; }
@Override protected List<LongJobVO> scripts() { // check long jobs using same uuid with current node List<LongJobVO> vos = Q.New(LongJobVO.class) .eq(LongJobVO_.managementNodeUuid, Platform.getManagementServerId()) .eq(LongJobVO_.state, LongJobState.Running) .list(); vos.forEach(vo -> { if (destinationMaker.isManagedByUs(vo.getUuid())) { vo.setJobResult("Failed because management node restarted."); vo.setState(LongJobState.Failed); merge(vo); } }); vos = Q.New(LongJobVO.class).isNull(LongJobVO_.managementNodeUuid).list(); vos.removeIf(it -> !destinationMaker.isManagedByUs(it.getUuid())); vos.forEach(it -> { it.setManagementNodeUuid(Platform.getManagementServerId()); merge(it); }); return vos; } }.execute();
private List<Tuple> getDeletedImageManagedByUs() { int qun = 1000; SimpleQuery q = dbf.createQuery(ImageBackupStorageRefVO.class); q.add(ImageBackupStorageRefVO_.status, Op.EQ, ImageStatus.Deleted); long amount = q.count(); int times = (int) (amount / qun) + (amount % qun != 0 ? 1 : 0); int start = 0; List<Tuple> ret = new ArrayList<Tuple>(); for (int i = 0; i < times; i++) { q = dbf.createQuery(ImageBackupStorageRefVO.class); q.select(ImageBackupStorageRefVO_.imageUuid, ImageBackupStorageRefVO_.lastOpDate, ImageBackupStorageRefVO_.backupStorageUuid); q.add(ImageBackupStorageRefVO_.status, Op.EQ, ImageStatus.Deleted); q.setLimit(qun); q.setStart(start); List<Tuple> ts = q.listTuple(); start += qun; for (Tuple t : ts) { String imageUuid = t.get(0, String.class); if (!destMaker.isManagedByUs(imageUuid)) { continue; } ret.add(t); } } return ret; }