serverManage.cpp

/*
  サーバ処理
  Satofumi KAMIMURA
  $Id$
*/

#include "nettyping.h"
#include "packetTypes.h"
#include "serverManage.h"
#include "httpAccess.h"
#include "timeUtils.h"
#include <unistd.h>


ServerManage::ServerManage(const char* host, const char* page)
  : activated(false), meta_nortify(false),
    meta_host(host), meta_page(page), server_port(0) {
}


ServerManage::~ServerManage(void) {
}


std::string ServerManage::getOwnIP(void) {
  return (con) ? con->getOwnIP() : "";
}


bool ServerManage::activate(unsigned short port) {
  if (activated) {
    delete con;
    con = NULL;
  }

  try {
    con = new TcpipServer();
    con->activate(port);
    activated = true;

  } catch (ConnectionDevice_Exception& e) {
    activated = false;
  }
  return activated;
}


bool ServerManage::isActivated(void) {
  return activated;
}


// メタサーバに情報を通知
void ServerManage::nortifyToMetaServer(void) {
  if (meta_nortify) {
    HttpAccess request(meta_host.c_str(), 80);
    request.addItem("port", server_port);
    request.addItem("people", con_users.size());
    request.sendPostRequest(meta_page.c_str());
  }
}


void ServerManage::processFork(unsigned short port, bool nortify) {
  server_port = port;

  pid_t pid = fork();
  if (pid != 0) {
    return;
  }
  meta_nortify = nortify;

  // 起動ユーザとの接続
  TcpipDevice* new_user = con->accept(FirstTimeout);
  if (!new_user) {
    _exit(1);
  }
  con_users.push_back(new_user);
  nortifyToMetaServer();

  processServerTask();
}


std::string ServerManage::createPacket(unsigned char packet_type,
                                       const unsigned char* data) {

  // !!! 未実装

  return "";
}


void ServerManage::setOtherUser(int index, std::string packet) {

  // !!! 未実装

}


void ServerManage::handlePacket(int index, TcpipDevice* con) {
  // !!! チャット処理
  // !!! 対戦処理
}


void ServerManage::clearPacket(void) {
  user_packet.assign(con_users.size(), "");
}


void ServerManage::sendPacket(void) {
  int index = 0;
  for (std::vector<std::string>::iterator it = user_packet.begin();
       it != user_packet.end(); ++it, ++index) {
    if (!it->empty()) {
      con_users[index]->send(it->c_str(), it->size());
    }
  }
}


void ServerManage::processServerTask(void) {
  unsigned long nortify_sec = VXV::GetTicks() / 1000;
  while (con_users.size() > 0) {

    // 既存ユーザの管理
    clearPacket();
    int index = 0;
    for (std::vector<TcpipDevice*>::iterator it = con_users.begin();
         it != con_users.end(); ++it, ++index) {
      if ((*it)->size() > 0) {
        handlePacket(index, *it);
      }
      if (!(*it)->isConnected()) {
        setOtherUser(index, createPacket(RemoveUser, NULL));
      }
    }
    // パケットの送信
    sendPacket();

    // 無効なユーザの削除
    bool deleted = false;
    for (std::vector<TcpipDevice*>::iterator it = con_users.begin();
         it != con_users.end();) {
      if (!(*it)->isConnected()) {
        it = con_users.erase(it);
        deleted = true;
      } else {
        ++it;
      }
    }
    if (deleted) {
      nortifyToMetaServer();
    }

    // 新規ユーザの追加
    TcpipDevice* new_user = con->accept(100);
    if (new_user) {
      if (con_users.size() < HandleUsersMax) {
        con_users.push_back(new_user);
        nortifyToMetaServer();
      } else {
        delete new_user;
      }
    }

    // 一定時間毎にメタサーバに通知
    if (meta_nortify) {
      unsigned long now_sec = VXV::GetTicks() / 1000;
      if (now_sec > (nortify_sec + MetaServerUpdateInterval)) {
        nortifyToMetaServer();
        nortify_sec += MetaServerUpdateInterval;
      }
    }
  }
  _exit(0);
}