public ExtantNetwork extantNetwork() throws NotEnoughResourcesException, TransientEntityException { if (!NetworkGroups.networkingConfiguration().hasNetworking()) { ExtantNetwork bogusNet = ExtantNetwork.bogus(this); if (!this.hasExtantNetwork()) this.setExtantNetwork(bogusNet); return bogusNet; } else if (!Entities.isPersistent(this)) { throw new TransientEntityException(this.toString()); } else { ExtantNetwork exNet = this.getExtantNetwork(); if (exNet == null) { for (Integer i : Numbers.shuffled(NetworkGroups.networkTagInterval())) { try { Entities.uniqueResult(ExtantNetwork.named(i)); continue; } catch (Exception ex) { exNet = ExtantNetwork.create(this, i); Entities.persist(exNet); this.setExtantNetwork(exNet); return this.getExtantNetwork(); } } throw new NotEnoughResourcesException( "Failed to allocate network tag for network: " + this.getFullName() + ": no network tags are free."); } else { return this.getExtantNetwork(); } } }
public ExtantNetwork reclaim(Integer i) throws NotEnoughResourcesException, TransientEntityException { if (!NetworkGroups.networkingConfiguration().hasNetworking()) { return ExtantNetwork.bogus(this); } else if (!Entities.isPersistent(this)) { throw new TransientEntityException(this.toString()); } else { ExtantNetwork exNet = Entities.persist(ExtantNetwork.create(this, i)); this.setExtantNetwork(exNet); return this.getExtantNetwork(); } }
public static synchronized void updateNetworkRangeConfiguration() { final AtomicReference<NetworkRangeConfiguration> equalityCheck = new AtomicReference<NetworkRangeConfiguration>(null); try { Transactions.each( new ClusterConfiguration(), new Callback<ClusterConfiguration>() { @Override public void fire(final ClusterConfiguration input) { NetworkRangeConfiguration comparisonConfig = new NetworkRangeConfiguration(); comparisonConfig.setUseNetworkTags(input.getUseNetworkTags()); comparisonConfig.setMinNetworkTag(input.getMinNetworkTag()); comparisonConfig.setMaxNetworkTag(input.getMaxNetworkTag()); comparisonConfig.setMinNetworkIndex(input.getMinNetworkIndex()); comparisonConfig.setMaxNetworkIndex(input.getMaxNetworkIndex()); Logs.extreme() .debug( "Updating cluster config: " + input.getName() + " " + comparisonConfig.toString()); if (equalityCheck.compareAndSet(null, comparisonConfig)) { Logs.extreme().debug("Initialized cluster config check: " + equalityCheck.get()); } else { NetworkRangeConfiguration currentConfig = equalityCheck.get(); List<String> errors = Lists.newArrayList(); if (!currentConfig .getUseNetworkTags() .equals(comparisonConfig.getUseNetworkTags())) { errors.add( input.getName() + " network config mismatch: vlan tagging " + currentConfig.getUseNetworkTags() + " != " + comparisonConfig.getUseNetworkTags()); } else if (!currentConfig .getMinNetworkTag() .equals(comparisonConfig.getMinNetworkTag())) { errors.add( input.getName() + " network config mismatch: min vlan tag " + currentConfig.getMinNetworkTag() + " != " + comparisonConfig.getMinNetworkTag()); } else if (!currentConfig .getMaxNetworkTag() .equals(comparisonConfig.getMaxNetworkTag())) { errors.add( input.getName() + " network config mismatch: max vlan tag " + currentConfig.getMaxNetworkTag() + " != " + comparisonConfig.getMaxNetworkTag()); } else if (!currentConfig .getMinNetworkIndex() .equals(comparisonConfig.getMinNetworkIndex())) { errors.add( input.getName() + " network config mismatch: min net index " + currentConfig.getMinNetworkIndex() + " != " + comparisonConfig.getMinNetworkIndex()); } else if (!currentConfig .getMaxNetworkIndex() .equals(comparisonConfig.getMaxNetworkIndex())) { errors.add( input.getName() + " network config mismatch: max net index " + currentConfig.getMaxNetworkIndex() + " != " + comparisonConfig.getMaxNetworkIndex()); } } } }); } catch (RuntimeException ex) { Logs.extreme().error(ex, ex); throw ex; } catch (TransactionException ex) { LOG.error(ex); Logs.extreme().error(ex, ex); } netConfig = new NetworkRangeConfiguration(); final AtomicBoolean netTagging = new AtomicBoolean(true); try { Transactions.each( new ClusterConfiguration(), new Callback<ClusterConfiguration>() { @Override public void fire(final ClusterConfiguration input) { netTagging.compareAndSet(true, input.getUseNetworkTags()); netConfig.setMinNetworkTag( Ints.max(netConfig.getMinNetworkTag(), input.getMinNetworkTag())); netConfig.setMaxNetworkTag( Ints.min(netConfig.getMaxNetworkTag(), input.getMaxNetworkTag())); netConfig.setMinNetworkIndex( Longs.max(netConfig.getMinNetworkIndex(), input.getMinNetworkIndex())); netConfig.setMaxNetworkIndex( Longs.min(netConfig.getMaxNetworkIndex(), input.getMaxNetworkIndex())); } }); Logs.extreme().debug("Updated network configuration: " + netConfig.toString()); } catch (final TransactionException ex) { Logs.extreme().error(ex, ex); } netConfig.setUseNetworkTags(netTagging.get()); final EntityTransaction db = Entities.get(NetworkGroup.class); try { final List<NetworkGroup> ret = Entities.query(new NetworkGroup()); for (NetworkGroup group : ret) { ExtantNetwork exNet = group.getExtantNetwork(); if (exNet != null && (exNet.getTag() > netConfig.getMaxNetworkTag() || exNet.getTag() < netConfig.getMinNetworkTag())) { exNet.teardown(); Entities.delete(exNet); group.setExtantNetwork(null); } } db.commit(); } catch (final Exception ex) { Logs.extreme().error(ex, ex); LOG.error(ex); db.rollback(); } }
/** * Update network tag information by marking reported tags as being EXTANT and removing previously * EXTANT tags which are no longer reported * * @param activeNetworks */ public static void updateExtantNetworks( ServiceConfiguration cluster, List<NetworkInfoType> activeNetworks) { ActiveTags.INSTANCE.update(cluster, activeNetworks); /** * For each of the reported active network tags ensure that the locally stored extant network * state reflects that the network has now been EXTANT in the system (i.e. is no longer PENDING) */ for (NetworkInfoType activeNetInfo : activeNetworks) { EntityTransaction tx = Entities.get(NetworkGroup.class); try { NetworkGroup net = NetworkGroups.lookupByNaturalId(activeNetInfo.getUuid()); if (net.hasExtantNetwork()) { ExtantNetwork exNet = net.extantNetwork(); if (Reference.State.PENDING.equals(exNet.getState())) { LOG.debug( "Found PENDING extant network for " + net.getFullName() + " updating to EXTANT."); exNet.setState(Reference.State.EXTANT); } else { LOG.debug( "Found " + exNet.getState() + " extant network for " + net.getFullName() + ": skipped."); } } else { LOG.warn( "Failed to find extant network for " + net.getFullName()); // TODO:GRZE: likely we should be trying to reclaim tag here } tx.commit(); } catch (Exception ex) { LOG.debug(ex); Logs.extreme().error(ex, ex); } finally { if (tx.isActive()) tx.rollback(); } } /** * For each defined network group check to see if the extant network is in the set of active * tags and remove it if appropriate. * * <p>It is appropriate to remove the network when the state of the extant network is {@link * Reference.State.RELEASING}. * * <p>Otherwise, if {@link ActiveTags#INSTANCE#isActive()} is false and: * * <ol> * <li>The state of the extant network is {@link Reference.State.EXTANT} * <li>The state of the extant network is {@link Reference.State.PENDING} and has exceeded * {@link NetworksGroups#NETWORK_TAG_PENDING_TIMEOUT} * </ol> * * Then the state of the extant network is updated to {@link Reference.State.RELEASING}. */ try { final List<NetworkGroup> groups = NetworkGroups.lookupAll(null, null); for (NetworkGroup net : groups) { final EntityTransaction tx = Entities.get(NetworkGroup.class); try { net = Entities.merge(net); if (net.hasExtantNetwork()) { ExtantNetwork exNet = net.getExtantNetwork(); Integer exNetTag = exNet.getTag(); if (!ActiveTags.INSTANCE.isActive(exNetTag)) { if (Reference.State.EXTANT.equals(exNet.getState())) { exNet.setState(Reference.State.RELEASING); } else if (Reference.State.PENDING.equals(exNet.getState()) && exNet.lastUpdateMillis() > 60L * 1000 * NetworkGroups.NETWORK_TAG_PENDING_TIMEOUT) { exNet.setState(Reference.State.RELEASING); } else if (Reference.State.RELEASING.equals(exNet.getState())) { exNet.teardown(); Entities.delete(exNet); net.setExtantNetwork(null); } } } tx.commit(); } catch (final Exception ex) { LOG.debug(ex); Logs.extreme().error(ex, ex); } finally { if (tx.isActive()) tx.rollback(); } } } catch (MetadataException ex) { LOG.error(ex); } }