/*
* Copyright (c) 2007-2013, 2016 Eike Stepper (Berlin, Germany) and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Eike Stepper - initial API and implementation
*/
package org.eclipse.net4j;
import org.eclipse.net4j.acceptor.IAcceptor;
import org.eclipse.net4j.buffer.IBufferPool;
import org.eclipse.net4j.buffer.IBufferProvider;
import org.eclipse.net4j.connector.ConnectorException;
import org.eclipse.net4j.connector.IConnector;
import org.eclipse.net4j.protocol.IProtocol;
import org.eclipse.net4j.protocol.IProtocol2;
import org.eclipse.net4j.signal.heartbeat.HeartBeatProtocol;
import org.eclipse.net4j.util.StringUtil;
import org.eclipse.net4j.util.concurrent.ExecutorServiceFactory;
import org.eclipse.net4j.util.container.ContainerUtil;
import org.eclipse.net4j.util.container.IManagedContainer;
import org.eclipse.net4j.util.io.GZIPStreamWrapper;
import org.eclipse.net4j.util.lifecycle.ILifecycle;
import org.eclipse.internal.net4j.TransportConfig;
import org.eclipse.internal.net4j.buffer.BufferFactory;
import org.eclipse.internal.net4j.buffer.BufferPool;
import org.eclipse.internal.net4j.buffer.BufferProviderFactory;
import org.eclipse.spi.net4j.AcceptorFactory;
import org.eclipse.spi.net4j.ConnectorFactory;
import java.util.concurrent.ExecutorService;
/**
* A utility class with various static factory and convenience methods.
*
* @author Eike Stepper
*/
public final class Net4jUtil
{
public static final String SCHEME_SEPARATOR = "://"; //$NON-NLS-1$
public static final short DEFAULT_BUFFER_CAPACITY = 4096;
private Net4jUtil()
{
}
public static void prepareContainer(IManagedContainer container)
{
ContainerUtil.prepareContainer(container);
container.registerFactory(new BufferProviderFactory());
container.registerFactory(new GZIPStreamWrapper.Factory());
container.registerFactory(new HeartBeatProtocol.Server.Factory());
container.addPostProcessor(new TransportInjector());
container.addPostProcessor(new HeartBeatProtocol.Server.TimerInjector());
}
public static ExecutorService getExecutorService(IManagedContainer container)
{
return ExecutorServiceFactory.get(container);
}
public static IBufferProvider getBufferProvider(IManagedContainer container)
{
return BufferProviderFactory.get(container);
}
public static IAcceptor getAcceptor(IManagedContainer container, String type, String description)
{
return (IAcceptor)container.getElement(AcceptorFactory.PRODUCT_GROUP, type, description);
}
/**
* @since 4.0
*/
public static IConnector getConnector(IManagedContainer container, String type, String description, long timeout)
{
IConnector connector = (IConnector)container.getElement(ConnectorFactory.PRODUCT_GROUP, type, description);
try
{
connector.waitForConnection(timeout);
}
catch (ConnectorException ex)
{
container.removeElement(ConnectorFactory.PRODUCT_GROUP, type, description);
throw ex;
}
return connector;
}
public static IConnector getConnector(IManagedContainer container, String type, String description)
{
return getConnector(container, type, description, 10000L);
}
public static IConnector getConnector(IManagedContainer container, String description)
{
int pos = description.indexOf(SCHEME_SEPARATOR);
if (pos <= 0)
{
throw new IllegalArgumentException("Connector type (scheme) missing: " + description); //$NON-NLS-1$
}
String factoryType = description.substring(0, pos);
String connectorDescription = description.substring(pos + SCHEME_SEPARATOR.length());
if (StringUtil.isEmpty(connectorDescription))
{
throw new IllegalArgumentException("Illegal connector description: " + description); //$NON-NLS-1$
}
return getConnector(container, factoryType, connectorDescription);
}
public static IBufferProvider createBufferFactory(short bufferCapacity)
{
return new BufferFactory(bufferCapacity);
}
public static IBufferProvider createBufferFactory()
{
return createBufferFactory(DEFAULT_BUFFER_CAPACITY);
}
public static IBufferPool createBufferPool(IBufferProvider factory)
{
return new BufferPool(factory);
}
public static IBufferPool createBufferPool(short bufferCapacity)
{
return createBufferPool(createBufferFactory(bufferCapacity));
}
public static IBufferPool createBufferPool()
{
return createBufferPool(createBufferFactory());
}
public static long getProvidedBuffers(IBufferProvider bufferProvider)
{
if (bufferProvider instanceof IBufferProvider.Introspection)
{
return ((IBufferProvider.Introspection)bufferProvider).getProvidedBuffers();
}
return -1L;
}
public static long getRetainedBuffers(IBufferProvider bufferProvider)
{
if (bufferProvider instanceof IBufferProvider.Introspection)
{
return ((IBufferProvider.Introspection)bufferProvider).getRetainedBuffers();
}
return -1L;
}
public static int getPooledBuffers(IBufferPool bufferPool)
{
if (bufferPool instanceof IBufferPool.Introspection)
{
return ((IBufferPool.Introspection)bufferPool).getPooledBuffers();
}
return -1;
}
/**
* @since 2.0
*/
public static ITransportConfig copyTransportConfig(ILifecycle lifecycle, ITransportConfig source)
{
return new TransportConfig(lifecycle, source.getReceiveExecutor(), source.getBufferProvider(), source.getProtocolProvider(), source.getNegotiator());
}
/**
* @since 4.2
*/
public static String getProtocolID(IProtocol<?> protocol)
{
if (protocol != null)
{
return protocol.getType();
}
return null;
}
/**
* @since 4.2
*/
public static int getProtocolVersion(IProtocol<?> protocol)
{
if (protocol instanceof IProtocol2)
{
return ((IProtocol2<?>)protocol).getVersion();
}
return IProtocol2.UNSPECIFIED_VERSION;
}
}