server context implementation

2011-01-31 22:52:25 +01:00
parent 5ee480beee
commit 327efbcf80
5 changed files with 977 additions and 10 deletions
--- a/pvAccessApp/server/serverContext.cpp
+++ b/pvAccessApp/server/serverContext.cpp
@@ -0,0 +1,510 @@
+/*
+ * serverContext.cpp
+ */
+
+#include "serverContext.h"
+#include "responseHandlers.h"
+
+namespace epics { namespace pvAccess {
+
+const char* ServerContextImpl::StateNames[] = { "NOT_INITIALIZED", "INITIALIZED", "RUNNING", "SHUTDOWN", "DESTROYED"};
+const int32 ServerContextImpl::VERSION_MAJOR = 2;
+const int32 ServerContextImpl::VERSION_MINOR = 0;
+const int32 ServerContextImpl::VERSION_MAINTENANCE = 0;
+const int32 ServerContextImpl::VERSION_DEVELOPMENT = 0;
+const Version* ServerContextImpl::VERSION = new Version("Channel Access Server in C++", "C++",
+		ServerContextImpl::VERSION_MAJOR,
+		ServerContextImpl::VERSION_MINOR,
+		ServerContextImpl::VERSION_MAINTENANCE,
+		ServerContextImpl::VERSION_DEVELOPMENT);
+
+
+ServerContextImpl::ServerContextImpl():
+				_state(NOT_INITIALIZED),
+				_beaconAddressList(""),
+				_ignoreAddressList(""),
+				_autoBeaconAddressList(true),
+				_beaconPeriod(15.0),
+				_broadcastPort(CA_BROADCAST_PORT),
+				_serverPort(CA_SERVER_PORT),
+				_receiveBufferSize(MAX_TCP_RECV),
+				_timer(NULL),
+				_broadcastTransport(NULL),
+				_beaconEmitter(NULL),
+				_acceptor(NULL),
+				_transportRegistry(NULL),
+				_channelAccess(NULL),
+				//TODO CAJ_DEFAULT_PROVIDER is not defined
+				_channelProviderName("local"),
+				//_channelProviderName(CAJ_DEFAULT_PROVIDER),
+				_channelProvider(NULL),
+				_beaconServerStatusProvider(NULL)
+
+{
+	initializeLogger();
+	loadConfiguration();
+}
+
+ServerContextImpl::~ServerContextImpl()
+{
+}
+
+const Version* ServerContextImpl::getVersion()
+{
+    return ServerContextImpl::VERSION;
+}
+
+void ServerContextImpl::initializeLogger()
+{
+	createFileLogger("serverContextImpl.log");
+}
+
+Configuration* ServerContextImpl::getConfiguration()
+{
+	ConfigurationProvider* configurationProvider =  ConfigurationFactory::getProvider();
+	Configuration* config = configurationProvider->getConfiguration("pvAccess-server");
+	if (config == NULL)
+	{
+		config = configurationProvider->getConfiguration("system");
+	}
+	return config;
+}
+
+/**
+ * Load configuration.
+ */
+void ServerContextImpl::loadConfiguration()
+{
+	Configuration* config = getConfiguration();
+
+	_beaconAddressList = config->getPropertyAsString("EPICS4_CA_ADDR_LIST", _beaconAddressList);
+	_beaconAddressList = config->getPropertyAsString("EPICS4_CAS_BEACON_ADDR_LIST", _beaconAddressList);
+
+	_autoBeaconAddressList = config->getPropertyAsBoolean("EPICS4_CA_AUTO_ADDR_LIST", _autoBeaconAddressList);
+	_autoBeaconAddressList = config->getPropertyAsBoolean("EPICS4_CAS_AUTO_BEACON_ADDR_LIST", _autoBeaconAddressList);
+
+	_beaconPeriod = config->getPropertyAsFloat("EPICS4_CA_BEACON_PERIOD", _beaconPeriod);
+	_beaconPeriod = config->getPropertyAsFloat("EPICS4_CAS_BEACON_PERIOD", _beaconPeriod);
+
+	_serverPort = config->getPropertyAsInteger("EPICS4_CA_SERVER_PORT", _serverPort);
+	_serverPort = config->getPropertyAsInteger("EPICS4_CAS_SERVER_PORT", _serverPort);
+
+	_broadcastPort = config->getPropertyAsInteger("EPICS4_CA_BROADCAST_PORT", _broadcastPort);
+	_broadcastPort = config->getPropertyAsInteger("EPICS4_CAS_BROADCAST_PORT", _broadcastPort);
+
+	_receiveBufferSize = config->getPropertyAsInteger("EPICS4_CA_MAX_ARRAY_BYTES", _receiveBufferSize);
+	_receiveBufferSize = config->getPropertyAsInteger("EPICS4_CAS_MAX_ARRAY_BYTES", _receiveBufferSize);
+
+	_channelProviderName = config->getPropertyAsString("EPICS4_CA_PROVIDER_NAME", _channelProviderName);
+	_channelProviderName = config->getPropertyAsString("EPICS4_CAS_PROVIDER_NAME", _channelProviderName);
+}
+
+void ServerContextImpl::initialize(ChannelAccess* channelAccess)
+{
+	//TODO
+	/*Lock guard(&_mutex);
+	if (channelAccess == NULL)
+	{
+		THROW_BASE_EXCEPTION("non null channelAccess expected");
+	}
+
+	if (_state == DESTROYED)
+	{
+		THROW_BASE_EXCEPTION("Context destroyed.");
+	}
+	else if (_state != NOT_INITIALIZED)
+	{
+		THROW_BASE_EXCEPTION("Context already initialized.");
+	}
+
+	_channelAccess = channelAccess;
+
+	_channelProvider = _channelAccess->getProvider(_channelProviderName);
+	if (_channelProvider == NULL)
+	{
+		std::string msg = "Channel provider with name '" + _channelProviderName + "' not available.";
+		THROW_BASE_EXCEPTION(msg.c_str());
+	}*/
+
+	internalInitialize();
+
+	_state = INITIALIZED;
+}
+
+void ServerContextImpl::internalInitialize()
+{
+	_timer = new Timer("pvAccess-server timer",lowerPriority);
+	_transportRegistry = new TransportRegistry();
+
+	// setup broadcast UDP transport
+	initializeBroadcastTransport();
+
+	_acceptor = new BlockingTCPAcceptor(this, _serverPort, _receiveBufferSize);
+	_serverPort = _acceptor->getBindAddress()->ia.sin_port;
+
+	_beaconEmitter = new BeaconEmitter(_broadcastTransport, this);
+}
+
+void ServerContextImpl::initializeBroadcastTransport()
+{
+
+	// setup UDP transport
+	try
+	{
+		// where to bind (listen) address
+	    osiSockAddr listenLocalAddress;
+	    listenLocalAddress.ia.sin_family = AF_INET;
+	    listenLocalAddress.ia.sin_port = htons(_broadcastPort);
+	    listenLocalAddress.ia.sin_addr.s_addr = htonl(INADDR_ANY);
+
+		// where to send address
+	    SOCKET socket = epicsSocketCreate(AF_INET, SOCK_STREAM, IPPROTO_TCP);
+	    InetAddrVector* broadcasts = getBroadcastAddresses(socket,_broadcastPort);
+	    epicsSocketDestroy(socket);
+
+
+	    BlockingUDPConnector*  broadcastConnector = new BlockingUDPConnector(true, true);
+
+		_broadcastTransport = static_cast<BlockingUDPTransport*>(broadcastConnector->connect(
+									NULL, new ServerResponseHandler(this),
+									listenLocalAddress, CA_MINOR_PROTOCOL_REVISION,
+									CA_DEFAULT_PRIORITY));
+
+		_broadcastTransport->setBroadcastAddresses(broadcasts);
+
+		// set ignore address list
+		if (_ignoreAddressList.length() > 0)
+		{
+			// we do not care about the port
+			InetAddrVector* list = getSocketAddressList(_ignoreAddressList, 0, NULL);
+			if (list != NULL && list->size() > 0)
+			{
+				_broadcastTransport->setIgnoredAddresses(list);
+			}
+		}
+		// set broadcast address list
+		if (_beaconAddressList.length() > 0)
+		{
+			// if auto is true, add it to specified list
+			InetAddrVector* appendList = NULL;
+			if (_autoBeaconAddressList == true)
+			{
+				appendList = _broadcastTransport->getSendAddresses();
+			}
+
+			InetAddrVector* list = getSocketAddressList(_beaconAddressList, _broadcastPort, appendList);
+			if (list != NULL  && list->size() > 0)
+			{
+				_broadcastTransport->setBroadcastAddresses(list);
+			}
+		}
+
+		_broadcastTransport->start();
+	}
+	catch (...)
+	{
+		THROW_BASE_EXCEPTION("Failed to initialize broadcast UDP transport");
+	}
+}
+
+void ServerContextImpl::run(int32 seconds)
+{
+	if (seconds < 0)
+	{
+		THROW_BASE_EXCEPTION("seconds cannot be negative.");
+	}
+
+	{
+		Lock guard(&_mutex);
+
+		if (_state == NOT_INITIALIZED)
+		{
+			THROW_BASE_EXCEPTION("Context not initialized.");
+		}
+		else if (_state == DESTROYED)
+		{
+			THROW_BASE_EXCEPTION("Context destroyed.");
+		}
+		else if (_state == RUNNING)
+		{
+			THROW_BASE_EXCEPTION("Context is already running.");
+		}
+		else if (_state == SHUTDOWN)
+		{
+			THROW_BASE_EXCEPTION("Context was shutdown.");
+		}
+
+		_state = RUNNING;
+	}
+
+	// run...
+	_beaconEmitter->start();
+
+	//TODO review how is with guards
+	if(seconds == 0)
+	{
+		_runEvent.wait();
+	}
+	else
+	{
+		_runEvent.wait(seconds);
+	}
+
+	{
+		Lock guard(&_mutex);
+		_state = SHUTDOWN;
+	}
+}
+
+void ServerContextImpl::shutdown()
+{
+	Lock guard(&_mutex);
+	if(_state == DESTROYED)
+	{
+		THROW_BASE_EXCEPTION("Context already destroyed.");
+	}
+
+
+	// notify to stop running...
+	_runEvent.signal();
+}
+
+void ServerContextImpl::destroy()
+{
+	Lock guard(&_mutex);
+	if (_state == DESTROYED)
+	{
+		THROW_BASE_EXCEPTION("Context already destroyed.");
+	}
+
+	// shutdown if not already
+	shutdown();
+
+	// go into destroyed state ASAP
+	_state = DESTROYED;
+
+	internalDestroy();
+}
+
+
+void ServerContextImpl::internalDestroy()
+{
+	// stop responding to search requests
+	if (_broadcastTransport != NULL)
+	{
+		_broadcastTransport->close(true);
+	}
+
+	// stop accepting connections
+	if (_acceptor != NULL)
+	{
+		_acceptor->destroy();
+	}
+
+	// stop emitting beacons
+	if (_beaconEmitter != NULL)
+	{
+		_beaconEmitter->destroy();
+	}
+
+	// stop timer
+	if (_timer != NULL)
+	{
+		//TODO there is no stop in Timer
+	//	_timer->stop();
+	}
+
+	// this will also destroy all channels
+	destroyAllTransports();
+}
+
+void ServerContextImpl::destroyAllTransports()
+{
+
+	// not initialized yet
+	if (_transportRegistry == NULL)
+	{
+		return;
+	}
+
+	int32 size;
+	Transport** transports = _transportRegistry->toArray(size);
+
+	if (size == 0)
+	{
+		return;
+	}
+
+	errlogSevPrintf(errlogMajor, "Server context still has %d transport(s) active and closing...", size);
+
+	for (int i = 0; i < size; i++)
+	{
+		Transport* transport = transports[i];
+		try
+		{
+			transport->close(true);
+		}
+		catch (std::exception &e)
+		{
+			// do all exception safe, log in case of an error
+			errlogSevPrintf(errlogMajor, "Unhandled exception caught from client code at %s:%d: %s", __FILE__, __LINE__, e.what());
+		}
+		catch (...)
+		{
+			// do all exception safe, log in case of an error
+			 errlogSevPrintf(errlogMajor, "Unhandled exception caught from client code at %s:%d.", __FILE__, __LINE__);
+		}
+	}
+
+	delete[] transports;
+}
+
+void ServerContextImpl::printInfo()
+{
+	printInfo(cout);
+}
+
+void ServerContextImpl::printInfo(ostream& str)
+{
+	Lock guard(&_mutex);
+	str << "VERSION : " << getVersion()->getVersionString() << endl \
+		<< "CHANNEL PROVIDER : " << _channelProviderName << endl \
+		<< "BEACON_ADDR_LIST : " << _beaconAddressList << endl \
+	    << "AUTO_BEACON_ADDR_LIST : " << _autoBeaconAddressList << endl \
+	    << "BEACON_PERIOD : " << _beaconPeriod << endl \
+	    << "BROADCAST_PORT : " << _broadcastPort << endl \
+	    << "SERVER_PORT : " << _serverPort << endl \
+	    << "RCV_BUFFER_SIZE : " << _receiveBufferSize << endl \
+	    << "IGNORE_ADDR_LIST: " << _ignoreAddressList << endl \
+	    << "STATE : " << ServerContextImpl::StateNames[_state] << endl;
+}
+
+void ServerContextImpl::dispose()
+{
+	try
+	{
+		destroy();
+	}
+	catch(...)
+	{
+		// noop
+	}
+}
+
+void ServerContextImpl::setBeaconServerStatusProvider(BeaconServerStatusProvider* beaconServerStatusProvider)
+{
+	_beaconServerStatusProvider = beaconServerStatusProvider;
+}
+
+bool ServerContextImpl::isInitialized()
+{
+	Lock guard(&_mutex);
+	return _state == INITIALIZED || _state == RUNNING || _state == SHUTDOWN;
+}
+
+bool ServerContextImpl::isDestroyed()
+{
+	Lock guard(&_mutex);
+	return _state == DESTROYED;
+}
+
+std::string ServerContextImpl::getBeaconAddressList()
+{
+	return _beaconAddressList;
+}
+
+bool ServerContextImpl::isAutoBeaconAddressList()
+{
+	return _autoBeaconAddressList;
+}
+
+float ServerContextImpl::getBeaconPeriod()
+{
+	return _beaconPeriod;
+}
+
+int32 ServerContextImpl::getReceiveBufferSize()
+{
+	return _receiveBufferSize;
+}
+
+int32 ServerContextImpl::getServerPort()
+{
+	return _serverPort;
+}
+
+void ServerContextImpl::setServerPort(int32 port)
+{
+	_serverPort = port;
+}
+
+int32 ServerContextImpl::getBroadcastPort()
+{
+	return _broadcastPort;
+}
+
+std::string ServerContextImpl::getIgnoreAddressList()
+{
+	return _ignoreAddressList;
+}
+
+BeaconServerStatusProvider* ServerContextImpl::getBeaconServerStatusProvider()
+{
+	return _beaconServerStatusProvider;
+}
+
+osiSockAddr* ServerContextImpl::getServerInetAddress()
+{
+	if(_acceptor != NULL)
+	{
+		return _acceptor->getBindAddress();
+	}
+	return NULL;
+}
+
+BlockingUDPTransport* ServerContextImpl::getBroadcastTransport()
+{
+	return _broadcastTransport;
+}
+
+ChannelAccess* ServerContextImpl::getChannelAccess()
+{
+	return _channelAccess;
+}
+
+std::string ServerContextImpl::getChannelProviderName()
+{
+	return _channelProviderName;
+}
+
+ChannelProvider* ServerContextImpl::getChannelProvider()
+{
+	return _channelProvider;
+}
+
+Timer* ServerContextImpl::getTimer()
+{
+	return _timer;
+}
+
+TransportRegistry* ServerContextImpl::getTransportRegistry()
+{
+	return _transportRegistry;
+}
+
+//TODO what with this?
+Channel* ServerContextImpl::getChannel(pvAccessID id)
+{
+	return NULL;
+}
+
+//TODO what with this?
+Transport* ServerContextImpl::getSearchTransport()
+{
+	return NULL;
+}
+
+
+
+}
+}