You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
390 lines
10 KiB
390 lines
10 KiB
/***************************************************************************
|
|
* 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 <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)
|
|
{
|
|
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;
|
|
}
|
|
|
|
TQPtrList<KAction> RemoteInstrumentPart::menuActionList() {
|
|
return TQPtrList<KAction>();
|
|
}
|
|
|
|
void RemoteInstrumentPart::resize(TQSize size) {
|
|
TQWidget* parentWidget = dynamic_cast<TQWidget*>(parent());
|
|
if (parentWidget) {
|
|
parentWidget->setFixedSize(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"));
|
|
}
|
|
}
|
|
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;
|
|
}
|
|
else {
|
|
connToServerState = -1;
|
|
connToServerConnecting = false;
|
|
disconnectFromServer();
|
|
KMessageBox::error(0, i18n("<qt>Unable to establish connection to remote server</qt>"), i18n("Connection Failed"));
|
|
}
|
|
}
|
|
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"));
|
|
}
|
|
else {
|
|
connToServerState = 2;
|
|
}
|
|
}
|
|
break;
|
|
case 2:
|
|
// Connection established!
|
|
// Read magic number and proto version from server
|
|
m_socket->processPendingData();
|
|
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;
|
|
}
|
|
break;
|
|
case 3:
|
|
// Read response from server
|
|
m_socket->processPendingData();
|
|
if (m_socket->bytesAvailable() > 0) {
|
|
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;
|
|
}
|
|
}
|
|
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;
|
|
}
|
|
|
|
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
|
|
|