ArClientSwitchManager.cpp

Go to the documentation of this file.

/*
MobileRobots Advanced Robotics Interface for Applications (ARIA)
Copyright (C) 2004, 2005 ActivMedia Robotics LLC
Copyright (C) 2006, 2007 MobileRobots Inc.

     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

If you wish to redistribute ARIA under different terms, contact 
MobileRobots for information about a commercial version of ARIA at 
robots@mobilerobots.com or 
MobileRobots Inc, 19 Columbia Drive, Amherst, NH 03031; 800-639-9481
*/

#include "Aria.h"
#include "ArExport.h"
#include "ArClientSwitchManager.h"

AREXPORT ArClientSwitchManager::ArClientSwitchManager(
        ArServerBase *serverBase, ArArgumentParser *parser) :
  myParseArgsCB(this, &ArClientSwitchManager::parseArgs),
  myLogOptionsCB(this, &ArClientSwitchManager::logOptions),
  mySocketClosedCB(this, &ArClientSwitchManager::socketClosed),
  mySwitchCB(this, &ArClientSwitchManager::clientSwitch),
  myNetCentralHeartbeatCB(this, &ArClientSwitchManager::netCentralHeartbeat),
  myFileUserCB(this, &ArClientSwitchManager::fileUserCallback),
  myFilePasswordCB(this, &ArClientSwitchManager::filePasswordCallback),
  myFileServerKeyCB(this, &ArClientSwitchManager::fileServerKeyCallback)
{
  myServer = serverBase;
  myParser = parser;
  
  setThreadName("ArClientSwitchManager");

  mySwitchCB.setName("ArClientSwitchManager");

  myParseArgsCB.setName("ArClientSwitchManager");
  Aria::addParseArgsCB(&myParseArgsCB, 49);
  myLogOptionsCB.setName("ArClientSwitchManager");
  Aria::addLogOptionsCB(&myLogOptionsCB, 49);

  myNetCentralHeartbeatCB.setName("ArClientSwitchManager");
  myServer->addData("centralHeartbeat", 
                    "a packet that is requested and used by the central server to make sure there is still a connection, it should not be used by anyone or anything else, note that this sends a response over tcp and udp at the same time",
                    &myNetCentralHeartbeatCB, "none", "none", "RobotInfo", 
                    "RETURN_SINGLE");
  
  switchState(IDLE);
  myClient = NULL;
  myCentralServerPort = 5000;

  myFileUserCB.setName("ArClientSwitchManager::user");
  myFileParser.addHandler("user", &myFileUserCB);
  myFilePasswordCB.setName("ArClientSwitchManager::password");
  myFileParser.addHandler("password", &myFilePasswordCB);
  myFileServerKeyCB.setName("ArClientSwitchManager::serverKey");
  myFileParser.addHandler("serverKey", &myFileServerKeyCB);
}
 
AREXPORT ArClientSwitchManager::~ArClientSwitchManager()
{
}

AREXPORT void ArClientSwitchManager::switchState(State state)
{
  myState = state;
  myStartedState.setToNow();
  myGaveTimeWarning = false;
}

