ClientConnectionAdapter.cpp

/*
 * ClientConnectionAdapter.cpp
 *
 *  Created on: Nov 2, 2012
 *      Author: Mitchell Wills
 */

#include "networktables2/client/ClientConnectionAdapter.h"
#include "networktables2/util/System.h"

void ClientConnectionAdapter::gotoState(ClientConnectionState* newState){
        {
                NTSynchronized sync(LOCK);
                if(connectionState!=newState){
                        fprintf(stdout, "[NT] %p entered connection state: %s\n", (void*)this, newState->toString());
                        fflush(stdout);
                        if(newState==&ClientConnectionState::IN_SYNC_WITH_SERVER)
                                connectionListenerManager.FireConnectedEvent();
                        if(connectionState==&ClientConnectionState::IN_SYNC_WITH_SERVER)
                                connectionListenerManager.FireDisconnectedEvent();
                        //TODO find better way to manage memory leak
                        ClientConnectionState_Error *temp=dynamic_cast<ClientConnectionState_Error *>(connectionState);
                        connectionState = newState;
                        if (temp)
                                delete temp;
                }
        }
}
ClientConnectionState* ClientConnectionAdapter::getConnectionState(){
        return connectionState;
}
bool ClientConnectionAdapter::isConnected() {
        return getConnectionState()==&ClientConnectionState::IN_SYNC_WITH_SERVER;
}

ClientConnectionAdapter::ClientConnectionAdapter(ClientNetworkTableEntryStore& _entryStore, NTThreadManager& _threadManager, IOStreamFactory& _streamFactory, ClientConnectionListenerManager& _connectionListenerManager, NetworkTableEntryTypeManager& _typeManager):
        entryStore(_entryStore),
        streamFactory(_streamFactory),
        threadManager(_threadManager),
        connectionListenerManager(_connectionListenerManager),
        typeManager(_typeManager),
        readThread(NULL),
        monitor(NULL),
        connection(NULL){
        connectionState = &ClientConnectionState::DISCONNECTED_FROM_SERVER;
}
ClientConnectionAdapter::~ClientConnectionAdapter()
{
        if(readThread!=NULL)
                readThread->stop();
        if (connection)
                connection->close();
        if(readThread!=NULL)
        {
            delete readThread;
                readThread = NULL;
        }
        if(monitor!=NULL)
        {
                delete monitor;
                monitor = NULL;
        }       
        close();
        if(connection!=NULL){
                delete connection;
                connection = NULL;
        }       

        //TODO find better way to manage memory leak
        ClientConnectionState_Error *temp=dynamic_cast<ClientConnectionState_Error *>(connectionState);
        if (temp)
        {
                delete temp;
                connectionState=NULL;
        }
}


/*
 * Connection management
 */
void ClientConnectionAdapter::reconnect() {
        //This is in reconnect so that the entry store doesn't have to be valid when this object is deleted
        //Note:  clearIds() cannot be in a LOCK critical section
        entryStore.clearIds();
        {
                NTSynchronized sync(LOCK);
                close();//close the existing stream and monitor thread if needed
                try{
                        IOStream* stream = streamFactory.createStream();
                        if(stream==NULL)
                                return;
                        if (!connection)
                                connection = new NetworkTableConnection(stream, typeManager);
                        else
                                connection->SetIOStream(stream);
                        m_IsConnectionClosed=false;
                        if (!monitor)
                                monitor = new ConnectionMonitorThread(*this, *connection);
                        if (!readThread)
                                readThread = threadManager.newBlockingPeriodicThread(monitor, "Client Connection Reader Thread");
                        connection->sendClientHello();
                        gotoState(&ClientConnectionState::CONNECTED_TO_SERVER);
                } catch(IOException& e){
                        close();//make sure to clean everything up if we fail to connect
                }
        }
}

void ClientConnectionAdapter::close() {
        close(&ClientConnectionState::DISCONNECTED_FROM_SERVER);
}
void ClientConnectionAdapter::close(ClientConnectionState* newState) {
        {
                NTSynchronized sync(LOCK);
                gotoState(newState);
                //Disconnect the socket
                if(connection!=NULL)
                {
                        connection->close();
                        connection->SetIOStream(NULL);  //disconnect the table connection from the IO stream
                }
                m_IsConnectionClosed=true;
        }
}



void ClientConnectionAdapter::badMessage(BadMessageException& e) {
        close(new ClientConnectionState_Error(e));
        sleep_ms(33);  //avoid busy wait
}

void ClientConnectionAdapter::ioException(IOException& e) {
        if(connectionState!=&ClientConnectionState::DISCONNECTED_FROM_SERVER)//will get io exception when on read thread connection is closed
        {
                reconnect();
                sleep_ms(500);
        }
        else
        {
                sleep_ms(33);  //avoid busy wait
        }
}

NetworkTableEntry* ClientConnectionAdapter::GetEntry(EntryId id) {
        return entryStore.GetEntry(id);
}


bool ClientConnectionAdapter::keepAlive() {
        return true;
}

void ClientConnectionAdapter::clientHello(ProtocolVersion protocolRevision) {
        throw BadMessageException("A client should not receive a client hello message");
}

void ClientConnectionAdapter::protocolVersionUnsupported(ProtocolVersion protocolRevision) {
        close();
        gotoState(new ClientConnectionState_ProtocolUnsuppotedByServer(protocolRevision));
}

void ClientConnectionAdapter::serverHelloComplete() {
        if (connectionState==&ClientConnectionState::CONNECTED_TO_SERVER) {
                try {
                        gotoState(&ClientConnectionState::IN_SYNC_WITH_SERVER);
                        entryStore.sendUnknownEntries(*connection);
                } catch (IOException& e) {
                        ioException(e);
                }
        }
        else
                throw BadMessageException("A client should only receive a server hello complete once and only after it has connected to the server");
}


void ClientConnectionAdapter::offerIncomingAssignment(NetworkTableEntry* entry) {
        entryStore.offerIncomingAssignment(entry);
}
void ClientConnectionAdapter::offerIncomingUpdate(NetworkTableEntry* entry, SequenceNumber sequenceNumber, EntryValue value) {
        entryStore.offerIncomingUpdate(entry, sequenceNumber, value);
}

void ClientConnectionAdapter::offerOutgoingAssignment(NetworkTableEntry* entry) {
        try {
                {
                        NTSynchronized sync(LOCK);
                        if(connection!=NULL && connectionState==&ClientConnectionState::IN_SYNC_WITH_SERVER)
                                connection->sendEntryAssignment(*entry);
                }
        } catch(IOException& e){
                ioException(e);
        }
}

void ClientConnectionAdapter::offerOutgoingUpdate(NetworkTableEntry* entry) {
        try {
                {
                        NTSynchronized sync(LOCK);
                        if(connection!=NULL && connectionState==&ClientConnectionState::IN_SYNC_WITH_SERVER)
                                connection->sendEntryUpdate(*entry);
                }
        } catch(IOException& e){
                ioException(e);
        }
}
void ClientConnectionAdapter::flush() {
        {
                NTSynchronized sync(LOCK);
                if(connection!=NULL) {
                        try {
                                connection->flush();
                        } catch (IOException& e) {
                                ioException(e);
                        }
                }
        }
}
void ClientConnectionAdapter::ensureAlive() {
        {
                NTSynchronized sync(LOCK);
                if ((connection!=NULL)&&(!m_IsConnectionClosed)) {
                        try {
                          connection->sendKeepAlive();
                        } catch (IOException& e) {
                                ioException(e);
                        }
                }
                else
                        reconnect();//try to reconnect if not connected
        }
}