Java tutorial
/** * Copyright 2014 Comcast Cable Communications Management, LLC * * Licensed 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 com.comcast.viper.flume2storm.connection; import java.io.Serializable; import org.apache.commons.configuration.Configuration; import org.apache.commons.lang3.builder.EqualsBuilder; import org.apache.commons.lang3.builder.HashCodeBuilder; import org.apache.commons.lang3.builder.ToStringBuilder; import org.apache.commons.lang3.builder.ToStringStyle; import com.comcast.viper.flume2storm.F2SConfigurationException; import com.google.common.base.Preconditions; /** * Configuration for the KryoNet sender and receiver */ public class KryoNetParameters implements Serializable { private static final long serialVersionUID = -5348116647457735026L; /** Configuration attribute base name */ public static final String CONFIG_BASE_NAME = "kryonet"; /** Configuration attribute name for {@link #getConnectionTimeout()} */ public static final String CONNECTION_TIMEOUT = "connection.timeout.in.ms"; /** Default value for {@value #CONNECTION_TIMEOUT} */ public static final int CONNECTION_TIMEOUT_DEFAULT = 10000; /** Configuration attribute name for {@link #getRetrySleepDelay()} */ public static final String RETRY_SLEEP_DELAY = "retry.sleep.delay.in.ms"; /** Default value for {@value #RETRY_SLEEP_DELAY} */ public static final int RETRY_SLEEP_DELAY_DEFAULT = 50; /** Configuration attribute name for {@link #getReconnectionDelay()} */ public static final String RECONNECTION_DELAY = "reconnection.delay.in.ms"; /** Default value for {@value #RECONNECTION_DELAY} */ public static final int RECONNECTION_DELAY_DEFAULT = 2000; /** Configuration attribute name for {@link #getTerminationTimeout()} */ public static final String TERMINATION_TO = "termination.timeout.in.ms"; /** Default value for {@value #TERMINATION_TO} */ public static final int TERMINATION_TO_DEFAULT = 10000; /** Configuration attribute name for {@link #getMaxRetries()} */ public static final String MAX_RETRIES = "max.retries"; /** Default value for {@value #MAX_RETRIES} */ public static final int MAX_RETRIES_DEFAULT = 3; protected int connectionTimeout; protected int retrySleepDelay; protected int reconnectionDelay; protected int terminationTimeout; protected int maxRetries; /** * Builds a new {@link KryoNetParameters} based on a Configuration * * @param config * The configuration to use * @return The newly created {@link KryoNetParameters} * @throws F2SConfigurationException * If the configuration specified is invalid */ public static KryoNetParameters from(final Configuration config) throws F2SConfigurationException { KryoNetParameters result = new KryoNetParameters(); try { result.setConnectionTimeout(config.getInt(CONNECTION_TIMEOUT, CONNECTION_TIMEOUT_DEFAULT)); } catch (Exception e) { throw F2SConfigurationException.with(config, CONNECTION_TIMEOUT, e); } try { result.setTerminationTimeout(config.getInt(TERMINATION_TO, TERMINATION_TO_DEFAULT)); } catch (Exception e) { throw F2SConfigurationException.with(config, TERMINATION_TO, e); } try { result.setReconnectionDelay(config.getInt(RECONNECTION_DELAY, RECONNECTION_DELAY_DEFAULT)); } catch (Exception e) { throw F2SConfigurationException.with(config, RECONNECTION_DELAY, e); } try { result.setRetrySleepDelay(config.getInt(RETRY_SLEEP_DELAY, RETRY_SLEEP_DELAY_DEFAULT)); } catch (Exception e) { throw F2SConfigurationException.with(config, RETRY_SLEEP_DELAY, e); } try { result.setMaxRetries(config.getInt(MAX_RETRIES, MAX_RETRIES_DEFAULT)); } catch (Exception e) { throw F2SConfigurationException.with(config, MAX_RETRIES, e); } return result; } /** * Empty constructor - initializes with default values when available */ public KryoNetParameters() { connectionTimeout = CONNECTION_TIMEOUT_DEFAULT; retrySleepDelay = RETRY_SLEEP_DELAY_DEFAULT; reconnectionDelay = RECONNECTION_DELAY_DEFAULT; terminationTimeout = TERMINATION_TO_DEFAULT; maxRetries = MAX_RETRIES_DEFAULT; } /** * @return The timeout for a connection attempt, in milliseconds */ public int getConnectionTimeout() { return connectionTimeout; } /** * @param connectionTo * See #getConnectionTimeout() * @return This object */ public KryoNetParameters setConnectionTimeout(int connectionTo) { Preconditions.checkArgument(connectionTo > 0, "KryoNet connection timeout must be strictly positive"); connectionTimeout = connectionTo; return this; } /** * @return The delay allowed for the client to terminate, in milliseconds. It * should be greater than the connection timeout */ public int getTerminationTimeout() { return terminationTimeout; } /** * @param terminationTo * See #getTerminationTimeout() * @return This object */ public KryoNetParameters setTerminationTimeout(int terminationTo) { Preconditions.checkArgument(terminationTo > 0, "KryoNet termination timeout must be strictly positive"); terminationTimeout = terminationTo; return this; } /** * @return The time in milliseconds to wait before the client (i.e. * EventReceptor) retries to connect to the server (i.e. EventSender) */ public int getReconnectionDelay() { return reconnectionDelay; } /** * @param reconnectionDelay * See #getReconnectionDelay() * @return This object */ public KryoNetParameters setReconnectionDelay(int reconnectionDelay) { Preconditions.checkArgument(reconnectionDelay > 0, "KryoNet reconnection delay must be strictly positive"); this.reconnectionDelay = reconnectionDelay; return this; } /** * @return The time in milliseconds to wait before the server (i.e. * EventSender) retries sending an event to the same client (i.e. * EventReceptor) */ public int getRetrySleepDelay() { return retrySleepDelay; } /** * @param retrySleepDelay * See #getRetrySleepDelay() * @return This object */ public KryoNetParameters setRetrySleepDelay(int retrySleepDelay) { Preconditions.checkArgument(retrySleepDelay > 0, "KryoNet retry sleep delay must be strictly positive"); this.retrySleepDelay = retrySleepDelay; return this; } /** * @return The maximum number of times an event is attempted to be sent before * considering it failed */ public int getMaxRetries() { return maxRetries; } /** * @param maxRetries * See #getMaxRetries() * @return This object */ public KryoNetParameters setMaxRetries(int maxRetries) { Preconditions.checkArgument(maxRetries > 0, "KryoNet maximum number of retries must be strictly positive"); this.maxRetries = maxRetries; return this; } /** * @see java.lang.Object#hashCode() */ @Override public int hashCode() { return new HashCodeBuilder().append(connectionTimeout).append(retrySleepDelay).append(reconnectionDelay) .append(terminationTimeout).append(maxRetries).hashCode(); } /** * @see java.lang.Object#equals(java.lang.Object) */ @Override public boolean equals(Object obj) { if (this == obj) return true; if (obj == null) return false; if (getClass() != obj.getClass()) return false; KryoNetParameters other = (KryoNetParameters) obj; return new EqualsBuilder().append(this.connectionTimeout, other.connectionTimeout) .append(this.retrySleepDelay, other.retrySleepDelay) .append(this.reconnectionDelay, other.reconnectionDelay) .append(this.terminationTimeout, other.terminationTimeout).append(this.maxRetries, other.maxRetries) .isEquals(); } /** * @see java.lang.Object#toString() */ @Override public String toString() { return new ToStringBuilder(this, ToStringStyle.SHORT_PREFIX_STYLE) .append("connectionTimeout", connectionTimeout).append("retrySleepDelay", retrySleepDelay) .append("reconnectionDelay", reconnectionDelay).append("terminationTimeout", terminationTimeout) .append("maxRetries", maxRetries).toString(); } }