AREXPORT bool ArClientSwitchManager::parseArgs(void)
{
  const char *centralServer = NULL;
  const char *identifier = NULL;

  if (!myParser->checkParameterArgumentString("-centralServer", 
                                              &centralServer) || 
      !myParser->checkParameterArgumentString("-cs", &centralServer) || 
      !myParser->checkParameterArgumentInteger("-centralServerPort", 
                                     &myCentralServerPort) || 
      !myParser->checkParameterArgumentInteger("-csp", 
                                               &myCentralServerPort) || 
      !myParser->checkParameterArgumentString("-identifier", &identifier) || 
      !myParser->checkParameterArgumentString("-id", &identifier))
    return false;


  
  bool wasReallySet;
  const char *centralServerInfoFile = NULL;
  while (myParser->checkParameterArgumentString(
                 "-centralServerInfoFile", &centralServerInfoFile, 
                 &wasReallySet, true) && 
         wasReallySet)
  {
    if (centralServerInfoFile != NULL && !parseFile(centralServerInfoFile))
      return false;
  }
  
  myDataMutex.lock();
  if (centralServer != NULL && centralServer[0] != '\0')
  {
    myCentralServer = centralServer;
    myState = TRYING_CONNECTION;
  }

  if (identifier != NULL && identifier[0] != '\0')
  {
    myIdentifier = identifier;
  }
  /* Just don't set it so the server can just set it to the IP
  else 
  {
    int nameLen;
    char name[512];
    int i;
    
    nameLen = ArMath::random() % 15 + 1;
    for (i = 0; i < nameLen; i++)
      name[i] = 'a' + (ArMath::random() % ('z' - 'a'));
    name[nameLen] = '\0';
    
    myIdentifier = name;
  }
  */
  myDataMutex.unlock();

  return true;
}

AREXPORT void ArClientSwitchManager::logOptions(void) const
{
  ArLog::log(ArLog::Terse, "ArClientSwitchManager options:");
  ArLog::log(ArLog::Terse, "");
  ArLog::log(ArLog::Terse, "-centralServer <host>");
  ArLog::log(ArLog::Terse, "-cs <host>");
  ArLog::log(ArLog::Terse, "-centralServerPort <port>");
  ArLog::log(ArLog::Terse, "-csp <port>");
  ArLog::log(ArLog::Terse, "-identifier <identifier>");
  ArLog::log(ArLog::Terse, "-id <identifier>");
  /*
  ArLog::log(ArLog::Terse, "-centralServerUser <user>");
  ArLog::log(ArLog::Terse, "-csu <user>");
  ArLog::log(ArLog::Terse, "-centralServerPassword <password>");
  ArLog::log(ArLog::Terse, "-csp <password>");
  ArLog::log(ArLog::Terse, "-centralServerKey <serverKey>");
  ArLog::log(ArLog::Terse, "-csk <password>");
  */
  ArLog::log(ArLog::Terse, "-centralServerInfoFile <fileName>");
}

AREXPORT void ArClientSwitchManager::clientSwitch(ArNetPacket *packet)
{
  ArLog::log(ArLog::Normal, "Switch acknowledged, switching");
  
  ArClientBase *client;
  
  myDataMutex.lock();

  myClient->getTcpSocket()->setCloseCallback(&mySocketClosedCB);
  myServer->makeNewServerClientFromSocket(myClient->getTcpSocket(), true);
  client = myClient; 
  myClient = NULL;
  switchState(CONNECTED);
  myDataMutex.unlock();

  client->cancel();
  delete client;

  printf("Done switching\n");
  //myClient.disconnect();
}

AREXPORT void ArClientSwitchManager::socketClosed(void)
{
  myDataMutex.lock();
  if (myState == CONNECTED)
  {
    ArLog::log(ArLog::Normal, "ArClientSwitchManager: Lost connection to central server");
    switchState(LOST_CONNECTION);
  }
  myDataMutex.unlock();
}

