/** * 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()); }