Example #1
0
std::string CompileUserRanks(const std::string& section, Timeframe tf, Direction dir, 
                             SortField sf, int max, text::Template& templ, 
                             const std::function<bool(acl::User&)>& filter)
{
  auto users = ::db::stats::CalculateUserRanks(section, tf, dir, sf);
  
  std::ostringstream os;
  text::TemplateSection& head = templ.Head();
  head.RegisterValue("section", section.empty() ? "ALL" : section);
  os << head.Compile();
  
  text::TemplateSection& body = templ.Body();

  long long totalBytes = 0;
  long long totalFiles = 0;
  long long totalXfertime = 0;

  int index = 0;
  unsigned total = 0;
  for (const auto& u : users)
  {
    if (u.Files() <= 0) break;
    if (index < max)
    {
      auto user = acl::User::Load(u.ID());      
      if (!user || (filter && !filter(*user))) continue;
      
      body.RegisterValue("index", ++index);
      body.RegisterValue("user", user->Name());
      body.RegisterValue("group", user->PrimaryGroup());
      body.RegisterValue("tagline", user->Tagline());
      body.RegisterValue("files", u.Files());
      body.RegisterSize("size", u.KBytes());
      body.RegisterSpeed("speed", u.Speed());
      os << body.Compile();
    }
    
    totalBytes += u.KBytes();
    totalFiles += u.Files();
    totalXfertime += u.Xfertime();
    ++total;
  }
  
  text::TemplateSection& foot = templ.Foot();
  foot.RegisterValue("users", total);
  foot.RegisterSize("size", totalBytes);
  foot.RegisterValue("files" ,totalFiles);
  foot.RegisterSpeed("speed", totalXfertime == 0 ? totalBytes : totalBytes / (totalXfertime / 1000.0));
  os << foot.Compile();
  return os.str();
}
Example #2
0
std::string CompileGroupRanks(const std::string& section, Timeframe tf, Direction dir, 
                              SortField sf, int max, text::Template& templ)
{
  auto groups = ::db::stats::CalculateGroupRanks(section, tf, dir, sf);
  
  std::ostringstream os;
  text::TemplateSection& head = templ.Head();
  head.RegisterValue("section", section.empty() ? "ALL" : section);
  os << head.Compile();
  
  text::TemplateSection& body = templ.Body();

  long long totalKBytes = 0;
  long long totalFiles = 0;
  long long totalXfertime = 0;

  int index = 0;
  unsigned total = 0;
  for (const auto& g : groups)
  {
    if (g.Files() <= 0) break;
    if (index < max)
    {
      auto group = acl::Group::Load(g.ID());
      body.RegisterValue("index", ++index);
      body.RegisterValue("group", group ? group->Name() : "unknown");
      body.RegisterValue("descr", group ? group->Description() : "");
      body.RegisterValue("files", g.Files());
      body.RegisterSize("size", g.KBytes());
      body.RegisterSpeed("speed", g.Speed());
      
      os << body.Compile();
    }
    
    totalKBytes += g.KBytes();
    totalFiles += g.Files();
    totalXfertime += g.Xfertime();
    ++total;
  }
  
  text::TemplateSection& foot = templ.Foot();
  foot.RegisterValue("groups", total);
  foot.RegisterSize("size", totalKBytes);
  foot.RegisterValue("files" ,totalFiles);
  foot.RegisterSpeed("speed", totalXfertime == 0 ? totalKBytes : totalKBytes / (totalXfertime / 1000.0));
  os << foot.Compile();
  
  return os.str();
}
Example #3
0
std::string NukeTemplateCompile(const db::nuking::Nuke& nuke, text::Template& templ, const fs::VirtualPath& path)
{
  std::ostringstream os;
  RegisterHeadFoot(templ.Head(), nuke, path);

  os << templ.Head().Compile();
  
  unsigned index = 0;
  long long totalKBytes = 0;
  long long totalCredits = 0;
  int totalFiles = 0;
  auto& body = templ.Body();

  for (const auto& nukee : nuke.Nukees())
  {
    body.RegisterValue("index", ++index);
    body.RegisterValue("username", acl::UIDToName(nukee.UID()));
    body.RegisterSize("size", nukee.KBytes());
    body.RegisterSize("credits", nukee.Credits());
    body.RegisterValue("files", nukee.Files());
    os << body.Compile();
    
    totalKBytes += nukee.KBytes();
    totalCredits += nukee.Credits();
    totalFiles += nukee.Files();
  }

  auto& foot = templ.Foot();
  RegisterHeadFoot(foot, nuke, path);
  foot.RegisterValue("total_nukees", nuke.Nukees().size());
  foot.RegisterSize("total_size", totalKBytes);
  foot.RegisterSize("total_credits", totalCredits);
  foot.RegisterValue("total_files", totalFiles);
  os << foot.Compile();
  return os.str();
}
Example #4
0
std::string CompileWhosOnline(const std::string& id, text::Template& templ)
{
  std::vector<ftp::OnlineClient> clients;
  
  {
    ftp::OnlineReader reader(id);  
    
    {
      ftp::OnlineReaderLock lock(reader);
      std::copy(reader.begin(), reader.end(), std::back_inserter(clients));
    }
  }
  
  std::ostringstream multiStr;
  for (const auto& client : clients)
    multiStr << "-" << acl::UIDToName(client.uid) << " ";
    
  auto users = acl::User::GetUsers(multiStr.str());

  std::ostringstream os;
  auto& head = templ.Head();
  os << head.Compile();
  
  auto& body = templ.Body();
  
  int count = 0;
  int idlers = 0;
  int active = 0;
  int uploaders = 0;
  int downloaders = 0;
  double upFastest = 0;
  double downFastest = 0;
  double upSlowest = -1;
  double downSlowest = -1;
  double upTotalSpeed = 0;
  double downTotalSpeed = 0;
  
  for (const auto& client : clients)
  {
    auto it = std::find_if(users.begin(), users.end(), 
                    [&](const acl::User& user)
                    {
                      return user.ID() == client.uid;
                    });
    if (it == users.end()) continue;
    
    body.RegisterValue("count", ++count);
    body.RegisterValue("user", it->Name());
    body.RegisterValue("group", it->PrimaryGroup());
    body.RegisterValue("tagline", it->Tagline());
    
    body.RegisterValue("ident", client.ident);
    body.RegisterValue("ip", client.ip);
    body.RegisterValue("hostname", client.hostname);
    body.RegisterValue("work_dir", client.workDir);
    body.RegisterValue("ident_address", client.ident + std::string("@") + client.hostname);
    
    // below needs santising for hideinwho config option
    
    std::ostringstream action;
    if (client.xfer) // transfering
    {
      double speed = stats::CalculateSpeed(client.xfer->bytes, client.xfer->start, 
                        boost::posix_time::microsec_clock::local_time()) / 1024;
      
      if (client.xfer->direction == stats::Direction::Upload)
      {
        ++uploaders;
        upTotalSpeed += speed;
        if (upSlowest == -1) upSlowest = speed;
        else upSlowest = std::min(upSlowest, speed);
        upFastest = std::max(upFastest, speed);
        action << "UP @ ";
      }
      else
      {
        ++downloaders;
        downTotalSpeed += speed;
        if (downSlowest == -1) downSlowest = speed;
        else downSlowest = std::max(downSlowest, speed);
        downFastest = std::max(downFastest, speed);
        action << "DN @ ";
      }
      
      action << stats::AutoUnitSpeedString(speed);
    }
    else // not transfering
    {
      if (client.IsIdle()) // idle
      {
        ++idlers;
        action << "IDLE " << (boost::posix_time::second_clock::local_time() - client.lastCommand);
      }
      else // executing command
      {
        ++active;
        action << client.command;
      }
    }
    
    body.RegisterValue("action", action.str());
    os << body.Compile();
  }
  
  if (upSlowest == -1) upSlowest = 0;
  if (downSlowest == -1) downSlowest = 0;
  
  auto& foot = templ.Foot();
  foot.RegisterValue("online_users", count);
  foot.RegisterValue("all_online_users", count);
  foot.RegisterValue("idlers", idlers);
  foot.RegisterValue("active", active);
  foot.RegisterValue("uploaders", uploaders);
  foot.RegisterValue("downloaders", downloaders);
  foot.RegisterValue("up_fastest_speed", upFastest);
  foot.RegisterValue("up_slowest_speed", upSlowest);
  foot.RegisterValue("down_fastest_speed", downFastest);
  foot.RegisterValue("down_slowest_speed", downSlowest);
  foot.RegisterValue("up_total_speed", upTotalSpeed);
  foot.RegisterValue("up_avg_speed", uploaders == 0 ? 0 : upTotalSpeed / uploaders);
  foot.RegisterValue("down_total_speed", downTotalSpeed);
  foot.RegisterValue("down_avg_speed", downloaders == 0 ? 0 : downTotalSpeed / downloaders);
  foot.RegisterValue("max_online_users", cfg::Config::MaxOnline().Users());
  os << foot.Compile();
  return os.str();
}