org.apache.bookkeeper.net.AbstractDNSToSwitchMapping Maven / Gradle / Ivy
/*
* 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.bookkeeper.net;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import org.apache.bookkeeper.conf.Configurable;
import org.apache.bookkeeper.proto.BookieAddressResolver;
import org.apache.commons.configuration.Configuration;
import org.apache.commons.lang.StringUtils;
/**
* This is a base class for DNS to Switch mappings.
*
* It is not mandatory to derive {@link DNSToSwitchMapping} implementations from it, but it is strongly
* recommended, as it makes it easy for the Hadoop developers to add new methods
* to this base class that are automatically picked up by all implementations.
*
*
This class does not extend the Configured
* base class, and should not be changed to do so, as it causes problems
* for subclasses. The constructor of the Configured calls
* the {@link #setConf(Configuration)} method, which will call into the
* subclasses before they have been fully constructed.
*
*/
public abstract class AbstractDNSToSwitchMapping implements DNSToSwitchMapping, Configurable {
private Configuration conf;
private BookieAddressResolver bookieAddressResolver;
/**
* Create an unconfigured instance.
*/
protected AbstractDNSToSwitchMapping() {
}
/**
* Create an instance, caching the configuration file.
* This constructor does not call {@link #setConf(Configuration)}; if
* a subclass extracts information in that method, it must call it explicitly.
* @param conf the configuration
*/
protected AbstractDNSToSwitchMapping(Configuration conf) {
this.conf = conf;
}
public BookieAddressResolver getBookieAddressResolver() {
return bookieAddressResolver;
}
@Override
public void setBookieAddressResolver(BookieAddressResolver bookieAddressResolver) {
this.bookieAddressResolver = bookieAddressResolver;
}
@Override
public Configuration getConf() {
return conf;
}
@Override
public void setConf(Configuration conf) {
this.conf = conf;
validateConf();
}
/**
* Predicate that indicates that the switch mapping is known to be
* single-switch. The base class returns false: it assumes all mappings are
* multi-rack. Subclasses may override this with methods that are more aware
* of their topologies.
*
*
This method is used when parts of Hadoop need know whether to apply
* single rack vs multi-rack policies, such as during block placement.
* Such algorithms behave differently if they are on multi-switch systems.
*
* @return true if the mapping thinks that it is on a single switch
*/
public boolean isSingleSwitch() {
return false;
}
/**
* Get a copy of the map (for diagnostics).
* @return a clone of the map or null for none known
*/
public Map getSwitchMap() {
return null;
}
/**
* Generate a string listing the switch mapping implementation,
* the mapping for every known node and the number of nodes and
* unique switches known about -each entry to a separate line.
* @return a string that can be presented to the ops team or used in
* debug messages.
*/
public String dumpTopology() {
Map rack = getSwitchMap();
StringBuilder builder = new StringBuilder();
builder.append("Mapping: ").append(this).append("\n");
if (rack != null) {
builder.append("Map:\n");
Set switches = new HashSet();
for (Map.Entry entry : rack.entrySet()) {
builder.append(" ").append(entry.getKey()).append(" -> ").append(entry.getValue()).append("\n");
switches.add(entry.getValue());
}
builder.append("Nodes: ").append(rack.size()).append("\n");
builder.append("Switches: ").append(switches.size()).append("\n");
} else {
builder.append("No topology information");
}
return builder.toString();
}
protected boolean isSingleSwitchByScriptPolicy() {
return conf != null
&& (!StringUtils.isNotBlank(conf.getString(CommonConfigurationKeys.NET_TOPOLOGY_SCRIPT_FILE_NAME_KEY)));
}
/**
* Query for a {@link DNSToSwitchMapping} instance being on a single
* switch.
*
* This predicate simply assumes that all mappings not derived from
* this class are multi-switch.
*
* @param mapping the mapping to query
* @return true if the base class says it is single switch, or the mapping
* is not derived from this class.
*/
public static boolean isMappingSingleSwitch(DNSToSwitchMapping mapping) {
return mapping != null && mapping instanceof AbstractDNSToSwitchMapping
&& ((AbstractDNSToSwitchMapping) mapping).isSingleSwitch();
}
/**
* when setConf is called it should do sanity checking of the conf/env. and
* throw RuntimeException if things are not valid.
*/
protected void validateConf() {
}
}