tmux-mem-cpu-load/tmux-mem-cpu-load.cpp

/* vim: tabstop=2 shiftwidth=2 expandtab textwidth=80 linebreak wrap
 *
 * Copyright 2012 Matthew McCormick
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include <cstring>
#include <iostream>
#include <fstream>
#include <sstream>
#include <string>
#include <cstdlib> // EXIT_SUCCESS

#include "argParse/argParse.h"
#include "version.h"
#include "graph.h"

// Tmux color lookup tables for the different metrics.
#include "luts.h"

#if defined(__APPLE__) && defined(__MACH__)
   // Apple osx system
   #include "osx/cpu.h"
   #include "osx/memory.h"
   #include "osx/load.h"
#elif defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__)
   // BSD system
   #define BSD_BASED 1
   #include "bsd/cpu.h"
   #include "bsd/load.h"
   #include "bsd/memory.h"
#else
   // assume linux system
   #include "linux/cpu.h"
   #include "linux/memory.h"
   #include "linux/load.h"
#endif

std::string cpu_string( unsigned int cpu_usage_delay, unsigned int graph_lines,
	bool use_colors = false )
{

  float percentage;

  //output stuff
  std::ostringstream oss;
  oss.precision( 1 );
  oss.setf( std::ios::fixed | std::ios::right );

  // get %
  percentage = cpu_percentage( cpu_usage_delay );

  if( use_colors )
  {
    oss << cpu_percentage_lut[static_cast<unsigned int>( percentage )];
  }

  if( graph_lines > 0)
  {
    oss << "[";
    oss << get_graph_by_percentage( unsigned( percentage ), graph_lines );
    oss << "]";
  }
  oss.width( 5 );
  oss << percentage;
  oss << "%";
  if( use_colors )
  {
    oss << "#[fg=default,bg=default]";
  }

  return oss.str();
}

int main( int argc, char** argv )
{
  using namespace ArgvParse;

  unsigned cpu_usage_delay = 990000;
  short graph_lines = 10; // max 32767 should be enough
  bool use_colors = false;

  // Argv parser
  ArgvParser arg;

  // ugly, I know
  std::string intro = "tmux-mem-cpu-load v";
  intro += tmux_mem_cpu_load_VERSION;
  intro += "\nUsage: tmux-mem-cpu-load [OPTIONS]";

  arg.setIntroduction( intro );

  arg.setHelpOption( "h", "help", "Prints this help message" );

  // define actual options
  arg.defineOption( "colors", "Use tmux colors in output",
      ArgvParser::NoAttribute );
  arg.defineOption( "i", "interval", "set tmux status refresh interval in "
      "seconds. Default: 1 second", ArgvParser::RequiresValue );
  arg.defineOption( "g", "graph-lines", "Set how many lines should be drawn in "
      "a graph. Default: 10", ArgvParser::RequiresValue );

  int result = arg.parse( argc, argv );

  if( result != ArgvParser::Success )
  {
    std::cerr << arg.parseErrorDescription( result );
    return EXIT_FAILURE;
  }

  // mangle arguments
  if( arg.foundOption( "colors" ) )
    use_colors = true;

  if( arg.foundOption( "interval" ) )
  {
    int delay = std::stoi( arg.optionValue( "interval" ) );
    if( delay < 1 )
    {
      std::cerr << "Status interval argument must be one or greater.\n";
      return EXIT_FAILURE;
    }
    cpu_usage_delay = delay * 1000000 - 10000;
  }

  if( arg.foundOption( "graph-lines" ) )
  {
    graph_lines = std::stoi( arg.optionValue( "graph-lines" ) );
    if( graph_lines < 0 )
    {
      std::cerr << "Graph lines argument must be zero or greater.\n";
      return EXIT_FAILURE;
    }
  }

  std::cout << mem_string( use_colors ) << ' ' 
    << cpu_string( cpu_usage_delay, graph_lines, use_colors ) << ' ' 
    << load_string( use_colors );

  return EXIT_SUCCESS;
}