/**
* Update all known Provisioners of the new ResourceCapability
*
* @param resourceCapability The ResourceCapability object
* @param deployedServices List of deployed services
*/
void updateMonitors(
ResourceCapability resourceCapability, List<DeployedService> deployedServices) {
ProvisionLeaseManager[] mgrs;
synchronized (leaseTable) {
Collection<ProvisionLeaseManager> c = leaseTable.values();
mgrs = c.toArray(new ProvisionLeaseManager[c.size()]);
}
if (mgrs == null) return;
if (mgrs.length == 0) return;
for (ProvisionLeaseManager mgr : mgrs) {
try {
mgr.provisioner.update(
adapter.getInstantiator(), resourceCapability, deployedServices, serviceLimit);
} catch (Throwable t) {
if (logger.isLoggable(Level.FINEST))
logger.log(Level.FINEST, "Updating ProvisionManager", t);
boolean connected = false;
/* Determine if we should even try to reconnect */
final int category = ThrowableConstants.retryable(t);
if (category == ThrowableConstants.INDEFINITE
|| category == ThrowableConstants.UNCATEGORIZED) {
connected = mgr.reconnect();
}
if (!connected) {
removeProvisionManager(mgr.provisioner, mgr.serviceID);
}
}
}
}
/**
* Register to a Provisioner
*
* @param item The ServiceItem of a discovered Provisioner
*/
void register(ServiceItem item) {
try {
if (haveRegistration(item)) {
if (logger.isLoggable(Level.FINEST))
logger.log(Level.FINEST, "Already registered to {0}", new Object[] {item.service});
return;
}
ProvisionManager provisioner =
(ProvisionManager) provisionerPreparer.prepareProxy(item.service);
if (logger.isLoggable(Level.FINEST))
logger.log(
Level.FINEST, "ServiceConsumer - prepared ProvisionManager proxy: {0}", provisioner);
ResourceCapability rCap = adapter.getResourceCapability();
if (logger.isLoggable(Level.FINEST))
logger.log(Level.FINEST, "ResourceCapability {0}", new Object[] {rCap});
Lease lease = connect(provisioner);
if (lease == null) {
logger.log(
Level.WARNING,
"Unable to register to ProvisionManager {0}",
new Object[] {provisioner.toString()});
return;
}
leaseTable.put(item.service, new ProvisionLeaseManager(lease, provisioner, item.serviceID));
logger.log(Level.INFO, "Registered to a ProvisionManager");
} catch (Throwable t) {
provisioners.remove(item.serviceID);
logger.log(Level.SEVERE, "Registering ProvisionManager", t);
}
}
/**
* Construct a ServiceConsumer
*
* @param adapter The CybernodeAdapter
* @param serviceLimit The maximum number of services the Cybernode has been configured to
* instantiate
* @param config The Configuration object used to obtain operational values
* @throws ConfigurationException if errors occur accessing the configuration
*/
ServiceConsumer(CybernodeAdapter adapter, int serviceLimit, Configuration config)
throws ConfigurationException {
if (adapter == null) throw new NullPointerException("CybernodeAdapter is null");
if (config == null) throw new NullPointerException("config is null");
this.adapter = adapter;
this.config = config;
/* Establish the lease duration */
long ONE_MINUTE = 1000 * 60;
long DEFAULT_LEASE_TIME = ONE_MINUTE * 30; /* 30 minutes */
long MIN_LEASE_TIME = 10 * 1000; /* 10 seconds */
provisionerLeaseDuration =
Config.getLongEntry(
config,
CybernodeImpl.CONFIG_COMPONENT,
"provisionerLeaseDuration",
DEFAULT_LEASE_TIME,
MIN_LEASE_TIME,
Long.MAX_VALUE);
/* Get the retry count if we disconnect from a provisioner */
int DEFAULT_RETRY_COUNT = 3;
int MIN_RETRY_COUNT = 0;
provisionerRetryCount =
Config.getIntEntry(
config,
CybernodeImpl.CONFIG_COMPONENT,
"provisionerRetryCount",
DEFAULT_RETRY_COUNT,
MIN_RETRY_COUNT,
Integer.MAX_VALUE);
/* Get the amount of time to wait between retries */
long DEFAULT_RETRY_DELAY = 1000; /* 1 second */
long MIN_RETRY_DELAY = 0;
provisionerRetryDelay =
Config.getLongEntry(
config,
CybernodeImpl.CONFIG_COMPONENT,
"provisionerRetryDelay",
DEFAULT_RETRY_DELAY,
MIN_RETRY_DELAY,
Long.MAX_VALUE);
if (logger.isLoggable(Level.FINEST))
logger.log(
Level.FINEST,
"LeaseDuration={0}, RetryCount={1}, RetryDelay={2}",
new Object[] {provisionerLeaseDuration, provisionerRetryCount, provisionerRetryDelay});
/* Get the ProxyPreparer for discovered ProvisionMonitor instances */
provisionerPreparer =
(ProxyPreparer)
config.getEntry(
CybernodeImpl.CONFIG_COMPONENT,
"provisionerPreparer",
ProxyPreparer.class,
new BasicProxyPreparer());
if (logger.isLoggable(Level.FINEST))
logger.log(Level.FINEST, "ProxyPreparer={0}", provisionerPreparer);
leaseTable = new Hashtable<Object, ProvisionLeaseManager>();
this.serviceLimit = serviceLimit;
computeResourceObserver = new ComputeResourceObserver(adapter.getComputeResource());
}
/** Destroy the ServiceConsumer */
void destroy() {
try {
adapter.getComputeResource().deleteObserver(computeResourceObserver);
lCache.removeListener(this);
cancelRegistrations();
synchronized (provisioners) {
provisioners.clear();
}
} finally {
destroyed = true;
}
}
/*
* Get the DeployedService instances
*/
List<DeployedService> getServiceDeployments() {
return adapter.getDeployedServices();
}
/**
* Attempt to connect to the ProvisionMonitor
*
* @param provisioner The provision monitor to connect to
* @return The Lease the ProvisionMonitor has returned, or null if a valid Lease could not be
* obtained
*/
synchronized Lease connect(ProvisionManager provisioner) {
boolean connected = false;
Lease lease = null;
for (int i = 1; i <= provisionerRetryCount; i++) {
try {
EventRegistration er =
provisioner.register(
adapter.getInstantiator(),
null,
adapter.getResourceCapability(),
getServiceDeployments(),
serviceLimit,
provisionerLeaseDuration);
lease = (Lease) provisionerPreparer.prepareProxy(er.getLease());
long leaseTime = lease.getExpiration() - System.currentTimeMillis();
if (leaseTime > 0) {
if (logger.isLoggable(Level.FINE))
logger.log(Level.FINE, "Established ProvisionManager registration");
connected = true;
break;
} else {
logger.log(
Level.WARNING,
"Invalid Lease time ["
+ leaseTime
+ "] returned from "
+ "ProvisionManager, retry count ["
+ i
+ "]");
try {
lease.cancel();
} catch (Exception e) {
if (logger.isLoggable(Level.FINEST))
logger.log(Level.FINEST, "Cancelling Lease with invalid lease time", e);
}
try {
Thread.sleep(provisionerRetryDelay);
} catch (InterruptedException ie) {
/* should not happen */
}
}
} catch (SecurityException e) {
// cancelRegistration(provisioner);
logger.log(Level.WARNING, "ProvisionManager security exception", e);
break;
} catch (Exception e) {
Throwable cause = ThrowableUtil.getRootCause(e);
logger.warning(
"Recovering ProvisionManager Lease attempt "
+ "retry count ["
+ i
+ "] "
+ cause.getClass().getName()
+ ": "
+ cause.getMessage());
/* Determine if we should even try to reconnect */
final int category = ThrowableConstants.retryable(e);
if (category == ThrowableConstants.INDEFINITE
|| category == ThrowableConstants.UNCATEGORIZED) {
try {
Thread.sleep(provisionerRetryDelay);
} catch (InterruptedException ie) {
/* should not happen */
}
}
}
}
/* If we're not connected, set lease to null and return */
if (!connected) lease = null;
return (lease);
}
/**
* Update all known Provisioners with new serviceLimit value
*
* @param serviceLimit The maximum number of services the Cybernode has been configured to
* instantiate
*/
void updateMonitors(int serviceLimit) {
setServiceLimit(serviceLimit);
updateMonitors(adapter.getResourceCapability(), adapter.getDeployedServices());
}
/** Update all known Provisioners */
void updateMonitors() {
updateMonitors(adapter.getResourceCapability(), adapter.getDeployedServices());
}
