| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| package org.apache.sling.discovery.base.commons; |
| |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.HashSet; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Set; |
| |
| import org.apache.sling.discovery.ClusterView; |
| import org.apache.sling.discovery.InstanceDescription; |
| import org.apache.sling.discovery.InstanceFilter; |
| import org.apache.sling.discovery.TopologyEvent.Type; |
| import org.apache.sling.discovery.commons.providers.BaseTopologyView; |
| import org.apache.sling.discovery.commons.providers.spi.LocalClusterView; |
| import org.slf4j.Logger; |
| import org.slf4j.LoggerFactory; |
| |
| /** |
| * Default Implementation of the topology view interface |
| */ |
| public class DefaultTopologyView extends BaseTopologyView { |
| |
| private final Logger logger = LoggerFactory.getLogger(this.getClass()); |
| |
| /** the instances that are part of this topology **/ |
| private final Set<InstanceDescription> instances = new HashSet<InstanceDescription>(); |
| |
| private String localClusterSyncTokenId; |
| |
| /** Create a new empty topology **/ |
| public DefaultTopologyView() { |
| // nothing to be initialized then |
| } |
| |
| /** Create a new topology filled with the given list of instances **/ |
| public DefaultTopologyView(final Collection<InstanceDescription> instances) { |
| if (instances != null) { |
| this.instances.addAll(instances); |
| } |
| } |
| |
| /** |
| * Compare this topology with the given one and determine how they compare |
| * @param other the other topology against which to compare |
| * @return the type describing how these two compare |
| * @see Type |
| */ |
| public Type compareTopology(final DefaultTopologyView other) { |
| if (other == null) { |
| throw new IllegalArgumentException("other must not be null"); |
| } |
| if ((localClusterSyncTokenId == null && other.localClusterSyncTokenId != null) |
| || (other.localClusterSyncTokenId == null && localClusterSyncTokenId != null) |
| || (localClusterSyncTokenId != null && !localClusterSyncTokenId.equals(other.localClusterSyncTokenId))) { |
| logger.debug("compareTopology: different localClusterSyncTokenId"); |
| return Type.TOPOLOGY_CHANGED; |
| } |
| if (this.instances.size() != other.instances.size()) { |
| logger.debug("compareTopology: different number of instances"); |
| return Type.TOPOLOGY_CHANGED; |
| } |
| boolean propertiesChanged = false; |
| for(final InstanceDescription instance : this.instances) { |
| |
| final Iterator<InstanceDescription> it2 = other.instances.iterator(); |
| InstanceDescription matchingInstance = null; |
| while (it2.hasNext()) { |
| final InstanceDescription otherInstance = it2.next(); |
| if (instance.getSlingId().equals(otherInstance.getSlingId())) { |
| matchingInstance = otherInstance; |
| break; |
| } |
| } |
| if (matchingInstance == null) { |
| if (logger.isDebugEnabled()) { |
| logger.debug("compareTopology: no matching instance found for {}", instance); |
| } |
| return Type.TOPOLOGY_CHANGED; |
| } |
| if (!instance.getClusterView().getId() |
| .equals(matchingInstance.getClusterView().getId())) { |
| logger.debug("compareTopology: cluster view id does not match"); |
| return Type.TOPOLOGY_CHANGED; |
| } |
| if (!instance.isLeader()==matchingInstance.isLeader()) { |
| logger.debug("compareTopology: leaders differ"); |
| return Type.TOPOLOGY_CHANGED; |
| } |
| if (!instance.getProperties().equals( |
| matchingInstance.getProperties())) { |
| propertiesChanged = true; |
| } |
| } |
| if (propertiesChanged) { |
| return Type.PROPERTIES_CHANGED; |
| } else { |
| return null; |
| } |
| } |
| |
| @Override |
| public boolean equals(final Object obj) { |
| if (obj == null || !(obj instanceof DefaultTopologyView)) { |
| return false; |
| } |
| DefaultTopologyView other = (DefaultTopologyView) obj; |
| if (this.isCurrent() != other.isCurrent()) { |
| return false; |
| } |
| Type diff = compareTopology(other); |
| return diff == null; |
| } |
| |
| @Override |
| public int hashCode() { |
| int code = 0; |
| for (Iterator<InstanceDescription> it = instances.iterator(); it |
| .hasNext();) { |
| InstanceDescription instance = it.next(); |
| code += instance.hashCode(); |
| } |
| return code; |
| } |
| |
| /** |
| * @see org.apache.sling.discovery.TopologyView#getLocalInstance() |
| */ |
| public InstanceDescription getLocalInstance() { |
| for (Iterator<InstanceDescription> it = instances.iterator(); it |
| .hasNext();) { |
| InstanceDescription instance = it.next(); |
| if (instance.isLocal()) { |
| return instance; |
| } |
| } |
| return null; |
| } |
| |
| /** |
| * @see org.apache.sling.discovery.TopologyView#getInstances() |
| */ |
| public Set<InstanceDescription> getInstances() { |
| return Collections.unmodifiableSet(instances); |
| } |
| |
| /** |
| * Adds the instances of the given ClusterView to this topology |
| */ |
| public void setLocalClusterView(final LocalClusterView localClusterView) { |
| if (localClusterView == null) { |
| throw new IllegalArgumentException("localClusterView must not be null"); |
| } |
| final List<InstanceDescription> instances = localClusterView.getInstances(); |
| addInstances(instances); |
| |
| this.localClusterSyncTokenId = localClusterView.getLocalClusterSyncTokenId(); |
| } |
| |
| /** |
| * Adds the given instances to this topology |
| */ |
| public void addInstances(final Collection<InstanceDescription> instances) { |
| if (instances == null) { |
| return; |
| } |
| outerLoop: for (Iterator<InstanceDescription> it = instances.iterator(); it |
| .hasNext();) { |
| InstanceDescription instanceDescription = it.next(); |
| for (Iterator<InstanceDescription> it2 = this.instances.iterator(); it2.hasNext();) { |
| InstanceDescription existingInstance = it2.next(); |
| if (existingInstance.getSlingId().equals(instanceDescription.getSlingId())) { |
| // SLING-3726: |
| // while 'normal duplicate instances' are filtered out here correctly, |
| // 'hidden duplicate instances' that are added via this instanceDescription's |
| // cluster, are not caught. |
| // there is, however, no simple fix for this. Since the reason is |
| // inconsistent state information in /var/discovery/impl - either |
| // due to stale-announcements (SLING-4139) - or by some manualy |
| // copying of data from one cluster to the next (which will also |
| // be cleaned up by SLING-4139 though) |
| // so the fix for avoiding duplicate instances is really SLING-4139 |
| logger.info("addInstance: cannot add same instance twice: " |
| + instanceDescription); |
| continue outerLoop; |
| } |
| } |
| this.instances.add(instanceDescription); |
| } |
| } |
| |
| /** |
| * @see org.apache.sling.discovery.TopologyView#findInstances(org.apache.sling.discovery.InstanceFilter) |
| */ |
| public Set<InstanceDescription> findInstances(final InstanceFilter picker) { |
| if (picker == null) { |
| throw new IllegalArgumentException("picker must not be null"); |
| } |
| Set<InstanceDescription> result = new HashSet<InstanceDescription>(); |
| for (Iterator<InstanceDescription> it = instances.iterator(); it |
| .hasNext();) { |
| InstanceDescription instance = it.next(); |
| if (picker.accept(instance)) { |
| result.add(instance); |
| } |
| } |
| return result; |
| } |
| |
| /** |
| * @see org.apache.sling.discovery.TopologyView#getClusterViews() |
| */ |
| public Set<ClusterView> getClusterViews() { |
| Set<ClusterView> result = new HashSet<ClusterView>(); |
| for (Iterator<InstanceDescription> it = instances.iterator(); it |
| .hasNext();) { |
| InstanceDescription instance = it.next(); |
| ClusterView cluster = instance.getClusterView(); |
| if (cluster != null) { |
| result.add(cluster); |
| } |
| } |
| return new HashSet<ClusterView>(result); |
| } |
| |
| @Override |
| public String toString() { |
| StringBuilder sb = new StringBuilder(); |
| try{ |
| boolean firstCluster = true; |
| for (ClusterView clusterView : getClusterViews()) { |
| if (!firstCluster) { |
| sb.append(", "); |
| } |
| firstCluster = false; |
| sb.append("[clusterId=" + clusterView.getId() + ", instances="); |
| boolean firstInstance = true; |
| for (InstanceDescription id : clusterView.getInstances()) { |
| if (!firstInstance) { |
| sb.append(", "); |
| } |
| firstInstance = false; |
| sb.append("[id=" + id.getSlingId() + ", isLeader=" + id.isLeader() + |
| ", isLocal=" + id.isLocal() + "]"); |
| } |
| sb.append("]"); |
| } |
| } catch(Exception e) { |
| // paranoia fallback |
| sb = new StringBuilder(instances.toString()); |
| } |
| return "DefaultTopologyView[current=" + isCurrent() + ", num=" + instances.size() + ", instances=" |
| + sb + "]"; |
| } |
| |
| @Override |
| public String getLocalClusterSyncTokenId() { |
| if (localClusterSyncTokenId==null) { |
| throw new IllegalStateException("no syncToken set"); |
| } else { |
| return localClusterSyncTokenId; |
| } |
| } |
| } |
