org.apache.mina.core.session.AbstractIoSessionConfig 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.mina.core.session;
/**
* A base implementation of {@link IoSessionConfig}.
*
* @author Apache MINA Project
*/
public abstract class AbstractIoSessionConfig implements IoSessionConfig {
/** The minimum size of the buffer used to read incoming data */
private int minReadBufferSize = 64;
/** The default size of the buffer used to read incoming data */
private int readBufferSize = 2048;
/** The maximum size of the buffer used to read incoming data */
private int maxReadBufferSize = 65536;
/** The delay before we notify a session that it has been idle on read. Default to infinite */
private int idleTimeForRead;
/** The delay before we notify a session that it has been idle on write. Default to infinite */
private int idleTimeForWrite;
/**
* The delay before we notify a session that it has been idle on read and write.
* Default to infinite
**/
private int idleTimeForBoth;
/** The delay to wait for a write operation to complete before bailing out */
private int writeTimeout = 60;
/** A flag set to true when weallow the application to do a session.read(). Default to false */
private boolean useReadOperation;
private int throughputCalculationInterval = 3;
protected AbstractIoSessionConfig() {
// Do nothing
}
/**
* {@inheritDoc}
*/
@Override
public void setAll(IoSessionConfig config) {
if (config == null) {
throw new IllegalArgumentException("config");
}
setReadBufferSize(config.getReadBufferSize());
setMaxReadBufferSize(config.getMaxReadBufferSize());
setMinReadBufferSize(config.getMinReadBufferSize());
setIdleTime(IdleStatus.BOTH_IDLE, config.getIdleTime(IdleStatus.BOTH_IDLE));
setIdleTime(IdleStatus.READER_IDLE, config.getIdleTime(IdleStatus.READER_IDLE));
setIdleTime(IdleStatus.WRITER_IDLE, config.getIdleTime(IdleStatus.WRITER_IDLE));
setWriteTimeout(config.getWriteTimeout());
setUseReadOperation(config.isUseReadOperation());
setThroughputCalculationInterval(config.getThroughputCalculationInterval());
}
/**
* {@inheritDoc}
*/
@Override
public int getReadBufferSize() {
return readBufferSize;
}
/**
* {@inheritDoc}
*/
@Override
public void setReadBufferSize(int readBufferSize) {
if (readBufferSize <= 0) {
throw new IllegalArgumentException("readBufferSize: " + readBufferSize + " (expected: 1+)");
}
this.readBufferSize = readBufferSize;
}
/**
* {@inheritDoc}
*/
@Override
public int getMinReadBufferSize() {
return minReadBufferSize;
}
/**
* {@inheritDoc}
*/
@Override
public void setMinReadBufferSize(int minReadBufferSize) {
if (minReadBufferSize <= 0) {
throw new IllegalArgumentException("minReadBufferSize: " + minReadBufferSize + " (expected: 1+)");
}
if (minReadBufferSize > maxReadBufferSize) {
throw new IllegalArgumentException("minReadBufferSize: " + minReadBufferSize + " (expected: smaller than "
+ maxReadBufferSize + ')');
}
this.minReadBufferSize = minReadBufferSize;
}
/**
* {@inheritDoc}
*/
@Override
public int getMaxReadBufferSize() {
return maxReadBufferSize;
}
/**
* {@inheritDoc}
*/
@Override
public void setMaxReadBufferSize(int maxReadBufferSize) {
if (maxReadBufferSize <= 0) {
throw new IllegalArgumentException("maxReadBufferSize: " + maxReadBufferSize + " (expected: 1+)");
}
if (maxReadBufferSize < minReadBufferSize) {
throw new IllegalArgumentException("maxReadBufferSize: " + maxReadBufferSize + " (expected: greater than "
+ minReadBufferSize + ')');
}
this.maxReadBufferSize = maxReadBufferSize;
}
/**
* {@inheritDoc}
*/
@Override
public int getIdleTime(IdleStatus status) {
if (status == IdleStatus.BOTH_IDLE) {
return idleTimeForBoth;
}
if (status == IdleStatus.READER_IDLE) {
return idleTimeForRead;
}
if (status == IdleStatus.WRITER_IDLE) {
return idleTimeForWrite;
}
throw new IllegalArgumentException("Unknown idle status: " + status);
}
/**
* {@inheritDoc}
*/
@Override
public long getIdleTimeInMillis(IdleStatus status) {
return getIdleTime(status) * 1000L;
}
/**
* {@inheritDoc}
*/
@Override
public void setIdleTime(IdleStatus status, int idleTime) {
if (idleTime < 0) {
throw new IllegalArgumentException("Illegal idle time: " + idleTime);
}
if (status == IdleStatus.BOTH_IDLE) {
idleTimeForBoth = idleTime;
} else if (status == IdleStatus.READER_IDLE) {
idleTimeForRead = idleTime;
} else if (status == IdleStatus.WRITER_IDLE) {
idleTimeForWrite = idleTime;
} else {
throw new IllegalArgumentException("Unknown idle status: " + status);
}
}
/**
* {@inheritDoc}
*/
@Override
public final int getBothIdleTime() {
return getIdleTime(IdleStatus.BOTH_IDLE);
}
/**
* {@inheritDoc}
*/
@Override
public final long getBothIdleTimeInMillis() {
return getIdleTimeInMillis(IdleStatus.BOTH_IDLE);
}
/**
* {@inheritDoc}
*/
@Override
public final int getReaderIdleTime() {
return getIdleTime(IdleStatus.READER_IDLE);
}
/**
* {@inheritDoc}
*/
@Override
public final long getReaderIdleTimeInMillis() {
return getIdleTimeInMillis(IdleStatus.READER_IDLE);
}
/**
* {@inheritDoc}
*/
@Override
public final int getWriterIdleTime() {
return getIdleTime(IdleStatus.WRITER_IDLE);
}
/**
* {@inheritDoc}
*/
@Override
public final long getWriterIdleTimeInMillis() {
return getIdleTimeInMillis(IdleStatus.WRITER_IDLE);
}
/**
* {@inheritDoc}
*/
@Override
public void setBothIdleTime(int idleTime) {
setIdleTime(IdleStatus.BOTH_IDLE, idleTime);
}
/**
* {@inheritDoc}
*/
@Override
public void setReaderIdleTime(int idleTime) {
setIdleTime(IdleStatus.READER_IDLE, idleTime);
}
/**
* {@inheritDoc}
*/
@Override
public void setWriterIdleTime(int idleTime) {
setIdleTime(IdleStatus.WRITER_IDLE, idleTime);
}
/**
* {@inheritDoc}
*/
@Override
public int getWriteTimeout() {
return writeTimeout;
}
/**
* {@inheritDoc}
*/
@Override
public long getWriteTimeoutInMillis() {
return writeTimeout * 1000L;
}
/**
* {@inheritDoc}
*/
@Override
public void setWriteTimeout(int writeTimeout) {
if (writeTimeout < 0) {
throw new IllegalArgumentException("Illegal write timeout: " + writeTimeout);
}
this.writeTimeout = writeTimeout;
}
/**
* {@inheritDoc}
*/
@Override
public boolean isUseReadOperation() {
return useReadOperation;
}
/**
* {@inheritDoc}
*/
@Override
public void setUseReadOperation(boolean useReadOperation) {
this.useReadOperation = useReadOperation;
}
/**
* {@inheritDoc}
*/
@Override
public int getThroughputCalculationInterval() {
return throughputCalculationInterval;
}
/**
* {@inheritDoc}
*/
@Override
public void setThroughputCalculationInterval(int throughputCalculationInterval) {
if (throughputCalculationInterval < 0) {
throw new IllegalArgumentException("throughputCalculationInterval: " + throughputCalculationInterval);
}
this.throughputCalculationInterval = throughputCalculationInterval;
}
/**
* {@inheritDoc}
*/
@Override
public long getThroughputCalculationIntervalInMillis() {
return throughputCalculationInterval * 1000L;
}
}