remotelaboratory/lib/libtqtrla/src/tqtrla.cpp

/***************************************************************************
 *   Copyright (C) 2012 by Timothy Pearson                                 *
 *   kb9vqf@pearsoncomputing.net                                           *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/

#include "tqtrla.h"

#include <tqwidget.h>
#include <tqbuffer.h>

#include <klocale.h>
#include <kmessagebox.h>

// RAJA UNCOMMENT ME
//#define SERVER_TIMEOUT_MS 10000
// RAJA DEBUG ONLY
#define SERVER_TIMEOUT_MS 100000
#define FPGA_DATA_PROCESSING_TIMEOUT_MS 2500

namespace KParts
{
	class RemoteInstrumentPartPrivate
	{
		public:
			RemoteInstrumentPartPrivate() {
				//
			}
		
			~RemoteInstrumentPartPrivate() {
				//
			}
	};
	
	RemoteInstrumentPart::RemoteInstrumentPart(TQObject *parent, const char *name)
		: Part( parent, name ),
		m_socket(NULL), connToServerConnecting(false), connToServerState(-1), connToServerTimeoutTimer(NULL), m_fixedSize(false)
	{
		d = new RemoteInstrumentPartPrivate;

		// Create timers
		m_connectionTimer = new TQTimer(this);
		connect(m_connectionTimer, SIGNAL(timeout()), this, SLOT(finishConnectingToServer()));
	}
	
	RemoteInstrumentPart::~RemoteInstrumentPart() {
		RemoteInstrumentPart::closeURL();
		delete d;
	}

	bool RemoteInstrumentPart::openURL(const KURL &url) {
		m_url = url;
		return false;
	}

	bool RemoteInstrumentPart::closeURL() {
		return false;
	}

	void RemoteInstrumentPart::setUsingFixedSize(bool fixed) {
		m_fixedSize = fixed;
		if (!fixed) {
			TQWidget* parentWidget = dynamic_cast<TQWidget*>(parent());
			if (parentWidget) {
				parentWidget->setMinimumSize(0, 0);
				parentWidget->setMaximumSize(TQWIDGETSIZE_MAX, TQWIDGETSIZE_MAX);
			}
		}
		emit(usingFixedSizeChanged(fixed));
	}

	TQPtrList<KAction> RemoteInstrumentPart::menuActionList() {
		return TQPtrList<KAction>();
	}

	void RemoteInstrumentPart::resize(TQSize size) {
		TQWidget* parentWidget = dynamic_cast<TQWidget*>(parent());
		if (parentWidget) {
			if (m_fixedSize) {
				parentWidget->setFixedSize(size);
			}
			else {
				parentWidget->resize(size);
			}
		}
	}

	void RemoteInstrumentPart::close() {
		TQWidget* parentWidget = dynamic_cast<TQWidget*>(parent());
		if (parentWidget) {
			parentWidget->close();
		}
	}

	void RemoteInstrumentPart::setStatusMessage(const TQString& message) {
		emit(statusMessageSet(message));
	}

	TQ_ULONG RemoteInstrumentPart::maximumSocketDataChunkSize() {
		// FIXME
		// Dynamically set this!
		return 512;
	}

	TQStringList RemoteInstrumentPart::textForServerError(TQString shortError) {
		TQStringList ret;

		if (shortError == "ERRNOCONN") {
			ret.append(i18n("<qt>Unable to establish connection with backend server<p>Please verify that you are currently connected to a workspace</qt>"));
			ret.append(i18n("Connection Failed"));
		}
		else if (shortError == "ERRNOTAVL") {
			ret.append(i18n("<qt>The backend server is not available at this time<p>Please try a different workspace, or try again later</qt>"));
			ret.append(i18n("Connection Failed"));
		}
		else if (shortError == "ERRNOSERV") {
			ret.append(i18n("<qt>The active laboratory workspace does not support the requested service</qt>"));
			ret.append(i18n("Service Unavailable"));
		}
		else {
			ret.append(i18n("<qt>Unable to establish connection with remote server</qt>"));
			ret.append(i18n("Connection Failed"));
		}

		return ret;
	}

	int RemoteInstrumentPart::connectToServer(TQString server) {
		if (m_socket) {
			return -1;
		}
		if (!m_socket) {
			m_socket = new TDEKerberosClientSocket(this);
			connect(m_socket, TQT_SIGNAL(statusMessageUpdated(const TQString&)), this, TQT_SLOT(setStatusMessage(const TQString&) ));
		}
		m_socket->setServiceName("remotefpga");
		m_socket->setServerFQDN(server);
		m_socket->connectToHost(server, 4004);
	
		// Finish connecting when appropriate
		connToServerState = 0;
		connToServerConnecting = true;
		m_connectionTimer->start(100, TRUE);
	
		return 0;
	}

	void RemoteInstrumentPart::disconnectFromServer() {
		disconnectFromServerCallback();
		m_connectionTimer->stop();
		if (m_socket) {
			m_socket->clearPendingData();
			m_socket->close();
			delete m_socket;
			m_socket = NULL;
		}
		connectionStatusChangedCallback();
	}

	void RemoteInstrumentPart::finishConnectingToServer() {
		if (!m_socket) {
			connToServerState = -1;
			connToServerConnecting = false;
			connectionStatusChangedCallback();
			return;
		}
	
		if (connToServerConnecting) {
			switch(connToServerState) {
				case 0:
					if (!connToServerTimeoutTimer) {
						connToServerTimeoutTimer = new TQTimer;
						connToServerTimeoutTimer->start(SERVER_TIMEOUT_MS, TRUE);
					}
					if ((m_socket->state() == TQSocket::Connecting) || (m_socket->state() == TQSocket::HostLookup)) {
						if (!connToServerTimeoutTimer->isActive()) {
							connToServerState = -3;
							connToServerConnecting = false;
							disconnectFromServer();
							KMessageBox::error(0, i18n("<qt>Unable to establish connection to remote server</qt>"), i18n("Connection Failed"));
							close();
							return;
						}
					}
					else {
						if (m_socket->state() == TQSocket::Connected) {
							printf("[DEBUG] Initial connection established...\n\r"); fflush(stdout);
							m_socket->setDataTimeout(SERVER_TIMEOUT_MS);
							m_socket->setUsingKerberos(true);
							connToServerState = 1;
							connToServerTimeoutTimer->stop();
							connToServerTimeoutTimer->start(SERVER_TIMEOUT_MS, TRUE);
						}
						else {
							connToServerState = -1;
							connToServerConnecting = false;
							disconnectFromServer();
							KMessageBox::error(0, i18n("<qt>Unable to establish connection to remote server</qt>"), i18n("Connection Failed"));
							close();
							return;
						}
					}
					break;
				case 1:
					if (m_socket->kerberosStatus() == TDEKerberosClientSocket::KerberosInitializing) {
						// Do nothing
					}
					else {
						if (m_socket->kerberosStatus() != TDEKerberosClientSocket::KerberosInUse) {
							connToServerState = -1;
							connToServerConnecting = false;
							disconnectFromServer();
							KMessageBox::error(0, i18n("<qt>Unable to establish Kerberos protocol with remote server<p>Please verify that you currently hold a valid Kerberos ticket</qt>"), i18n("Connection Failed"));
							close();
							return;
						}
						else {
							connToServerState = 2;
							connToServerTimeoutTimer->stop();
							connToServerTimeoutTimer->start(SERVER_TIMEOUT_MS, TRUE);
						}
					}
					break;
				case 2:
					// Connection established!
					// Read magic number and proto version from server
					if (m_socket->canReadFrame()) {
						TQDataStream ds(m_socket);
						ds.setPrintableData(true);
						TQ_UINT32 magicnum;
						TQ_UINT32 protover;
						ds >> magicnum;
						ds >> protover;
						m_socket->clearFrameTail();
						printf("[DEBUG] Got magic number %d and protocol version %d\n\r", magicnum, protover); fflush(stdout);
	
						// Request connection to backend server
						ds << TQString("SERV");
						m_socket->writeEndOfFrame();
						ds << m_clientLibraryName;
						m_socket->writeEndOfFrame();
						connToServerState = 3;
						connToServerTimeoutTimer->stop();
						connToServerTimeoutTimer->start(SERVER_TIMEOUT_MS, TRUE);
					}
					else {
						if ((!connToServerTimeoutTimer->isActive()) || (m_socket->state() != TQSocket::Connected)) {
							connToServerState = -1;
							connToServerConnecting = false;
							disconnectFromServer();
							KMessageBox::error(0, i18n("<qt>Connection with remote server terminated<p>This may indicate that the requested service is not functional</qt>"), i18n("Connection Failed"));
							close();
							return;
						}
					}
					break;
				case 3:
					// Read response from server
					if (m_socket->canReadFrame()) {
						TQDataStream ds(m_socket);
						ds.setPrintableData(true);
						TQString response;
						ds >> response;
						m_socket->clearFrameTail();
						if (response == "OK") {
							connToServerState = 4;
							connToServerConnecting = false;
							connectionFinishedCallback();
							return;
						}
						else {
							TQStringList errorStrings = textForServerError(response);
							connToServerState = -1;
							connToServerConnecting = false;
							disconnectFromServer();
							KMessageBox::error(0, errorStrings[0], errorStrings[1]);
							close();
							return;
						}
					}
					else {
						if ((!connToServerTimeoutTimer->isActive()) || (m_socket->state() != TQSocket::Connected)) {
							connToServerState = -1;
							connToServerConnecting = false;
							disconnectFromServer();
							KMessageBox::error(0, i18n("<qt>Connection with remote server terminated<p>This may indicate that the requested service is not functional</qt>"), i18n("Connection Failed"));
							close();
							return;
						}
					}
					break;
			}
	
			m_connectionTimer->start(100, TRUE);
		}
	}

	void RemoteInstrumentPart::connectionFinishedCallback() {
		//
	}

	void RemoteInstrumentPart::disconnectFromServerCallback() {
		//
	}

	void RemoteInstrumentPart::connectionStatusChangedCallback() {
		//
	}
}

TQDataStream &operator<<( TQDataStream &s, const TQFloatArray &data ) {
	TQ_UINT32 i;
	TQ_UINT32 count = data.count();
	s << count;
	for (i=0; i<count; i++) {
		s << data[i];
	}
	return s;
}

TQDataStream &operator>>( TQDataStream &s, TQFloatArray &data ) {
	TQ_UINT32 i;
	TQ_UINT32 count;
	s >> count;
	data.resize(count);
	for (i=0; i<count; i++) {
		s >> data[i];
	}
	return s;
}

TQDataStream &operator<<( TQDataStream &s, const TQDoubleArray &data ) {
	TQ_UINT32 i;
	TQ_UINT32 count = data.count();
	s << count;
	for (i=0; i<count; i++) {
		s << data[i];
	}
	return s;
}

TQDataStream &operator>>( TQDataStream &s, TQDoubleArray &data ) {
	TQ_UINT32 i;
	TQ_UINT32 count;
	s >> count;
	data.resize(count);
	for (i=0; i<count; i++) {
		s >> data[i];
	}
	return s;
}

bool operator==( const ServiceType &s1, const ServiceType &s2 ) {
	bool identical = true;

	if (s1.type != s2.type) {
		identical = false;
	}

	return identical;
}

#ifndef QT_NO_DATASTREAM
/*!
    \relates ServiceType

    Writes the ServiceType \a str to the stream \a s.

    See also \link datastreamformat.html Format of the TQDataStream operators \endlink
*/

