Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
/**
* Copyright 2007-2015, Kaazing Corporation. All rights reserved.
*
* 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 org.apache.mina.core.service;
import java.net.SocketAddress;
import java.util.concurrent.Executor;
import java.util.concurrent.Executors;
import org.apache.mina.core.future.ConnectFuture;
import org.apache.mina.core.future.IoFuture;
import org.apache.mina.core.future.IoFutureListener;
import org.apache.mina.core.session.IdleStatus;
import org.apache.mina.core.session.IoSession;
import org.apache.mina.core.session.IoSessionConfig;
import org.apache.mina.core.session.IoSessionInitializer;
/**
* A base implementation of {@link IoConnector}.
*
* @author Apache MINA Project
*/
public abstract class AbstractIoConnector
extends AbstractIoService implements IoConnector {
/**
* The minimum timeout value that is supported (in milliseconds).
*/
private long connectTimeoutCheckInterval = 50L;
private long connectTimeoutInMillis = 60 * 1000L; // 1 minute by default
private SocketAddress defaultRemoteAddress;
/**
* Constructor for {@link AbstractIoConnector}. You need to provide a default
* session configuration and an {@link Executor} for handling I/O events. If
* null {@link Executor} is provided, a default one will be created using
* {@link Executors#newCachedThreadPool()}.
*
* {@see AbstractIoService#AbstractIoService(IoSessionConfig, Executor)}
*
* @param sessionConfig
* the default configuration for the managed {@link IoSession}
* @param executor
* the {@link Executor} used for handling execution of I/O
* events. Can be null.
*/
protected AbstractIoConnector(IoSessionConfig sessionConfig, Executor executor) {
super(sessionConfig, executor);
}
/**
* Returns the minimum connection timeout value for this connector
*
* @return
* The minimum time that this connector can have for a connection
* timeout in milliseconds.
*/
public long getConnectTimeoutCheckInterval() {
return connectTimeoutCheckInterval;
}
public void setConnectTimeoutCheckInterval(long minimumConnectTimeout) {
if( getConnectTimeoutMillis() < minimumConnectTimeout ){
this.connectTimeoutInMillis = minimumConnectTimeout;
}
this.connectTimeoutCheckInterval = minimumConnectTimeout;
}
/**
* @deprecated
* Take a look at getConnectTimeoutMillis()
*/
public final int getConnectTimeout() {
return (int)connectTimeoutInMillis/1000;
}
/**
* {@inheritDoc}
*/
public final long getConnectTimeoutMillis() {
return connectTimeoutInMillis;
}
/**
* @deprecated
* Take a look at setConnectTimeoutMillis(long)
*/
public final void setConnectTimeout(int connectTimeout) {
setConnectTimeoutMillis( connectTimeout * 1000L );
}
/**
* Sets the connect timeout value in milliseconds.
*
*/
public final void setConnectTimeoutMillis(long connectTimeoutInMillis) {
if (connectTimeoutInMillis <= connectTimeoutCheckInterval) {
this.connectTimeoutCheckInterval = connectTimeoutInMillis;
}
this.connectTimeoutInMillis = connectTimeoutInMillis;
}
/**
* {@inheritDoc}
*/
public SocketAddress getDefaultRemoteAddress() {
return defaultRemoteAddress;
}
/**
* {@inheritDoc}
*/
public final void setDefaultRemoteAddress(SocketAddress defaultRemoteAddress) {
if (defaultRemoteAddress == null) {
throw new NullPointerException("defaultRemoteAddress");
}
if (!getTransportMetadata().getAddressType().isAssignableFrom(
defaultRemoteAddress.getClass())) {
throw new IllegalArgumentException("defaultRemoteAddress type: "
+ defaultRemoteAddress.getClass() + " (expected: "
+ getTransportMetadata().getAddressType() + ")");
}
this.defaultRemoteAddress = defaultRemoteAddress;
}
/**
* {@inheritDoc}
*/
public final ConnectFuture connect() {
SocketAddress defaultRemoteAddress = getDefaultRemoteAddress();
if (defaultRemoteAddress == null) {
throw new IllegalStateException("defaultRemoteAddress is not set.");
}
return connect(defaultRemoteAddress, null, null);
}
/**
* {@inheritDoc}
*/
public ConnectFuture connect(IoSessionInitializer sessionInitializer) {
SocketAddress defaultRemoteAddress = getDefaultRemoteAddress();
if (defaultRemoteAddress == null) {
throw new IllegalStateException("defaultRemoteAddress is not set.");
}
return connect(defaultRemoteAddress, null, sessionInitializer);
}
/**
* {@inheritDoc}
*/
public final ConnectFuture connect(SocketAddress remoteAddress) {
return connect(remoteAddress, null, null);
}
/**
* {@inheritDoc}
*/
public ConnectFuture connect(SocketAddress remoteAddress,
IoSessionInitializer sessionInitializer) {
return connect(remoteAddress, null, sessionInitializer);
}
/**
* {@inheritDoc}
*/
public ConnectFuture connect(SocketAddress remoteAddress,
SocketAddress localAddress) {
return connect(remoteAddress, localAddress, null);
}
/**
* {@inheritDoc}
*/
public final ConnectFuture connect(SocketAddress remoteAddress,
SocketAddress localAddress, IoSessionInitializer sessionInitializer) {
if (isDisposing()) {
throw new IllegalStateException("Already disposed.");
}
if (remoteAddress == null) {
throw new NullPointerException("remoteAddress");
}
if (!getTransportMetadata().getAddressType().isAssignableFrom(
remoteAddress.getClass())) {
throw new IllegalArgumentException("remoteAddress type: "
+ remoteAddress.getClass() + " (expected: "
+ getTransportMetadata().getAddressType() + ")");
}
if (localAddress != null
&& !getTransportMetadata().getAddressType().isAssignableFrom(
localAddress.getClass())) {
throw new IllegalArgumentException("localAddress type: "
+ localAddress.getClass() + " (expected: "
+ getTransportMetadata().getAddressType() + ")");
}
if (getHandler() == null) {
if (getSessionConfig().isUseReadOperation()) {
setHandler(new IoHandler() {
public void exceptionCaught(IoSession session,
Throwable cause) throws Exception {
// Empty handler
}
public void messageReceived(IoSession session,
Object message) throws Exception {
// Empty handler
}
public void messageSent(IoSession session, Object message)
throws Exception {
// Empty handler
}
public void sessionClosed(IoSession session)
throws Exception {
// Empty handler
}
public void sessionCreated(IoSession session)
throws Exception {
// Empty handler
}
public void sessionIdle(IoSession session, IdleStatus status)
throws Exception {
// Empty handler
}
public void sessionOpened(IoSession session)
throws Exception {
// Empty handler
}
});
} else {
throw new IllegalStateException("handler is not set.");
}
}
return connect0(remoteAddress, localAddress, sessionInitializer);
}
/**
* Implement this method to perform the actual connect operation.
*
* @param localAddress null if no local address is specified
*/
protected abstract ConnectFuture connect0(SocketAddress remoteAddress,
SocketAddress localAddress, IoSessionInitializer sessionInitializer);
/**
* Adds required internal attributes and {@link IoFutureListener}s
* related with event notifications to the specified {@code session}
* and {@code future}. Do not call this method directly;
* {@link #finishSessionInitialization(IoSession, IoFuture, IoSessionInitializer)}
* will call this method instead.
*/
@Override
protected final void finishSessionInitialization0(
final IoSession session, IoFuture future) {
// In case that ConnectFuture.cancel() is invoked before
// setSession() is invoked, add a listener that closes the
// connection immediately on cancellation.
future.addListener(new IoFutureListener() {
public void operationComplete(ConnectFuture future) {
if (future.isCanceled()) {
session.close(true);
}
}
});
}
/**
* {@inheritDoc}
*/
@Override
public String toString() {
TransportMetadata m = getTransportMetadata();
return '(' + m.getProviderName() + ' ' + m.getName() + " connector: " +
"managedSessionCount: " + getManagedSessionCount() + ')';
}
}
