/** * {@inheritDoc} */ @Override public void from(io.cattle.platform.core.model.ExternalEvent from) { setId(from.getId()); setAccountId(from.getAccountId()); setKind(from.getKind()); setUuid(from.getUuid()); setState(from.getState()); setCreated(from.getCreated()); setData(from.getData()); setExternalId(from.getExternalId()); setEventType(from.getEventType()); setReportedAccountId(from.getReportedAccountId()); }
/** * {@inheritDoc} */ @Override public <E extends io.cattle.platform.core.model.ExternalEvent> E into(E into) { into.from(this); return into; }
void deleteService(ExternalEvent event, Map<String, Object> serviceData) { Service svc = serviceDao.getServiceByExternalId(event.getAccountId(), event.getExternalId()); if (svc != null) { objectProcessManager.scheduleStandardProcess(StandardProcess.REMOVE, svc, null); } }
@Override public HandlerResult handle(ProcessState state, ProcessInstance process) { ExternalEvent event = (ExternalEvent)state.getResource(); if (StringUtils.isEmpty(event.getExternalId())) { log.debug("External event doesn't have an external id: {}", event.getId()); return null; } if (ExternalEventConstants.KIND_VOLUME_EVENT.equals(event.getKind())) { handleVolumeEvent(event, state, process); } else if (ExternalEventConstants.KIND_STORAGE_POOL_EVENT.equals(event.getKind())) { handleStoragePoolEvent(event, state, process); } else if (ExternalEventConstants.KIND_EXTERNAL_DNS_EVENT.equals(event.getKind())) { handleExternalDnsEvent(event, state, process); } return null; }
@Override public Collection<? extends Service> getServices(Object obj) { if (obj == null) { return null; } Long accountId = null; if (obj instanceof Host) { Host host = (Host) obj; accountId = host.getAccountId(); } else if (obj instanceof HostLabelMap) { HostLabelMap m = (HostLabelMap) obj; accountId = m.getAccountId(); } else if (obj instanceof ExternalEvent) { ExternalEvent event = (ExternalEvent)obj; if (KIND_EXTERNAL_HOST_EVENT.equals(event.getKind()) && TYPE_SCHEDULER_UPDATE.equals(event.getEventType())) { accountId = event.getAccountId(); } } if (accountId == null) { return null; } List<? extends Service> services = expMapDao.getActiveServices(accountId); List<Service> activeGlobalServices = new ArrayList<Service>(); for (Service service : services) { if (sdSvc.isGlobalService(service) || sdSvc.isScalePolicyService(service)) { activeGlobalServices.add(service); } } return activeGlobalServices; }
final ExternalEvent event = (ExternalEvent)state.getResource(); if (!ExternalEventConstants.KIND_SERVICE_EVENT.equals(event.getKind())) { return null; lockManager.lock(new ExternalEventLock(SERVICE_LOCK_NAME, event.getAccountId(), event.getExternalId()), new LockCallbackNoReturn() { @Override public void doWithLockNoResult() {
@Override public void doWithLockNoResult() { Volume volume = volumeDao.findVolumeByExternalId(storagePool.getId(), event.getExternalId()); switch (event.getEventType()) { case ExternalEventConstants.TYPE_VOLUME_CREATE: if (volume == null) { Map<String, Object> volumeData = CollectionUtils.toMap(DataUtils.getFields(event).get(FIELD_VOLUME)); if (volumeData.isEmpty()) { log.warn("Empty volume for externalVolumeEvent: {}. StoragePool: {}", event, volumeData); return; } volumeData.put(ObjectMetaDataManager.ACCOUNT_FIELD, event.getAccountId()); volumeData.put(FIELD_ATTACHED_STATE, CommonStatesConstants.INACTIVE); volumeData.put(FIELD_ALLOC_STATE, CommonStatesConstants.ACTIVE); volumeData.put(FIELD_ZONE_ID, 1L); volumeData.put(FIELD_DEV_NUM, -1); try { volumeDao.createVolumeInStoragePool(volumeData, name.toString(), storagePool); } catch (ProcessCancelException e) { log.info("Create process cancelled for volumeData {}. ProcessCancelException message: {}", volumeData, e.getMessage()); } } break; default: log.error("Unknown event type: {} for event {}", event.getEventType(), event); return; } } });
@Override public HandlerResult handle(ProcessState state, ProcessInstance process) { // event's account id is set to the agent that submitted. This will change it to the actual user's account id. ExternalEvent event = (ExternalEvent)state.getResource(); List<Agent> agents = objectManager.find(Agent.class, AGENT.ACCOUNT_ID, event.getAccountId()); if (agents.size() == 1) { Agent agent = agents.get(0); Long resourceAccId = DataAccessor.fromDataFieldOf(agent).withKey(AgentConstants.DATA_AGENT_RESOURCES_ACCOUNT_ID).as(Long.class); Map<String, Object> data = new HashMap<String, Object>(); if (resourceAccId != null) { data.put(ObjectMetaDataManager.ACCOUNT_FIELD, resourceAccId); } if (event.getReportedAccountId() != null) { data.put(ExternalEventConstants.FIELD_REPORTED_ACCOUNT_ID, event.getReportedAccountId()); } else { data.put(ExternalEventConstants.FIELD_REPORTED_ACCOUNT_ID, event.getAccountId()); } return new HandlerResult(data); } return null; }
@Override public HandlerResult handle(ProcessState state, ProcessInstance process) { ExternalEvent event = (ExternalEvent)state.getResource(); if (!ExternalEventConstants.KIND_EXTERNAL_HOST_EVENT.equals(event.getKind()) || !ExternalEventConstants.TYPE_HOST_EVACUATE.equals(event.getEventType())) { return null; } boolean delete = DataAccessor.fieldBool(event, ExternalEventConstants.FIELD_DELETE_HOST); List<Long> hosts = getHosts(event); for (long hostId : hosts) { Host host = objectManager.loadResource(Host.class, hostId); if (host == null) { continue; } try { deactivateHost(state, host); } catch (ProcessCancelException e) { } if (delete) { host = objectManager.reload(host); try { remove(host, state.getData()); } catch (ProcessCancelException e) { } host = objectManager.reload(host); purge(host, state.getData()); } } return null; }
@Override public void doWithLockNoResult() { String fqdn = DataAccessor.fieldString(event, ExternalEventConstants.FIELD_FQDN); String serviceName = DataAccessor .fieldString(event, ExternalEventConstants.FIELD_SERVICE_NAME); String stackName = DataAccessor.fieldString(event, ExternalEventConstants.FIELD_STACK_NAME); if (fqdn == null || serviceName == null || stackName == null) { log.info("External DNS [event: " + event.getId() + "] misses some fields"); return; } Stack stack = objectManager.findAny(Stack.class, STACK.ACCOUNT_ID, event.getAccountId(), STACK.REMOVED, null, STACK.NAME, stackName); if (stack == null) { log.info("Stack not found for external DNS [event: " + event.getId() + "]"); return; } Service service = objectManager.findAny(Service.class, SERVICE.ACCOUNT_ID, event.getAccountId(), SERVICE.REMOVED, null, SERVICE.STACK_ID, stack.getId(), SERVICE.NAME, serviceName); if (service == null) { log.info("Service not found for external DNS [event: " + event.getId() + "]"); return; } Map<String, Object> data = new HashMap<>(); data.put(ExternalEventConstants.FIELD_FQDN, fqdn); DataUtils.getWritableFields(service).putAll(data); objectManager.persist(service); objectProcessManager.scheduleStandardProcessAsync(StandardProcess.UPDATE, service, data); } });
protected List<Long> getHosts(ExternalEvent event) { List<Long> hosts = new ArrayList<>(); String label = DataAccessor.fieldString(event, ExternalEventConstants.FIELD_HOST_LABEL); if (StringUtils.isNotBlank(label)) { Map<String, String> labels = new HashMap<>(); labels.put(HostAffinityConstraint.LABEL_HEADER_AFFINITY_HOST_LABEL, DataAccessor.fieldString(event, ExternalEventConstants.FIELD_HOST_LABEL)); hosts.addAll(allocationHelper.getAllHostsSatisfyingHostAffinity(event.getAccountId(), labels)); } Long hostId = DataAccessor.fieldLong(event, ExternalEventConstants.FIELD_HOST_ID); if (hostId != null) { hosts.add(hostId); } return hosts; }
@Override public void doWithLockNoResult() { Map<String, Object> serviceData = CollectionUtils.toMap(DataUtils.getFields(event).get(FIELD_SERVICE)); if (serviceData.isEmpty()) { log.warn("Empty service for externalServiceEvent: {}.", event); return; } String kind = serviceData.get(ObjectMetaDataManager.KIND_FIELD) != null ? serviceData.get(ObjectMetaDataManager.KIND_FIELD).toString() : null; if (StringUtils.isEmpty(kind) || schemaFactory.getSchema(kind) == null) { log.warn("Couldn't find schema for service type [{}]. Returning.", kind); return; } if (StringUtils.equals(event.getEventType(), TYPE_SERVICE_CREATE)) { createService(event, serviceData); } else if (StringUtils.equals(event.getEventType(), TYPE_SERVICE_UPDATE)) { updateService(event, serviceData); } else if (StringUtils.equals(event.getEventType(), TYPE_SERVICE_DELETE)) { deleteService(event, serviceData); } else if (StringUtils.equals(event.getEventType(), TYPE_STACK_DELETE)) { deleteStack(event, serviceData); } } });
void deleteStack(ExternalEvent event, Map<String, Object> stackData) { Stack env = stackDao.getStackByExternalId(event.getAccountId(), event.getExternalId()); if (env != null) { objectProcessManager.scheduleStandardProcess(StandardProcess.REMOVE, env, null); } }
List<? extends StoragePool> pools = storagePoolDao.findStoragePoolByDriverName(event.getAccountId(), driverName); StoragePool storagePool = pools.size() > 0 ? pools.get(0) : null; Map<String, Object> spData = CollectionUtils.toMap(DataUtils.getFields(event).get(FIELD_STORAGE_POOL)); spData.put(ObjectMetaDataManager.ACCOUNT_FIELD, event.getAccountId()); spData.put(FIELD_ZONE_ID, 1L); Agent agent = objectManager.findOne(Agent.class, AGENT.ACCOUNT_ID, event.getReportedAccountId(), AGENT.STATE, CommonStatesConstants.ACTIVE); spData.put(FIELD_AGENT_ID, agent.getId()); Agent agent = objectManager.findOne(Agent.class, AGENT.ACCOUNT_ID, event.getReportedAccountId(), AGENT.STATE, CommonStatesConstants.ACTIVE); spData.put(FIELD_AGENT_ID, agent.getId());
Stack stack = stackDao.getStackByExternalId(event.getAccountId(), envExtId); newEnv.setAccountId(event.getAccountId()); String name = possibleName != null ? possibleName.toString() : envExtId; newEnv.setName(name);
protected void handleExternalDnsEvent(final ExternalEvent event, ProcessState state, ProcessInstance process) { lockManager.lock(new ExternalEventLock(EXERNAL_DNS_LOCK_NAME, event.getAccountId(), event.getExternalId()), new LockCallbackNoReturn() { @Override
void updateService(ExternalEvent event, Map<String, Object> serviceData) { Service svc = serviceDao.getServiceByExternalId(event.getAccountId(), event.getExternalId()); if (svc == null) { log.info("Unable to find service while attempting to update. Returning. Service external id: [{}], account id: [{}]", event.getExternalId(), event.getAccountId()); return; } Map<String, Object> fields = DataUtils.getFields(svc); Map<String, Object> updates = new HashMap<String, Object>(); for (Map.Entry<String, Object> resourceField : serviceData.entrySet()) { String fieldName = resourceField.getKey(); Object newFieldValue = resourceField.getValue(); Object currentFieldValue = fields.get(fieldName); if (ObjectUtils.hasWritableProperty(svc, fieldName)) { Object property = ObjectUtils.getProperty(svc, fieldName); if (newFieldValue != null && !newFieldValue.equals(property) || property == null) { updates.put(fieldName, newFieldValue); } } else if ((newFieldValue != null && !newFieldValue.equals(currentFieldValue)) || currentFieldValue != null) { updates.put(fieldName, newFieldValue); } } if (!updates.isEmpty()) { objectManager.setFields(svc, updates); resourceDao.updateAndSchedule(svc); } }
protected void handleStoragePoolEvent(final ExternalEvent event, ProcessState state, ProcessInstance process) { lockManager.lock(new ExternalEventLock(STORAGE_POOL_LOCK_NAME, event.getAccountId(), event.getExternalId()), new LockCallbackNoReturn() { @Override public void doWithLockNoResult() {
void createService(ExternalEvent event, Map<String, Object> serviceData) { Service svc = serviceDao.getServiceByExternalId(event.getAccountId(), event.getExternalId()); if (svc != null) { return; SERVICE.REMOVED, null, SERVICE.STACK_ID, stack.getId(), SERVICE.ACCOUNT_ID, event.getAccountId(), SERVICE.KIND, ServiceConstants.KIND_KUBERNETES_SERVICE); !existingSvc.getExternalId().equals(event.getExternalId())) { log.info("Deleting existing kubernetes service {} with externalId {}", existingSvc.getName(), existingSvc.getExternalId()); service.putAll(serviceData); service.put(ObjectMetaDataManager.ACCOUNT_FIELD, event.getAccountId()); service.put(FIELD_STACK_ID, stack.getId()); } catch (ProcessCancelException e) { log.info("Create and activate process cancelled for service with account id {}and external id {}", event.getAccountId(), event.getExternalId());
List<? extends StoragePool> pools = storagePoolDao.findStoragePoolByDriverName(event.getAccountId(), driverName); if (pools.size() == 0) { log.warn("Unknown storage pool. Returning. Driver name: {}", driverName); lockManager.lock(new DockerStoragePoolVolumeCreateLock(storagePool, event.getExternalId()), new LockCallbackNoReturn() { @Override public void doWithLockNoResult() {