@Override
public void run() {
StringBuilder sb = new StringBuilder("\nWaveformStartTask run:");
try {
waveformProviders = new WaveformModuleProvider[systems.length];
waveformObjects = new DOFObject[systems.length];
for (int i = 0; i < systems.length; i++) {
SystemConfig systemConfig = nodeConfig.getSystemConfig(fdn, systems[i]);
if (systemConfig == null)
log.error("Invalid ccsc fdn: " + fdn + " and/or system name: " + systems[i]);
else {
DOFSystem system = systemConfig.getSystem();
String creds = systemConfig.credentials.toString();
waveformProviders[i] = new WaveformModuleProvider(serviceOids[i], creds);
waveformObjects[i] = system.createObject(DOFObjectID.create(serviceOids[i]));
waveformProviders[i].beginProvider(waveformObjects[i]);
}
}
statusTracker.setStatus(moduleName, Status.Ok);
node.setModuleStatus(WaveformModule.this, ModuleStatus.Started);
log.debug(sb.toString());
} catch (Exception e) {
log.debug(sb.toString());
log.error("\n" + getClass().getName() + " failed to start", e);
node.setModuleStatus(WaveformModule.this, ModuleStatus.Failed);
}
}
@Override
public void interfaceRemoved(Query operation, DOFObjectID objectID, DOFInterfaceID interfaceID) {
if (!objectID.equals(providerId) || !interfaceID.equals(HubRequestInterface.IID)) return;
log.trace("Hub Request Provider Removed {}:{}", objectID, interfaceID);
// requestProvided.set(false);
GracePeriodExpiredTask gracePeriodExpiredTask = new GracePeriodExpiredTask(this);
synchronized (this) {
if (gracePeriodFuture != null) {
gracePeriodFuture.cancel(true);
gracePeriodFuture = null;
}
gracePeriodExpiredFuture =
hubProvideFactory.timerExecutor.schedule(
gracePeriodExpiredTask, requestorGracePeriodMinutes.get(), TimeUnit.MINUTES);
if (provider != null) provider.requestProvideStopped(-1);
}
}
/* *************************************************************************
* Module implementation
**************************************************************************/
@Override
public void init(Configuration config) throws Exception {
String msg = "ok";
try {
nodeConfig = (NodeConfig) config;
nodeConfig.tabLevel.set(3);
nodeConfig.sb.append("\n");
nodeConfig.toSb(getClass().getName(), " init:");
nodeConfig.tabLevel.incrementAndGet();
List<Entry<String, String>> list =
NodeConfiguration.getPropertiesForBaseKey(PropertyFileNameKey, nodeConfig.properties);
Entry<String, String> entry = list.get(index);
String value = entry.getValue();
nodeConfig.toSb(entry.getKey(), "=", value);
NodeConfiguration.loadProperties(nodeConfig, value);
fdn = nodeConfig.properties.getProperty(NodeConfiguration.FdnKey);
nodeConfig.toSb(NodeConfiguration.FdnKey, "=", fdn);
String systemNames = nodeConfig.properties.getProperty(SystemNameKey);
nodeConfig.toSb(SystemNameKey, "=", systemNames);
systems = systemNames.split(" ");
String services = nodeConfig.properties.getProperty(ServiceIdKey);
nodeConfig.toSb(ServiceIdKey, "=", services);
String[] serviceIds = services.split(" ");
serviceOids = new DOFObjectID[serviceIds.length];
int i = 0;
for (String sid : serviceIds) {
msg = "invalid service oid: " + sid;
serviceOids[i++] = DOFObjectID.create(sid);
}
nodeConfig.properties.remove(PropertyFileNameKey);
nodeConfig.properties.remove(ServiceIdKey);
nodeConfig.properties.remove(SystemNameKey);
nodeConfig.properties.remove(NodeConfiguration.FdnKey);
} catch (Exception e) {
nodeConfig.toSb(msg);
log.error(nodeConfig.sb.toString(), e);
throw e;
}
}
/**
* ************************************************************************
* DOFSystem.QueryOperationListener implementation
* ************************************************************************
*/
@Override
public void interfaceAdded(Query operation, DOFObjectID objectId, DOFInterfaceID interfaceId) {
if (!objectId.equals(providerId) || !interfaceId.equals(HubRequestInterface.IID)) return;
// if (gracePeriodExpired.get())
// return;
// requestProvided.set(true);
log.trace("Hub Request Provider Added {}:{}", objectId, interfaceId);
synchronized (this) {
if (gracePeriodExpiredFuture != null) {
gracePeriodExpiredFuture.cancel(true);
gracePeriodExpiredFuture = null;
provider.requestProvideStarted();
}
if (provider != null) return; // existing state is fine, we are done here.
// first time, or first time after a hubProvideFactory.remove(monitor)
gracePeriodFuture =
hubProvideFactory.executor.submit(new GetGracePeriodTask(this, objectId, interfaceId));
}
}
void getSystemAndStartQuery() {
try {
Authentication groupId = DOFObjectID.Authentication.create(providerId.getBase());
DOFObjectID.Attribute attr = providerId.getAttribute(DOFObjectID.Attribute.GROUP);
Domain domainId = DOFObjectID.Domain.create(attr.getValueObjectID());
DOFCredentials domainCredentials =
DOFCredentials.create(hubProvideFactory.coreCredentials, domainId);
//
// @formatter:off
DOFSystem.Config domainSystemConfig =
new DOFSystem.Config.Builder()
.setName(groupId.getDataString() + "." + domainId.getDataString() + "-DOFSystem")
.setCredentials(domainCredentials)
.setPermissionsExtendAllowed(true)
.setTunnelDomains(true)
.build();
// @formatter:on
DOFDomain.Config domainConfig = new DOFDomain.Config.Builder(domainCredentials).build();
DOFDomain serviceDomain = hubProvideFactory.dof.createDomain(domainConfig);
serviceDomain.addStateListener(this);
long t0 = System.currentTimeMillis();
long to = hubProvideFactory.commTimeout;
synchronized (domainFound) {
while (!domainFound.get()) {
try {
domainFound.wait(to);
if (domainFound.get()) break;
long delta = System.currentTimeMillis() - t0;
if (delta >= hubProvideFactory.commTimeout)
throw new TimeoutException(
"timed out: " + to + " waiting for Domain listener to report completed");
to =
hubProvideFactory.commTimeout
- delta; // spurious wakeup, or wait(to) slightly off System.currentTimeMillis
} finally {
serviceDomain.removeStateListener(this);
}
}
}
DOFSystem system =
hubProvideFactory.dof.createSystem(domainSystemConfig, hubProvideFactory.commTimeout);
systemData = new CreateSystemTask.SystemData(groupId, domainId, domainCredentials, system);
} catch (InterruptedException e) {
hubProvideFactory.removeHubRequestMonitor(providerId);
log.debug("Create system task interrupted.");
return;
} catch (Exception e) {
hubProvideFactory.removeHubRequestMonitor(providerId);
log.debug("Create system failed {} - " + e.getCause(), providerId);
return;
}
synchronized (this) {
if (activateInterestOperation == null || activateInterestOperation.isComplete())
activateInterestOperation =
systemData.system.beginInterest(
systemData.groupId,
HubRequestInterface.IID,
DOFInterestLevel.ACTIVATE,
DOF.TIMEOUT_NEVER,
null,
null);
if (queryOperation == null || queryOperation.isComplete()) {
DOFQuery query =
new DOFQuery.Builder()
.addFilter(providerId)
.addRestriction(HubRequestInterface.IID)
.build();
queryOperation = systemData.system.beginQuery(query, DOF.TIMEOUT_NEVER, this, null);
}
createSystemFuture = null;
log.debug(
"HubManager dof: "
+ hubProvideFactory.dof.getState().getName()
+ " beginQuery for: "
+ providerId.toStandardString()
+ ":"
+ HubRequestInterface.IID);
}
}
