public void fire(String path, Object data) { eventf.fire(path, data); } }
private void setupCanonicalEvents(){ evtf.on(PrimaryStorageCanonicalEvent.PRIMARY_STORAGE_HOST_STATUS_CHANGED_PATH, new EventCallback() { @Override protected void run(Map tokens, Object data) { PrimaryStorageCanonicalEvent.PrimaryStorageHostStatusChangeData d = (PrimaryStorageCanonicalEvent.PrimaryStorageHostStatusChangeData)data; if (d.getNewStatus() == PrimaryStorageHostStatus.Disconnected && d.getOldStatus() != PrimaryStorageHostStatus.Disconnected && noStorageAccessible(d.getHostUuid())){ ChangeHostConnectionStateMsg msg = new ChangeHostConnectionStateMsg(); msg.setHostUuid(d.getHostUuid()); msg.setConnectionStateEvent(HostStatusEvent.disconnected.toString()); bus.makeTargetServiceIdByResourceUuid(msg, HostConstant.SERVICE_ID, d.getHostUuid()); bus.send(msg); new HostBase.HostDisconnectedCanonicalEvent(d.getHostUuid(), operr("primary storage[uuid:%s] becomes disconnected, the host has no connected primary storage attached", d.getPrimaryStorageUuid())).fire(); } } }); }
private void onHostStatusChange() { evtf.onLocal(HostCanonicalEvents.HOST_STATUS_CHANGED_PATH, new EventCallback() { @Override protected void run(Map tokens, Object data) { HostCanonicalEvents.HostStatusChangedData d = (HostCanonicalEvents.HostStatusChangedData) data; if (HostStatus.Connected.toString().equals(d.getNewStatus())) { hostDisconnectCount.remove(d.getHostUuid()); } else if (HostStatus.Disconnected.toString().equals(d.getNewStatus()) && HostStatus.Connecting.toString().equals(d.getOldStatus())) { hostDisconnectCount.computeIfAbsent(d.getHostUuid(), key -> new AtomicInteger(0)).addAndGet(1); } } }); }
private void installTriggers() { setup(); DebugUtils.Assert(!eventCallbacks.isEmpty(), String.format("%s[%s] doesn't call onEvent() in the setup() to install any triggers", NAME, getClass())); for (Map.Entry<String, EventCallback> e : eventCallbacks.entrySet()) { evtf.on(e.getKey(), e.getValue()); } canceller = () -> eventCallbacks.values().forEach((it) -> evtf.off(it)); }
@Override public void run(Map tokens, Object data) { if (!evtf.isFromThisManagementNode(tokens)) { return;
@Override public void run(Map tokens, Object data) { if (!evtf.isFromThisManagementNode(tokens)) { return; } PrimaryStorageStatusChangedData d = (PrimaryStorageStatusChangedData) data; if (!PrimaryStorageStatus.Connected.toString().equals(d.getNewStatus())) { return; } SimpleQuery<VolumeVO> q = dbf.createQuery(VolumeVO.class); q.add(VolumeVO_.primaryStorageUuid, Op.EQ, d.getPrimaryStorageUuid()); q.add(VolumeVO_.status, Op.EQ, VolumeStatus.Ready); q.add(VolumeVO_.actualSize, Op.NULL); List<VolumeVO> vols = q.list(); if (vols.isEmpty()) { return; } List<SyncVolumeSizeMsg> msgs = CollectionUtils.transformToList(vols, new Function<SyncVolumeSizeMsg, VolumeVO>() { @Override public SyncVolumeSizeMsg call(VolumeVO arg) { SyncVolumeSizeMsg msg = new SyncVolumeSizeMsg(); msg.setVolumeUuid(arg.getUuid()); bus.makeTargetServiceIdByResourceUuid(msg, VolumeConstant.SERVICE_ID, arg.getUuid()); return msg; } }); bus.send(msgs); } });
private void unlock() { logger.warn(String.format("management node[uuid:%s] becomes unavailable, publish unlock event[unlock key:%s, lock reason:%s] for resource it holds", lmeta.senderManagementUuid, lmeta.unlockKey, lmeta.reason)); evtf.fire(LockResourceMessage.UNLOCK_CANONICAL_EVENT_PATH, lmeta.unlockKey); dismiss(); } };
private void setupCanonicalEvents(){ evtf.on(PrimaryStorageCanonicalEvent.PRIMARY_STORAGE_HOST_STATUS_CHANGED_PATH, new EventCallback() { @Override protected void run(Map tokens, Object data) { PrimaryStorageCanonicalEvent.PrimaryStorageHostStatusChangeData d = (PrimaryStorageCanonicalEvent.PrimaryStorageHostStatusChangeData)data; PrimaryStorageStatus nfsStatus = Q.New(PrimaryStorageVO.class) .eq(PrimaryStorageVO_.uuid, d.getPrimaryStorageUuid()) .eq(PrimaryStorageVO_.type, NfsPrimaryStorageConstant.NFS_PRIMARY_STORAGE_TYPE) .select(PrimaryStorageVO_.status) .findValue(); boolean recoverConnection = d.getNewStatus() == PrimaryStorageHostStatus.Connected && d.getOldStatus() != PrimaryStorageHostStatus.Connected; if (nfsStatus == null || !recoverConnection) { return; } logger.debug(String.format("NFS[uuid:%s] recover connection to host[uuid:%s]", d.getPrimaryStorageUuid(), d.getHostUuid())); if (nfsStatus != PrimaryStorageStatus.Connected) { // use sync call here to make sure the NFS primary storage connected before continue to the next step ChangePrimaryStorageStatusMsg cmsg = new ChangePrimaryStorageStatusMsg(); cmsg.setPrimaryStorageUuid(d.getPrimaryStorageUuid()); cmsg.setStatus(PrimaryStorageStatus.Connected.toString()); bus.makeTargetServiceIdByResourceUuid(cmsg, PrimaryStorageConstant.SERVICE_ID, d.getPrimaryStorageUuid()); bus.call(cmsg); logger.debug(String.format("connect nfs[uuid:%s] completed", d.getPrimaryStorageUuid())); } recalculateCapacity(d.getPrimaryStorageUuid()); } }); }
protected void hookToKVMHostConnectedEventToChangeStatusToConnected(){ evtf.onLocal(HostCanonicalEvents.HOST_STATUS_CHANGED_PATH, new AutoOffEventCallback() {
datas.forEach(it -> evtf.fire(PrimaryStorageCanonicalEvent.PRIMARY_STORAGE_HOST_STATUS_CHANGED_PATH, it));
private void syncVolumeSize() { evtf.on(PrimaryStorageCanonicalEvent.PRIMARY_STORAGE_STATUS_CHANGED_PATH, new EventCallback() { @Override public void run(Map tokens, Object data) {
evtf.onLocal(HostCanonicalEvents.HOST_STATUS_CHANGED_PATH, new AutoOffEventCallback() { @Override protected boolean run(Map tokens, Object data) {
protected void fireDisconnectedCanonicalEvent(ErrorCode reason) { PrimaryStorageCanonicalEvent.DisconnectedData data = new PrimaryStorageCanonicalEvent.DisconnectedData(); data.setPrimaryStorageUuid(self.getUuid()); data.setReason(reason); evtf.fire(PrimaryStorageCanonicalEvent.PRIMARY_STORAGE_DISCONNECTED, data); }
protected void fireDisconnectedCanonicalEvent(ErrorCode reason) { BackupStorageCanonicalEvents.DisconnectedData data = new BackupStorageCanonicalEvents.DisconnectedData(); data.setBackupStorageUuid(self.getUuid()); data.setReason(reason); evtf.fire(BackupStorageCanonicalEvents.BACKUP_STORAGE_DISCONNECTED, data); }
private void syncImageActualSize() { evtf.on(BackupStorageCanonicalEvents.BACKUP_STORAGE_STATUS_CHANGED, new EventCallback() { @Transactional(readOnly = true) private List<ImageInventory> getImagesForSync(String bsUuid) {
evtf.fire(PrimaryStorageCanonicalEvent.PRIMARY_STORAGE_HOST_STATUS_CHANGED_PATH, data);
@Override public void run(FlowTrigger trigger, Map data) { evtf.on(ManagementNodeCanonicalEvent.NODE_LIFECYCLE_PATH, nodeLifeCycleCallback); trigger.next(); } }).then(new NoRollbackFlow() {
private void handleAnonymousVm(final String vmUuid, final VmInstanceState actualState, VmInstanceState expected) { final VmInstanceVO vm = dbf.findByUuid(vmUuid, VmInstanceVO.class); if (vm == null) { logger.debug(String.format("[Vm Tracer] detects stranger vm[identity:%s, state:%s]", vmUuid, actualState)); String cachedHostUuid = strangeVms.get(vmUuid); if (cachedHostUuid != null) { logger.debug(String.format("[Vm Tracer] detects stranger vm[identity:%s, state:%s] but it's already in cache, skip firing event", vmUuid, actualState)); return; } strangeVms.put(vmUuid, hostUuid); VmTracerCanonicalEvents.StrangerVmFoundData data = new VmTracerCanonicalEvents.StrangerVmFoundData(); data.setVmIdentity(vmUuid); data.setVmState(actualState); data.setHostUuid(hostUuid); evtf.fire(VmTracerCanonicalEvents.STRANGER_VM_FOUND_PATH, data); N.New(VmInstanceVO.class, vmUuid).warn_("A strange vm[%s] was found on the host[%s], May cause problems, Please manually clean this vm", vmUuid, hostUuid); return; } handleStateChangeOnHostSide(vmUuid, actualState, expected); }
@Override public void run(final SyncTaskChain chain) { logger.debug(String.format("locked vm[uuid:%s] for %s", self.getUuid(), msg.getReason())); evtf.on(LockResourceMessage.UNLOCK_CANONICAL_EVENT_PATH, new AutoOffEventCallback() { @Override public boolean run(Map tokens, Object data) { if (msg.getUnlockKey().equals(data)) { logger.debug(String.format("unlocked vm[uuid:%s] that was locked by %s", self.getUuid(), msg.getReason())); chain.next(); return true; } return false; } }); LockVmInstanceReply reply = new LockVmInstanceReply(); bus.reply(msg, reply); }