path: root/src/Client/SystemCommands.cpp

/*
 * SystemCommands.cpp
 *
 * Copyright (C) 2009 Matthias Schiffer <matthias@gamezock.de>
 *
 * 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 3 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, see <http://www.gnu.org/licenses/>.
 */

#include "SystemCommands.h"
#include "Application.h"
#include "CommandParser.h"

#include <Common/RequestManager.h>

#include "Requests/DaemonFSInfoRequest.h"
#include "Requests/DaemonCommandRequest.h"
#include "Requests/DaemonStatusRequest.h"
#include <Common/Requests/FSInfoRequest.h>
#include <Common/Requests/StatusRequest.h>

#include <iostream>


namespace Mad {
namespace Client {

void SystemCommands::printFSInfo(boost::shared_ptr<const Common::XmlPacket> &packet) {
  const std::string units[] = {
      "kB", "MB", "GB", "TB", ""
  };

  const Common::XmlPacket::List *list = packet->getList("filesystems");

  if(list) {
    for(Common::XmlPacket::List::const_iterator fs = list->begin(); fs != list->end(); ++fs) {
      unsigned usedUnit = 0, totalUnit = 0;

      float used = fs->get<float>("usedSize");
      float total = fs->get<float>("totalSize");
      float available = fs->get<float>("availableSize");

      while(used >= 1024 && !units[usedUnit+1].empty()) {
        ++usedUnit;
        used /= 1024;
        available /= 1024;
      }

      while(total >= 1024 && !units[totalUnit+1].empty()) {
        ++totalUnit;
        total /= 1024;
      }


      std::string name = fs->get<const std::string&>("name");
      std::string mountedOn = fs->get<const std::string&>("mountedOn");

      std::string nameString = mountedOn + " (" + name + ")";

      if(nameString.length() < 32) {
        nameString.resize(32, ' ');
      }
      else {
        nameString += "\n\t";
        nameString.resize(nameString.length() + 32, ' ');
      }

      std::printf("\t%s%.*f%s", nameString.c_str(), (used < 10) ? 2 : 1, used, (usedUnit == totalUnit) ? "" : (" " + units[usedUnit]).c_str());
      std::printf("/%.*f %s (%.1f%%)\n", (total < 10) ? 2 : 1, total, units[totalUnit].c_str(), std::min(100*used/(used+available), 100.0f));
    }
  }

  std::printf("\n");
}

void SystemCommands::printHostStatus(boost::shared_ptr<const Common::XmlPacket> &packet) {
  unsigned long uptime = packet->get<unsigned long>("uptime");

  if(uptime) {
    unsigned long days = uptime/86400;
    unsigned long hours = (uptime%86400)/3600;
    unsigned long minutes = (uptime%3600)/60;

    std::printf("\tUptime:\t\t");

    if(days) std::printf("%lu days ", days);

    std::printf("%lu:%02lu", hours, minutes);

    std::printf(" (load average: %.2f %.2f %.2f, %lu processes)",
        packet->get<float>("loadAvg1"), packet->get<float>("loadAvg5"),
        packet->get<float>("loadAvg15"), packet->get<unsigned long>("nProcesses"));

    std::printf("\n\n");
  }

  float totalMem = packet->get<unsigned long>("totalMem");
  float freeMem = packet->get<unsigned long>("freeMem");

  if(totalMem && freeMem) {
    const std::string units[] = {
        "kB", "MB", "GB", "TB", ""
    };

    unsigned unit = 0;
    float usedMem = totalMem-freeMem;

    while(totalMem >= 1024 && !units[unit+1].empty()) {
      ++unit;
      totalMem /= 1024;
      usedMem /= 1024;
    }

    std::printf("\tMemory usage:\t%.*f/%.*f %s", (usedMem < 10) ? 2 : 1, usedMem, (totalMem < 10) ? 2 : 1, totalMem, units[unit].c_str());
    std::printf(" (%.1f%%)\n", usedMem*100.0f/totalMem);

    totalMem = packet->get<unsigned long>("totalSwap");
    freeMem = packet->get<unsigned long>("freeSwap");

    if(totalMem && freeMem) {
      unit = 0;
      usedMem = totalMem-freeMem;

      while(totalMem >= 1024 && !units[unit+1].empty()) {
        ++unit;
        totalMem /= 1024;
        usedMem /= 1024;
      }

      std::printf("\tSwap usage:\t%.*f/%.*f %s", (usedMem < 10) ? 2 : 1, usedMem, (totalMem < 10) ? 2 : 1, totalMem, units[unit].c_str());
      std::printf(" (%.1f%%)\n", usedMem*100.0f/totalMem);
    }

    std::printf("\n");
  }
}


void SystemCommands::fsinfoCommand(CommandParser *commandParser, const std::vector<std::string> &args) {
  boost::shared_ptr<Common::Request> request;

  if(args.size() == 1)
    request = boost::shared_ptr<Common::Requests::FSInfoRequest>(new Common::Requests::FSInfoRequest(commandParser->application));
  else if(args.size() == 2)
    request = boost::shared_ptr<Requests::DaemonFSInfoRequest>(new Requests::DaemonFSInfoRequest(commandParser->application, args[1]));
  else {
    std::cerr << args[0] << ": Too many arguments." << std::endl;
    commandParser->printUsage("fsinfo");
    return;
  }

  commandParser->application->getRequestManager()->sendRequest(commandParser->connection, request);
  request->wait();

  std::pair<boost::shared_ptr<const Common::XmlPacket>, Core::Exception> result = request->getResult();

  if(!result.first || result.second) {
    std::cerr << "An error occurred during your request: " << result.second.strerror() << "." << std::endl;
  }
  else {
    if(args.size() == 1)
      std::cout << "Server file system usage:" << std::endl;
    else
      std::cout << "Host file system usage:" << std::endl;

    printFSInfo(result.first);
  }
}

void SystemCommands::rebootCommand(CommandParser *commandParser, const std::vector<std::string> &args) {
  if(args.size() < 2) {
    std::cerr << args[0] << ": No host given." << std::endl;
    commandParser->printUsage("reboot");
    return;
  }

  std::map<std::string, Common::HostInfo> hosts = commandParser->parseHostList(std::vector<std::string>(args.begin()+1, args.end()), true);

  std::vector<boost::shared_ptr<Requests::DaemonCommandRequest> > requests;

  for(std::map<std::string, Common::HostInfo>::iterator host = hosts.begin(); host != hosts.end(); ++host) {
    boost::shared_ptr<Requests::DaemonCommandRequest> request(new Requests::DaemonCommandRequest(commandParser->application, host->first, true));
    commandParser->application->getRequestManager()->sendRequest(commandParser->connection, request);

    requests.push_back(request);
  }

  for(std::vector<boost::shared_ptr<Requests::DaemonCommandRequest> >::iterator request = requests.begin(); request != requests.end(); ++request)
    (*request)->wait();

  for(std::vector<boost::shared_ptr<Requests::DaemonCommandRequest> >::iterator request = requests.begin(); request != requests.end(); ++request) {
    std::pair<boost::shared_ptr<const Common::XmlPacket>, Core::Exception> result = (*request)->getResult();

    if(result.second)
      std::cerr << "An error occurred during your request: " << result.second.strerror() << "." << std::endl;
  }
}

void SystemCommands::shutdownCommand(CommandParser *commandParser, const std::vector<std::string> &args) {
  if(args.size() < 2) {
    std::cerr << args[0] << ": No host given." << std::endl;
    commandParser->printUsage("shutdown");
    return;
  }

  std::map<std::string, Common::HostInfo> hosts = commandParser->parseHostList(std::vector<std::string>(args.begin()+1, args.end()), true);

  std::vector<boost::shared_ptr<Requests::DaemonCommandRequest> > requests;

  for(std::map<std::string, Common::HostInfo>::iterator host = hosts.begin(); host != hosts.end(); ++host) {
    boost::shared_ptr<Requests::DaemonCommandRequest> request(new Requests::DaemonCommandRequest(commandParser->application, host->first, false));
    commandParser->application->getRequestManager()->sendRequest(commandParser->connection, request);

    requests.push_back(request);
  }

  for(std::vector<boost::shared_ptr<Requests::DaemonCommandRequest> >::iterator request = requests.begin(); request != requests.end(); ++request)
    (*request)->wait();

  for(std::vector<boost::shared_ptr<Requests::DaemonCommandRequest> >::iterator request = requests.begin(); request != requests.end(); ++request) {
    std::pair<boost::shared_ptr<const Common::XmlPacket>, Core::Exception> result = (*request)->getResult();

    if(result.second)
      std::cerr << "An error occurred during your request: " << result.second.strerror() << "." << std::endl;
  }
}

void SystemCommands::statusCommand(CommandParser *commandParser, const std::vector<std::string> &args) {
  boost::shared_ptr<Common::Request> request;

  if(args.size() == 1)
    request = boost::shared_ptr<Common::Requests::StatusRequest>(new Common::Requests::StatusRequest(commandParser->application));
  else if(args.size() == 2)
    request = boost::shared_ptr<Requests::DaemonStatusRequest>(new Requests::DaemonStatusRequest(commandParser->application, args[1]));
  else {
    std::cerr << args[0] << ": Too many arguments." << std::endl;
    commandParser->printUsage("status");
    return;
  }

  commandParser->application->getRequestManager()->sendRequest(commandParser->connection, request);
  request->wait();

  std::pair<boost::shared_ptr<const Common::XmlPacket>, Core::Exception> result = request->getResult();

  if(!result.first || result.second) {
    std::cerr << "An error occurred during your request: " << result.second.strerror() << "." << std::endl;
  }
  else {
    if(args.size() == 1)
      std::cout << "Server status:" << std::endl;
    else
      std::cout << "Host status:" << std::endl;

    printHostStatus(result.first);
  }
}

}
}