TQDataStream &operator<<( TQDataStream &s, const ServiceType &st )
{
	TQ_INT8 tempchar;

	s << st.type;
	s << st.name;
	s << st.description;
	s << st.clientLibrary;
	s << st.version;
	tempchar = (st.singleInstance)?1:0;
	s << tempchar;
	return s;
}

/*!
    \relates ServiceType

    Reads a ServiceType from the stream \a s into ServiceType \a str.

    See also \link datastreamformat.html Format of the TQDataStream operators \endlink
*/

TQDataStream &operator>>( TQDataStream &s, ServiceType &st )
{
	TQ_INT8 tempchar;

	s >> st.type;
	s >> st.name;
	s >> st.description;
	s >> st.clientLibrary;
	s >> st.version;
	s >> tempchar;
	st.singleInstance = (tempchar != 0);
	return s;
}

/*!
    \relates StationType

    Writes the StationType \a str to the stream \a s.

    See also \link datastreamformat.html Format of the TQDataStream operators \endlink
*/

TQDataStream &operator<<( TQDataStream &s, const StationType &st )
{
	s << st.id;
	s << st.type;
	s << st.services;
	s << st.name;
	s << st.description;
	return s;
}

/*!
    \relates StationType

    Reads a StationType from the stream \a s into StationType \a str.

    See also \link datastreamformat.html Format of the TQDataStream operators \endlink
*/

TQDataStream &operator>>( TQDataStream &s, StationType &st )
{
	s >> st.id;
	s >> st.type;
	s >> st.services;
	s >> st.name;
	s >> st.description;
	return s;
}
#endif // QT_NO_DATASTREAM