AREXPORT void *ArClientSwitchManager::runThread(void *arg)
{
  threadStarted();
  
  while (getRunning())
  {
    myDataMutex.lock();
    if (myState == IDLE)
    {
    }
    else if (myState == TRYING_CONNECTION)
    {
      ArLog::log(ArLog::Normal, "Trying to connect to central server");
      myClient = new ArClientBase;
      myClient->setServerKey(myServerKey.c_str(), false);
      if (!myClient->blockingConnect(myCentralServer.c_str(), 
                                     myCentralServerPort, false,
                                     myUser.c_str(), myPassword.c_str()))
      {
        if (myClient->wasRejected())
          ArLog::log(ArLog::Normal, 
                     "Could not connect to %s because it rejected connection (bad user, password, or serverkey)",
                     myCentralServer.c_str());
        else
          ArLog::log(ArLog::Verbose, 
             "Could not connect to %s to switch with, not doing anything",
                     myCentralServer.c_str());
        delete myClient;
        myClient = NULL;
        switchState(LOST_CONNECTION);
        myDataMutex.unlock();
        continue;
      }
      
      if (!myClient->dataExists("switch"))
      {
        ArLog::log(ArLog::Normal, 
                   "ArClientSwitchManager: Connected to central server %s but it isn't a central server, going to idle");
        myClient->disconnect();
        delete myClient;
        myClient = NULL;
        switchState(IDLE);
        myDataMutex.unlock();
        continue;
      }
      
      ArNetPacket sendPacket;
      ArLog::log(ArLog::Normal, "PUtting in %s\n", myIdentifier.c_str());
      sendPacket.strToBuf(myIdentifier.c_str());
      
      ArLog::log(ArLog::Normal, "Requesting switch");
      myClient->addHandler("switch", &mySwitchCB);
      myClient->requestOnce("switch", &sendPacket);
      myClient->runAsync();
      switchState(CONNECTING);
    }
    else if (myState == CONNECTING)
    {
      if (!myGaveTimeWarning && myStartedState.secSince() > 10)
      {
        ArLog::log(ArLog::Normal, "ArClientSwitchManager: Connecting has taken over 10 seconds, probably a problem");
        myGaveTimeWarning = true;
        myDataMutex.unlock();
        continue;
      }
    }
    else if (myState == CONNECTED)
    {
    }
    else if (myState == LOST_CONNECTION)
    {
      if (myStartedState.secSince() > 10)
      {
        switchState(TRYING_CONNECTION);
      }
    }
    myDataMutex.unlock();
    ArUtil::sleep(100);
  }
  return NULL;
}

AREXPORT void ArClientSwitchManager::netCentralHeartbeat(
        ArServerClient *client, ArNetPacket *packet)
{
  ArNetPacket sending;
  client->sendPacketTcp(&sending);
  client->sendPacketUdp(&sending);
}

AREXPORT bool ArClientSwitchManager::parseFile(const char *fileName)
{
  ArLog::log(ArLog::Normal, "Loading central server user/password from %s", 
             fileName);
  if (!myFileParser.parseFile(fileName))
  {
    
    ArLog::log(ArLog::Normal, "Failed parsing central server user/password file %s", 
             fileName);
    return false;
  }
  return true;
}

bool ArClientSwitchManager::fileUserCallback(ArArgumentBuilder *arg)
{
  if (arg->getArgc() > 1)
  {
    ArLog::log(ArLog::Normal, "Bad user line: %s %s", 
               arg->getExtraString(), arg->getFullString());
    return false;
  }
  if (arg->getArgc() == 0)
    myUser = "";
  else
    myUser = arg->getArg(0);
  return true;
}


bool ArClientSwitchManager::filePasswordCallback(ArArgumentBuilder *arg)
{
  if (arg->getArgc() > 1)
  {
    ArLog::log(ArLog::Normal, "Bad password line: %s %s", 
               arg->getExtraString(), arg->getFullString());
    return false;
  }
  if (arg->getArgc() == 0)
    myPassword = "";
  else
    myPassword = arg->getArg(0);
  return true;
}

bool ArClientSwitchManager::fileServerKeyCallback(ArArgumentBuilder *arg)
{
  if (arg->getArgc() > 1)
  {
    ArLog::log(ArLog::Normal, "Bad serverKey line: %s %s", 
               arg->getExtraString(), arg->getFullString());
    return false;
  }
  if (arg->getArgc() == 0)
    myServerKey = "";
  else
    myServerKey = arg->getArg(0);
  return true;
}

AREXPORT const char *ArClientSwitchManager::getCentralServerHostName(void)
{
  if (myCentralServer.size() <= 0)
    return NULL;
  else
    return myCentralServer.c_str();
}

---