How to use

ExternalEvent

in

io.cattle.platform.core.model

/**
 * {@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() {