def __init__(self, pcp_fname, start=None, finish=None, interval=None): '''Opens a PCP archive and does an initial walk of the PMNS tree. start and finish must be in datetime format. Interval must be in seconds''' self.pcparchive = pcp_fname try: self.ctx = pmapi.pmContext(c_api.PM_CONTEXT_ARCHIVE, pcp_fname) except pmapi.pmErr as e: print("Error: {0}".format(e)) sys.exit(-1) self.ctx.pmTraversePMNS('', self._pmns_callback) label = self.ctx.pmGetArchiveLabel() self.start = None self.finish = None self.interval = None if start: self.start = pmapi.timeval(sec=start) else: self.start = label.start if finish: self.finish = pmapi.timeval(sec=start) else: self.finish = self.ctx.pmGetArchiveEnd() if interval: self.interval = pmapi.timeval(sec=interval)
def get_stats(self, pcp): if len(self.metrics) <= 0: raise pmapi.pmErr list_type = type([]) if self._timestamp.tv_sec == 0: first = True else: first = False try: metric_result = pcp.pmFetch(self.metric_pmids) self._timestamp = copy.deepcopy(metric_result.contents.timestamp) except pmapi.pmErr as e: self._timestamp = pmapi.timeval(0, 0) raise e # list of metric names for i in range(len(self.metrics)): # list of metric results, one per metric name for j in range(metric_result.contents.numpmid): if (metric_result.contents.get_pmid(j) != self.metric_pmids[i]): continue atomlist = [] # list of instances, one or more per metric. e.g. there are many # instances for network metrics, one per network interface for k in range(metric_result.contents.get_numval(j)): atom = pcp.pmExtractValue(metric_result.contents.get_valfmt(j), metric_result.contents.get_vlist(j, k), self.metric_descs[j].type, self.metric_descs[j].type) atomlist.append(atom) value = [] # metric may require a diff to get a per interval value for k in range(metric_result.contents.get_numval(j)): if type(self._last_values[j]) == list_type: try: lastval = self._last_values[j][k] except IndexError: lastval = None else: lastval = self._last_values[j] if first: want_diff = False elif self.metrics[j] in self.diff_metrics: want_diff = True elif (self.metric_descs[j].sem == c_api.PM_SEM_DISCRETE or self.metric_descs[j].sem == c_api.PM_SEM_INSTANT) : want_diff = False else: want_diff = True value.append(self.get_atom_value(atomlist[k], lastval, self.metric_descs[j], want_diff)) self._last_values[j] = copy.copy(atomlist) if metric_result.contents.get_numval(j) == 1: if len(value) == 1: self.metric_values[j] = copy.copy(value[0]) else: self.metric_values[j] = 0 elif metric_result.contents.get_numval(j) > 1: self.metric_values[j] = copy.copy(value) pcp.pmFreeResult(metric_result)
def get_stats(self, pcp): if len(self.metrics) <= 0: raise pmErr list_type = type([]) if self._timestamp.tv_sec == 0: first = True else: first = False try: metric_result = pcp.pmFetch(self.metric_pmids) self._timestamp = copy.deepcopy(metric_result.contents.timestamp) except pmErr as e: self._timestamp = timeval(0, 0) raise e # list of metric names for i in range(len(self.metrics)): # list of metric results, one per metric name for j in range(metric_result.contents.numpmid): if (metric_result.contents.get_pmid(j) != self.metric_pmids[i]): continue atomlist = [] # list of instances, one or more per metric. e.g. there are many # instances for network metrics, one per network interface for k in range(metric_result.contents.get_numval(j)): atom = pcp.pmExtractValue(metric_result.contents.get_valfmt(j), metric_result.contents.get_vlist(j, k), self.metric_descs[j].type, self.metric_descs[j].type) atomlist.append(atom) value = [] # metric may require a diff to get a per interval value for k in range(metric_result.contents.get_numval(j)): if type(self._last_values[j]) == list_type: try: lastval = self._last_values[j][k] except IndexError: lastval = None else: lastval = self._last_values[j] if first: want_diff = False elif self.metrics[j] in self.diff_metrics: want_diff = True elif (self.metric_descs[j].sem == c_api.PM_SEM_DISCRETE or self.metric_descs[j].sem == c_api.PM_SEM_INSTANT) : want_diff = False else: want_diff = True value.append(self.get_atom_value(atomlist[k], lastval, self.metric_descs[j], want_diff)) self._last_values[j] = copy.copy(atomlist) if metric_result.contents.get_numval(j) == 1: if len(value) == 1: self.metric_values[j] = copy.copy(value[0]) else: self.metric_values[j] = 0 elif metric_result.contents.get_numval(j) > 1: self.metric_values[j] = copy.copy(value) pcp.pmFreeResult(metric_result)
def finalize_options(self): """ Finalize util options """ # Runtime overrides samples/interval if self.util.opts.pmGetOptionFinishOptarg(): origin = float(self.util.opts.pmGetOptionOrigin( )) if self.util.opts.pmGetOptionOrigin() is not None else 0 self.util.runtime = float( self.util.opts.pmGetOptionFinish()) - origin if self.util.opts.pmGetOptionSamples(): self.util.samples = self.util.opts.pmGetOptionSamples() if self.util.samples < 2: self.util.samples = 2 self.util.interval = float( self.util.runtime) / (self.util.samples - 1) self.util.opts.pmSetOptionInterval(str(self.util.interval)) self.util.interval = self.util.opts.pmGetOptionInterval() else: self.util.interval = self.util.opts.pmGetOptionInterval() if not self.util.interval: self.util.interval = pmapi.timeval(0) try: self.util.samples = int(self.util.runtime / float(self.util.interval) + 1) except Exception: pass else: self.util.samples = self.util.opts.pmGetOptionSamples() self.util.interval = self.util.opts.pmGetOptionInterval() if float(self.util.interval) <= 0: sys.stderr.write("Interval must be greater than zero.\n") sys.exit(1)
def __init__(self): """ Construct object, prepare for command line handling """ self.context = None self.daemonize = 0 self.pmconfig = pmconfig.pmConfig(self) self.opts = self.options() # Configuration directives self.keys = ('source', 'output', 'derived', 'header', 'globals', 'samples', 'interval', 'type', 'precision', 'daemonize', 'es_server', 'es_index', 'es_hostid', 'count_scale', 'space_scale', 'time_scale', 'version', 'speclocal', 'instances', 'ignore_incompat', 'omit_flat') # The order of preference for options (as present): # 1 - command line options # 2 - options from configuration file(s) # 3 - built-in defaults defined below self.check = 0 self.version = CONFVER self.source = "local:" self.output = None # For pmrep conf file compat only self.speclocal = None self.derived = None self.header = 1 self.globals = 1 self.samples = None # forever self.interval = pmapi.timeval(60) # 60 sec self.opts.pmSetOptionInterval(str(60)) # 60 sec self.delay = 0 self.type = 0 self.ignore_incompat = 0 self.instances = [] self.omit_flat = 0 self.precision = 3 # .3f self.timefmt = "%H:%M:%S" # For compat only self.interpol = 0 self.count_scale = None self.space_scale = None self.time_scale = None self.es_server = ES_SERVER self.es_index = ES_INDEX self.es_hostid = None # Internal self.runtime = -1 # Performance metrics store # key - metric name # values - 0:label, 1:instance(s), 2:unit/scale, 3:type, 4:width, 5:pmfg item self.metrics = OrderedDict() self.pmfg = None self.pmfg_ts = None # Read configuration and prepare to connect self.config = self.pmconfig.set_config_file(DEFAULT_CONFIG) self.pmconfig.read_options() self.pmconfig.read_cmd_line() self.pmconfig.prepare_metrics()
def __init__(self, typed = PM_CONTEXT_HOST, target = "local:"): dict.__init__(self) MetricCache.__init__(self, typed, target) self._options = None self._default_delta = timeval(1, 0) self._default_pause = None self._printer = None self._counter = 0
def __init__(self, typed=PM_CONTEXT_HOST, target="local:"): dict.__init__(self) MetricCache.__init__(self, typed, target) self._options = None self._default_delta = timeval(1, 0) self._default_pause = None self._printer = None self._counter = 0
def __init__(self): self.metrics = [] self._timestamp = timeval(0, 0) self.diff_metrics = [] self.metric_pmids = [] self.metric_descs = [] self.metric_values = [] self.metrics_dict = {} self._last_values = []
def __init__(self): """ Construct object - prepare for command line handling """ self.count = 0 # number of samples to report self.pause = None # time interval to pause between samples self.shift = 10 # bitshift conversion between B/KB/MB/GB self.show_high = 0 self.show_total = 0 self.show_compat = 0 self.opts = self.options() self.interval = pmapi.timeval() self.context = None
def _computePauseTime(self): """ Figure out how long to sleep between samples. This needs to take into account whether we were explicitly asked for a delay (independent of context type, --pause), whether this is an archive or live context, and the sampling --interval (including the default value, if none requested). """ if self._default_pause != None: return self._default_pause if self.type == PM_CONTEXT_ARCHIVE: self._default_pause = timeval(0, 0) elif self._options != None: pause = self._options.pmGetOptionInterval() if pause != None: self._default_pause = pause else: self._default_pause = self._default_delta else: self._default_pause = self._default_delta return self._default_pause
def prepare_output(self, operands): """ Complete all initialisation and get ready to begin sampling """ if not operands: operands = [] if len(operands) > 0: self.delay = float(operands[0]) if len(operands) > 1: self.samples = int(operands[1]) if len(operands) > 2: sys.stderr.write("Incorrect argument list, try --help\n") sys.exit(1) if not self.update: self.interval = pmapi.timeval(self.delay) self.pmconfig.set_signal_handler() self.term.set_title(self.arguments) self.term.set_theme(self.blackonwhite) if self.color == None: self.color = self.term.get_color() ### Empty ansi and theme databases when colors not in use if not self.color: for key in COLOR: COLOR[key] = '' for key in THEME: THEME[key] = '' for key in ANSI: ANSI[key] = '' THEME['colors_hi'] = (ANSI['default'],) THEME['colors_lo'] = (ANSI['default'],) ### Disable line-wrapping sys.stdout.write(ANSI['nolinewrap']) ### Create pidfile if self.pidfile: self.create_pidfile()
def builder(build, options, argv): """ Helper interface, simple PCP monitor argument parsing. """ manager = build.fromOptions(options, argv) manager._default_delta = timeval(options.delta, 0) manager._options = options return manager
def __init__(self): """ Construct object, parse command line """ self.context = None self.database = 'pcp' self.influxdb_tags = '' self.influxdb_address = 'http://127.0.0.1:8086' self.influxdb_user = None self.influxdb_pass = None self.sample_count = 0 self.unitsstr = None self.units = None self.units_mult = None # option setup self.opts = pmapi.pmOptions() self.opts.pmSetShortOptions("a:O:s:T:g:p:P:r:m:t:u:h:t:D:LV?") self.opts.pmSetShortUsage("[options] metricname ...") self.opts.pmSetLongOptionText(""" Description: Periodically, relay raw values of all instances of a given hierarchies of PCP metrics to an InfluxDB server on the network.""") self.opts.pmSetLongOptionHeader("Options") self.opts.pmSetOptionCallback(self.option) # common options self.opts.pmSetLongOptionVersion() self.opts.pmSetLongOptionArchive() self.opts.pmSetLongOptionOrigin() self.opts.pmSetLongOptionSamples() self.opts.pmSetLongOptionFinish() self.opts.pmSetLongOptionDebug() self.opts.pmSetLongOptionHost() self.opts.pmSetLongOptionLocalPMDA() self.opts.pmSetLongOptionInterval() # custom options self.opts.pmSetLongOption( "influxdb-address", 1, 'i', '', "InfluxDB HTTP/HTTPS address " + "(default \"" + self.influxdb_address + "\")") self.opts.pmSetLongOption( "units", 1, 'u', '', "rescale units " + "(e.g. \"MB\", will omit incompatible units)") self.opts.pmSetLongOption("database", 1, 'd', '', "database for metric (default \"pcp\")") self.opts.pmSetLongOption("db-user", 1, 'U', '', "username for InfluxDB database") self.opts.pmSetLongOption("db-password", 1, 'P', '', "password for InfluxDB database") self.opts.pmSetLongOption("tag-string", 1, 'I', '', "string of tags to add to the metrics") self.opts.pmSetLongOptionHelp() # parse options self.context = pmapi.pmContext.fromOptions(self.opts, sys.argv) self.interval = self.opts.pmGetOptionInterval() or pmapi.timeval(60, 0) if self.unitsstr is not None: units = self.context.pmParseUnitsStr(self.unitsstr) (self.units, self.units_mult) = units self.metrics = [] self.pmids = [] self.descs = [] metrics = self.opts.pmGetNonOptionsFromList(sys.argv) if metrics: for m in metrics: try: self.context.pmTraversePMNS(m, self.handle_candidate_metric) except pmapi.pmErr as error: sys.stderr.write("Excluding metric %s (%s)\n" % (m, str(error))) sys.stderr.flush() if len(self.metrics) == 0: sys.stderr.write("No acceptable metrics specified.\n") raise pmapi.pmUsageErr() # Report what we're about to do print("Relaying %d %smetric(s) to database %s with tags %s from %s " "to %s every %f s" % (len(self.metrics), "rescaled " if self.units else "", self.database, self.influxdb_tags, self.describe_source(), self.influxdb_address, self.interval)) sys.stdout.flush()
def __init__(self): """ Construct object, parse command line """ self.context = None self.opts = pmapi.pmOptions() self.opts.pmSetShortOptions("g:p:P:u:m:t:h:Lt:D:V?") # must include common options self.opts.pmSetShortUsage("[options] metricname ...") self.opts.pmSetOptionCallback(self.option) self.opts.pmSetOverrideCallback(self.option_override) # hack to include some explanatory text self.opts.pmSetLongOptionHeader(""" Description: Periodically, relay raw values of all instances of a given hierarchies of PCP metrics to a graphite/carbon server on the network. Options""") self.opts.pmSetLongOptionVersion() # -V # self.opts.pmSetLongOptionArchive() # -a FILE -- not supported yet; need -S/etc. controls self.opts.pmSetLongOptionDebug() # -D stuff self.opts.pmSetLongOptionHost() # -h HOST # self.opts.pmSetLongOptionLocalPMDA() # -L self.opts.pmSetLongOptionInterval() # -t NUMBER self.opts.pmSetLongOption("graphite-host", 1, 'g', '', "graphite server host (default \"localhost\")") self.opts.pmSetLongOption("pickled-port", 1, 'p', '', "graphite pickled port (default 2004)") self.opts.pmSetLongOption("text-port", 1, 'P', '', "graphite plaintext port (usually 2003)") self.opts.pmSetLongOption("units", 1, 'u', '', "rescale all metric units (e.g., \"mbytes/5 sec\")") self.opts.pmSetLongOption("prefix", 1, 'm', '', "prefix for metric names (default \"pcp.\")") self.opts.pmSetLongOptionHelp() self.graphite_host = "localhost" self.graphite_port = 2004 self.pickle = True self.prefix = "pcp." self.unitsstr = None self.units = None # pass verbatim by default self.units_mult = None # pass verbatim by default # now actually parse self.context = pmapi.pmContext.fromOptions(self.opts, sys.argv) self.interval = self.opts.pmGetOptionInterval() or pmapi.timeval(60,0) if self.unitsstr is not None: (self.units, self.units_mult) = self.context.pmParseUnitsStr(self.unitsstr) self.metrics = [] self.pmids = [] self.descs = [] metrics = self.opts.pmNonOptionsFromList(sys.argv) if metrics: for m in metrics: try: self.context.pmTraversePMNS(m, self.handle_candidate_metric) except pmapi.pmErr as error: sys.stderr.write("Excluding metric %s (%s)\n" % (m, str(error))) sys.stderr.flush() if len(self.metrics) == 0: sys.stderr.write("No acceptable metrics specified.\n") raise pmapi.pmUsageErr() # Report what we're about to do print("Relaying %d %smetric(s) with prefix %s " "in %s mode to %s:%d every %f s" % ( len(self.metrics), "rescaled " if self.units else "", self.prefix, "pickled" if self.pickle else "text", self.graphite_host, self.graphite_port, self.interval)) sys.stdout.flush()
def __init__(self): """ Construct object, prepare for command line handling """ self.context = None self.daemonize = 0 self.pmconfig = pmconfig.pmConfig(self) self.opts = self.options() # Configuration directives self.keys = ('source', 'output', 'derived', 'header', 'globals', 'samples', 'interval', 'type', 'precision', 'daemonize', 'graphite_host', 'graphite_port', 'pickle', 'pickle_protocol', 'prefix', 'count_scale', 'space_scale', 'time_scale', 'version', 'count_scale_force', 'space_scale_force', 'time_scale_force', 'type_prefer', 'precision_force', 'limit_filter', 'limit_filter_force', 'live_filter', 'rank', 'invert_filter', 'predicate', 'names_change', 'speclocal', 'instances', 'ignore_incompat', 'ignore_unknown', 'omit_flat') # The order of preference for options (as present): # 1 - command line options # 2 - options from configuration file(s) # 3 - built-in defaults defined below self.check = 0 self.version = CONFVER self.source = "local:" self.output = None # For pmrep conf file compat only self.speclocal = None self.derived = None self.header = 1 self.globals = 1 self.samples = None # forever self.interval = pmapi.timeval(60) # 60 sec self.opts.pmSetOptionInterval(str(60)) # 60 sec self.delay = 0 self.type = 0 self.type_prefer = self.type self.ignore_incompat = 0 self.ignore_unknown = 0 self.names_change = 0 # ignore self.instances = [] self.live_filter = 0 self.rank = 0 self.limit_filter = 0 self.limit_filter_force = 0 self.invert_filter = 0 self.predicate = None self.omit_flat = 0 self.precision = 3 # .3f self.precision_force = None self.timefmt = "%c" self.interpol = 0 self.count_scale = None self.count_scale_force = None self.space_scale = None self.space_scale_force = None self.time_scale = None self.time_scale_force = None self.graphite_host = SERVER self.graphite_port = PORT self.pickle = 1 self.pickle_protocol = 0 self.prefix = PREFIX # Internal self.runtime = -1 self.socket = None # Performance metrics store # key - metric name # values - 0:txt label, 1:instance(s), 2:unit/scale, 3:type, # 4:width, 5:pmfg item, 6:precision, 7:limit self.metrics = OrderedDict() self.pmfg = None self.pmfg_ts = None # Read configuration and prepare to connect self.config = self.pmconfig.set_config_file(DEFAULT_CONFIG) self.pmconfig.read_options() self.pmconfig.read_cmd_line() self.pmconfig.prepare_metrics() self.pmconfig.set_signal_handler()
def __init__(self): """ Construct object, parse command line """ self.context = None self.socket = None self.sample_count = 0 self.opts = pmapi.pmOptions() self.opts.pmSetShortOptions("a:O:s:T:g:p:P:r:u:m:t:h:t:D:LV?") self.opts.pmSetShortUsage("[options] metricname ...") self.opts.pmSetOptionCallback(self.option) self.opts.pmSetOverrideCallback(self.option_override) self.opts.pmSetLongOptionText(""" Description: Periodically, relay raw values of all instances of a given hierarchies of PCP metrics to a graphite/carbon server on the network.""") self.opts.pmSetLongOptionHeader("Options") self.opts.pmSetLongOptionVersion() # -V self.opts.pmSetLongOptionArchive() # -a FILE self.opts.pmSetLongOptionOrigin() # -O TIME self.opts.pmSetLongOptionSamples() # -s NUMBER self.opts.pmSetLongOptionFinish() # -T NUMBER self.opts.pmSetLongOptionDebug() # -D stuff self.opts.pmSetLongOptionHost() # -h HOST self.opts.pmSetLongOptionLocalPMDA() # -L self.opts.pmSetLongOptionInterval() # -t NUMBER self.opts.pmSetLongOption("graphite-host", 1, 'g', '', "graphite server host " + "(default \"localhost\")") self.opts.pmSetLongOption("pickled-port", 1, 'p', '', "graphite pickled port (default 2004)") self.opts.pmSetLongOption("text-port", 1, 'P', '', "graphite plaintext port (usually 2003)") self.opts.pmSetLongOption("units", 1, 'u', '', "rescale units " + "(e.g. \"MB\", will omit incompatible units)") self.opts.pmSetLongOption("prefix", 1, 'm', '', "prefix for metric names (default \"pcp.\")") self.opts.pmSetLongOption("pickle-protocol", 1, 'r', 'PROTOCOL', "graphite pickle protocol (default 0)") self.opts.pmSetLongOptionHelp() self.graphite_host = "localhost" self.graphite_port = 2004 self.pickle = True self.pickle_protocol = 0 self.prefix = "pcp." self.unitsstr = None self.units = None # pass verbatim by default self.units_mult = None # pass verbatim by default # now actually parse self.context = pmapi.pmContext.fromOptions(self.opts, sys.argv) self.interval = self.opts.pmGetOptionInterval() or pmapi.timeval(60, 0) if self.unitsstr is not None: units = self.context.pmParseUnitsStr(self.unitsstr) (self.units, self.units_mult) = units self.metrics = [] self.pmids = [] self.descs = [] metrics = self.opts.pmGetNonOptionsFromList(sys.argv) if metrics: for m in metrics: try: self.context.pmTraversePMNS(m, self.handle_candidate_metric) except pmapi.pmErr as error: sys.stderr.write("Excluding metric %s (%s)\n" % (m, str(error))) sys.stderr.flush() if len(self.metrics) == 0: sys.stderr.write("No acceptable metrics specified.\n") raise pmapi.pmUsageErr() # Report what we're about to do print("Relaying %d %smetric(s) with prefix %s from %s " "in %s mode to %s:%d every %f s" % (len(self.metrics), "rescaled " if self.units else "", self.prefix, self.describe_source(), "pickled" if self.pickle else "text", self.graphite_host, self.graphite_port, self.interval)) sys.stdout.flush()
def __init__(self): """ Construct object, parse command line """ self.context = None self.socket = None self.sample_count = 0 self.opts = pmapi.pmOptions() self.opts.pmSetShortOptions("a:O:s:T:g:p:P:r:u:m:t:h:t:D:LV?") self.opts.pmSetShortUsage("[options] metricname ...") self.opts.pmSetOptionCallback(self.option) self.opts.pmSetOverrideCallback(self.option_override) self.opts.pmSetLongOptionText(""" Description: Periodically, relay raw values of all instances of a given hierarchies of PCP metrics to a graphite/carbon server on the network.""") self.opts.pmSetLongOptionHeader("Options") self.opts.pmSetLongOptionVersion() # -V self.opts.pmSetLongOptionArchive() # -a FILE self.opts.pmSetLongOptionOrigin() # -O TIME self.opts.pmSetLongOptionSamples() # -s NUMBER self.opts.pmSetLongOptionFinish() # -T NUMBER self.opts.pmSetLongOptionDebug() # -D stuff self.opts.pmSetLongOptionHost() # -h HOST self.opts.pmSetLongOptionLocalPMDA() # -L self.opts.pmSetLongOptionInterval() # -t NUMBER self.opts.pmSetLongOption( "graphite-host", 1, 'g', '', "graphite server host " + "(default \"localhost\")") self.opts.pmSetLongOption("pickled-port", 1, 'p', '', "graphite pickled port (default 2004)") self.opts.pmSetLongOption("text-port", 1, 'P', '', "graphite plaintext port (usually 2003)") self.opts.pmSetLongOption( "units", 1, 'u', '', "rescale units " + "(e.g. \"MB\", will omit incompatible units)") self.opts.pmSetLongOption( "prefix", 1, 'm', '', "prefix for metric names (default \"pcp.\")") self.opts.pmSetLongOption("pickle-protocol", 1, 'r', 'PROTOCOL', "graphite pickle protocol (default 0)") self.opts.pmSetLongOptionHelp() self.graphite_host = "localhost" self.graphite_port = 2004 self.pickle = True self.pickle_protocol = 0 self.prefix = "pcp." self.unitsstr = None self.units = None # pass verbatim by default self.units_mult = None # pass verbatim by default # now actually parse self.context = pmapi.pmContext.fromOptions(self.opts, sys.argv) self.interval = self.opts.pmGetOptionInterval() or pmapi.timeval(60, 0) if self.unitsstr is not None: units = self.context.pmParseUnitsStr(self.unitsstr) (self.units, self.units_mult) = units self.metrics = [] self.pmids = [] self.descs = [] metrics = self.opts.pmGetNonOptionsFromList(sys.argv) if metrics: for m in metrics: try: self.context.pmTraversePMNS(m, self.handle_candidate_metric) except pmapi.pmErr as error: sys.stderr.write("Excluding metric %s (%s)\n" % (m, str(error))) sys.stderr.flush() if len(self.metrics) == 0: sys.stderr.write("No acceptable metrics specified.\n") raise pmapi.pmUsageErr() # Report what we're about to do print( "Relaying %d %smetric(s) with prefix %s from %s " "in %s mode to %s:%d every %f s" % (len(self.metrics), "rescaled " if self.units else "", self.prefix, self.describe_source(), "pickled" if self.pickle else "text", self.graphite_host, self.graphite_port, self.interval)) sys.stdout.flush()
def main(stdscr_p): global stdscr stdscr = _StandardOutput(stdscr_p) sort = "" duration = 0.0 i = 1 ss = Subsystem() ss.init_processor_metrics() ss.init_memory_metrics() ss.init_disk_metrics() ss.init_network_metrics() ss.init_process_metrics() cpu = _ProcessorPrint(ss, stdscr) mem = _MemoryPrint(ss, stdscr) disk = _DiskPrint(ss, stdscr) net = _NetPrint(ss, stdscr) proc = _ProcPrint(ss, stdscr) proc.output_type = opts.output_type stdscr.width = opts.width pmc = pmapi.pmContext.fromOptions(opts.opts, sys.argv) if pmc.type == c_api.PM_CONTEXT_ARCHIVE: pmc.pmSetMode(c_api.PM_MODE_FORW, pmapi.timeval(0, 0), 0) host = pmc.pmGetContextHostName() (delta, errmsg) = pmc.pmParseInterval(str(opts.interval_arg) + " seconds") ss.setup_metrics(pmc) if opts.create_archive: delta_seconds = c_api.pmtimevalToReal(delta.tv_sec, delta.tv_usec) msec = str(int(1000.0 * delta_seconds)) configuration = "log mandatory on every " + msec + " milliseconds { " configuration += ss.dump_metrics() configuration += "}" if opts.n_samples != 0: duration = float(opts.n_samples) * delta_seconds else: duration = float(10) * delta_seconds status = record(pmgui.GuiClient(), configuration, duration, opts.output_file, host) if status != "": return status record_add_creator(opts.output_file) sys.exit(0) i_samples = 0 disk.interval = delta.tv_sec disk.replay_archive = opts.replay_archive try: elapsed = ss.get_metric_value('kernel.all.uptime') while (i_samples < opts.n_samples) or (opts.n_samples == 0): ss.get_stats(pmc) stdscr.move(0, 0) stdscr.addstr('ATOP - %s\t\t%s elapsed\n\n' % ( time.strftime("%c"), datetime.timedelta(0, elapsed))) elapsed = delta.tv_sec stdscr.move(2, 0) try: cpu.prc() cpu.cpu() mem.mem() disk.disk(pmc) net.net(pmc) proc.set_line() proc.proc() except pmapi.pmErr as e: return str(e) + " while processing " + str(ssx[0]) except Exception as e: # catch all errors, pcp or python or other pass stdscr.move(proc.command_line, 0) stdscr.refresh() stdscr.timeout(delta.tv_sec * 1000) char = stdscr.getch() if char != -1: # user typed a command try: cmd = chr(char) except ValueError: cmd = None if cmd == "q": raise KeyboardInterrupt elif cmd == "":
def __init__(self): """ Construct object, parse command line """ self.opts = pmapi.pmOptions() self.opts.pmSetShortOptions("a:O:s:T:g:i:u:m:t:h:t:D:LV?") self.opts.pmSetShortUsage("[options] metricname ...") self.opts.pmSetOptionCallback(self.option) self.opts.pmSetOverrideCallback(self.option_override) self.opts.pmSetLongOptionText(""" Description: Periodically, relay raw values of all instances of a given hierarchies of PCP metrics to a elasticsearch/carbon server on the network.""") self.opts.pmSetLongOptionHeader("Options") self.opts.pmSetLongOptionVersion() # -V self.opts.pmSetLongOptionArchive() # -a FILE self.opts.pmSetLongOptionOrigin() # -O TIME self.opts.pmSetLongOptionSamples() # -s NUMBER self.opts.pmSetLongOptionFinish() # -T NUMBER self.opts.pmSetLongOptionDebug() # -D stuff self.opts.pmSetLongOptionHost() # -h HOST self.opts.pmSetLongOptionLocalPMDA() # -L self.opts.pmSetLongOptionInterval() # -t NUMBER self.opts.pmSetLongOption( "elasticsearch-host", 1, 'g', '', "elasticsearch server host " + "(default \"http://*****:*****@timestamp': { 'type': 'date' }, 'host-id': { 'type': 'string' } } } } }) # Report what we're about to do print("Relaying %d %smetric(s) with es_index %s from %s " "to %s every %f s" % (len(self.metrics), "rescaled " if self.units else "", self.es_index, self.describe_source(), self.elasticsearch_host, self.interval)) sys.stdout.flush()
def __init__(self): """ Construct object, prepare for command line handling """ self.context = None self.daemonize = 0 self.pmconfig = pmconfig.pmConfig(self) self.opts = self.options() # Configuration directives self.keys = ('source', 'output', 'derived', 'header', 'globals', 'samples', 'interval', 'type', 'precision', 'daemonize', 'timestamp', 'unitinfo', 'colxrow', 'delay', 'width', 'delimiter', 'extcsv', 'extheader', 'repeat_header', 'timefmt', 'interpol', 'count_scale', 'space_scale', 'time_scale', 'version', 'speclocal', 'instances', 'ignore_incompat', 'omit_flat') # The order of preference for options (as present): # 1 - command line options # 2 - options from configuration file(s) # 3 - built-in defaults defined below self.check = 0 self.version = CONFVER self.source = "local:" self.output = OUTPUT_STDOUT self.speclocal = None self.derived = None self.header = 1 self.unitinfo = 1 self.globals = 1 self.timestamp = 0 self.samples = None # forever self.interval = pmapi.timeval(1) # 1 sec self.opts.pmSetOptionInterval(str(1)) # 1 sec self.delay = 0 self.type = 0 self.ignore_incompat = 0 self.instances = [] self.omit_flat = 0 self.colxrow = None self.width = 0 self.precision = 3 # .3f self.delimiter = None self.extcsv = 0 self.extheader = 0 self.repeat_header = 0 self.timefmt = None self.interpol = 1 self.count_scale = None self.space_scale = None self.time_scale = None # Not in pmrep.conf, won't overwrite self.outfile = None # Internal self.format = None # stdout format self.writer = None self.pmi = None self.localtz = None self.prev_ts = None self.runtime = -1 self.found_insts = [] # Performance metrics store # key - metric name # values - 0:label, 1:instance(s), 2:unit/scale, 3:type, 4:width, 5:pmfg item self.metrics = OrderedDict() self.pmfg = None self.pmfg_ts = None # Read configuration and prepare to connect self.config = self.pmconfig.set_config_file(DEFAULT_CONFIG) self.pmconfig.read_options() self.pmconfig.read_cmd_line() self.pmconfig.prepare_metrics() self.pmconfig.set_signal_handler()
sys.exit(1) # Setup some default reporting if none specified so far if len(subsys) == 0: subsys.append(cpu) subsys.append(disk) subsys.append(net) if opts.create_archive: subsys.append(interrupt) subsys.append(memory) pm = pmapi.pmContext.fromOptions(opts.opts, sys.argv) if pm.type == c_api.PM_CONTEXT_ARCHIVE: replay_archive = True input_file = opts.opts.pmGetOptionArchives()[0] pm.pmSetMode(c_api.PM_MODE_FORW, pmapi.timeval(0, 0), 0) # Find server-side pmcd host-name host = pm.pmGetContextHostName() (delta, errmsg) = pm.pmParseInterval(str(opts.interval_arg) + " seconds") delta_seconds = c_api.pmtimevalToReal(delta.tv_sec, delta.tv_usec) if opts.duration_arg != 0: (timeval, errmsg) = pm.pmParseInterval(str(opts.duration_arg)) duration = c_api.pmtimevalToReal(timeval.tv_sec, timeval.tv_usec) opts.n_samples = int((duration / delta_seconds) + 0.5) if opts.create_archive: msec = str(int(1000.0 * delta_seconds)) configuration = "log mandatory on every " + msec + " milliseconds {\n"
def __init__(self, arguments): """ Construct object, prepare for command line handling """ global op op = self self.context = None self.opts = self.options() self.arguments = arguments self.pmconfig = pmconfig.pmConfig(self) ### Add additional dstat metric specifiers dspec = (None, 'printtype', 'colorstep', 'plugin') mspec = self.pmconfig.metricspec + dspec self.pmconfig.metricspec = mspec ### Add global dstat configuration directives self.keys = ('header', 'interval', 'timefmt') ### The order of preference for options (as present): # 1 - command line options # 2 - options from configuration file(s) # 3 - built-in defaults defined below self.check = 0 self.version = self.CONFIG_VERSION self.source = "local:" self.output = None self.instances = None self.speclocal = None self.derived = None self.globals = 1 self.samples = -1 # forever self.interval = pmapi.timeval(1) # 1 sec self.opts.pmSetOptionInterval(str(1)) # 1 sec self.missed = 0 self.delay = 1.0 self.type = 0 self.type_prefer = self.type self.ignore_incompat = 0 self.precision = 5 # .5f self.timefmt = self.TIMEFMT self.interpol = 0 # Internal self.missed = 0 self.runtime = -1 self.plugins = [] # list of requested plugin names self.allplugins = [] # list of all known plugin names self.timeplugins = [] # list of the time plugin names self.timelist = [] # DstatPlugin time objects list self.totlist = [] # active DstatPlugin object list self.vislist = [] # visible DstatPlugin object list self.mapping = {} # maps 'section/label' to plugin self.bits = False self.blackonwhite = False self.color = None self.debug = False self.header = 1 self.output = True self.update = True self.pidfile = False self.float = False self.integer = False # Options for specific plugins self.cpulist = None self.disklist = None self.intlist = None self.netlist = None self.swaplist = None ### Implicit if no terminal is used if not sys.stdout.isatty(): self.color = False self.header = False self.update = False atexit.register(self.finalize) # Performance metrics store # key - plugin/metric name # values - 0:text label, 1:instance(s), 2:unit/scale, 3:type, # 4:width, 5:pmfg item, 6:precision, 7:limit, # [ 8:printtype, 9:colorstep, 10:plugin <- Dstat extras ] self.metrics = OrderedDict() self.pmfg = None self.pmfg_ts = None ### Initialise output device self.term = DstatTerminal() ### Read configuration and initialise plugins configs = self.prepare_plugins() self.create_time_plugins() ### Complete command line processing and terminal/file setup operands = self.pmconfig.read_cmd_line() self.prepare_metrics(configs) self.prepare_output(operands)
# Setup some default reporting if none specified so far if len(subsys) == 0: subsys.append(cpu) subsys.append(disk) subsys.append(net) if opts.create_archive: subsys.append(interrupt, memory) if opts.duration_arg != 0: (timeval, errmsg) = pm.pmParseInterval(str(opts.duration_arg)) duration = c_api.pmtimevalToReal(timeval) pm = pmapi.pmContext.fromOptions(opts.opts, sys.argv) if pm.type == c_api.PM_CONTEXT_ARCHIVE: pm.pmSetMode(c_api.PM_MODE_FORW, pmapi.timeval(0, 0), 0) # Find server-side pmcd host-name host = pm.pmGetContextHostName() (delta, errmsg) = pmapi.pmContext.pmParseInterval(str(opts.interval_arg) + " seconds") if opts.create_archive: delta_seconds = c_api.pmtimevalToReal(delta.tv_sec, delta.tv_usec) msec = str(int(1000.0 * delta_seconds)) configuration = "log mandatory on every " + msec + " milliseconds { " configuration += ss.dump_metrics() configuration += "}" if duration == 0.0: if opts.n_samples != 0: duration = float(opts.n_samples) * delta_seconds
def __init__(self): """ Construct object, parse command line """ self.context = None self.database = 'pcp' self.influxdb_tags = '' self.influxdb_address = 'http://127.0.0.1:8086' self.influxdb_user = None self.influxdb_pass = None self.sample_count = 0 self.unitsstr = None self.units = None self.units_mult = None # option setup self.opts = pmapi.pmOptions() self.opts.pmSetShortOptions("a:O:s:T:g:p:P:r:m:t:u:h:t:D:LV?") self.opts.pmSetShortUsage("[options] metricname ...") self.opts.pmSetLongOptionText(""" Description: Periodically, relay raw values of all instances of a given hierarchies of PCP metrics to an InfluxDB server on the network.""") self.opts.pmSetLongOptionHeader("Options") self.opts.pmSetOptionCallback(self.option) # common options self.opts.pmSetLongOptionVersion() self.opts.pmSetLongOptionArchive() self.opts.pmSetLongOptionOrigin() self.opts.pmSetLongOptionSamples() self.opts.pmSetLongOptionFinish() self.opts.pmSetLongOptionDebug() self.opts.pmSetLongOptionHost() self.opts.pmSetLongOptionLocalPMDA() self.opts.pmSetLongOptionInterval() # custom options self.opts.pmSetLongOption("influxdb-address", 1, 'i', '', "InfluxDB HTTP/HTTPS address " + "(default \"" + self.influxdb_address + "\")") self.opts.pmSetLongOption("units", 1, 'u', '', "rescale units " + "(e.g. \"MB\", will omit incompatible units)") self.opts.pmSetLongOption("database", 1, 'd', '', "database for metric (default \"pcp\")") self.opts.pmSetLongOption("db-user", 1, 'U', '', "username for InfluxDB database") self.opts.pmSetLongOption("db-password", 1, 'P', '', "password for InfluxDB database") self.opts.pmSetLongOption("tag-string", 1, 'I', '', "string of tags to add to the metrics") self.opts.pmSetLongOptionHelp() # parse options self.context = pmapi.pmContext.fromOptions(self.opts, sys.argv) self.interval = self.opts.pmGetOptionInterval() or pmapi.timeval(60, 0) if self.unitsstr is not None: units = self.context.pmParseUnitsStr(self.unitsstr) (self.units, self.units_mult) = units self.metrics = [] self.pmids = [] self.descs = [] metrics = self.opts.pmGetNonOptionsFromList(sys.argv) if metrics: for m in metrics: try: self.context.pmTraversePMNS(m, self.handle_candidate_metric) except pmapi.pmErr as error: sys.stderr.write("Excluding metric %s (%s)\n" % (m, str(error))) sys.stderr.flush() if len(self.metrics) == 0: sys.stderr.write("No acceptable metrics specified.\n") raise pmapi.pmUsageErr() # Report what we're about to do print("Relaying %d %smetric(s) to database %s with tags %s from %s " "to %s every %f s" % (len(self.metrics), "rescaled " if self.units else "", self.database, self.influxdb_tags, self.describe_source(), self.influxdb_address, self.interval)) sys.stdout.flush()
def __init__(self): """ Construct object, parse command line """ self.context = None self.opts = pmapi.pmOptions() self.opts.pmSetShortOptions("g:p:P:u:m:t:h:Lt:D:V?") # must include common options self.opts.pmSetShortUsage("[options] metricname ...") self.opts.pmSetOptionCallback(self.option) self.opts.pmSetOverrideCallback(self.option_override) # hack to include some explanatory text self.opts.pmSetLongOptionHeader( """ Description: Periodically, relay raw values of all instances of a given hierarchies of PCP metrics to a graphite/carbon server on the network. Options""" ) self.opts.pmSetLongOptionVersion() # -V # self.opts.pmSetLongOptionArchive() # -a FILE -- not supported yet; need -S/etc. controls self.opts.pmSetLongOptionDebug() # -D stuff self.opts.pmSetLongOptionHost() # -h HOST # self.opts.pmSetLongOptionLocalPMDA() # -L self.opts.pmSetLongOptionInterval() # -t NUMBER self.opts.pmSetLongOption("graphite-host", 1, "g", "", 'graphite server host (default "localhost")') self.opts.pmSetLongOption("pickled-port", 1, "p", "", "graphite pickled port (default 2004)") self.opts.pmSetLongOption("text-port", 1, "P", "", "graphite plaintext port (usually 2003)") self.opts.pmSetLongOption("units", 1, "u", "", 'rescale all metric units (e.g., "mbytes/5 sec")') self.opts.pmSetLongOption("prefix", 1, "m", "", 'prefix for metric names (default "pcp.")') self.opts.pmSetLongOptionHelp() self.graphite_host = "localhost" self.graphite_port = 2004 self.pickle = True self.prefix = "pcp." self.unitsstr = None self.units = None # pass verbatim by default self.units_mult = None # pass verbatim by default # now actually parse self.context = pmapi.pmContext.fromOptions(self.opts, sys.argv) self.interval = self.opts.pmGetOptionInterval() or pmapi.timeval(60, 0) if self.unitsstr is not None: (self.units, self.units_mult) = self.context.pmParseUnitsStr(self.unitsstr) self.metrics = [] self.pmids = [] self.descs = [] metrics = self.opts.pmNonOptionsFromList(sys.argv) if metrics: for m in metrics: try: self.context.pmTraversePMNS(m, self.handle_candidate_metric) except pmapi.pmErr as error: sys.stderr.write("Excluding metric %s (%s)\n" % (m, str(error))) sys.stderr.flush() if len(self.metrics) == 0: sys.stderr.write("No acceptable metrics specified.\n") raise pmapi.pmUsageErr() # Report what we're about to do print( "Relaying %d %smetric(s) with prefix %s " "in %s mode to %s:%d every %f s" % ( len(self.metrics), "rescaled " if self.units else "", self.prefix, "pickled" if self.pickle else "text", self.graphite_host, self.graphite_port, self.interval, ) ) sys.stdout.flush()
def __init__(self): """ Construct object, prepare for command line handling """ self.context = None self.daemonize = 0 self.pmconfig = pmconfig.pmConfig(self) self.opts = self.options() # Configuration directives self.keys = ('source', 'output', 'derived', 'header', 'globals', 'samples', 'interval', 'type', 'precision', 'daemonize', 'timefmt', 'extended', 'everything', 'exact_types', 'count_scale', 'space_scale', 'time_scale', 'version', 'count_scale_force', 'space_scale_force', 'time_scale_force', 'type_prefer', 'precision_force', 'limit_filter', 'limit_filter_force', 'live_filter', 'rank', 'invert_filter', 'predicate', 'speclocal', 'instances', 'ignore_incompat', 'omit_flat') # The order of preference for options (as present): # 1 - command line options # 2 - options from configuration file(s) # 3 - built-in defaults defined below self.check = 0 self.version = CONFVER self.source = "local:" self.output = None # For pmrep conf file compat only self.speclocal = None self.derived = None self.header = 1 self.globals = 1 self.samples = None # forever self.interval = pmapi.timeval(60) # 60 sec self.opts.pmSetOptionInterval(str(60)) # 60 sec self.delay = 0 self.type = 0 self.type_prefer = self.type self.ignore_incompat = 0 self.instances = [] self.live_filter = 0 self.rank = 0 self.limit_filter = 0 self.limit_filter_force = 0 self.invert_filter = 0 self.predicate = None self.omit_flat = 0 self.precision = 3 # .3f self.precision_force = None self.timefmt = TIMEFMT self.interpol = 0 self.count_scale = None self.count_scale_force = None self.space_scale = None self.space_scale_force = None self.time_scale = None self.time_scale_force = None # Not in pcp2json.conf, won't overwrite self.outfile = None self.extended = 0 self.everything = 0 self.exact_types = 0 # Internal self.runtime = -1 self.data = None self.prev_ts = None self.writer = None # Performance metrics store # key - metric name # values - 0:txt label, 1:instance(s), 2:unit/scale, 3:type, # 4:width, 5:pmfg item, 6:precision, 7:limit self.metrics = OrderedDict() self.pmfg = None self.pmfg_ts = None # Read configuration and prepare to connect self.config = self.pmconfig.set_config_file(DEFAULT_CONFIG) self.pmconfig.read_options() self.pmconfig.read_cmd_line() self.pmconfig.prepare_metrics() self.pmconfig.set_signal_handler()
def __init__(self): """ Construct object, prepare for command line handling """ self.context = None self.daemonize = 0 self.pmconfig = pmconfig.pmConfig(self) self.opts = self.options() # Configuration directives self.keys = ('source', 'output', 'derived', 'header', 'globals', 'samples', 'interval', 'type', 'precision', 'daemonize', 'zabbix_server', 'zabbix_port', 'zabbix_host', 'zabbix_interval', 'zabbix_prefix', 'zabbix_lld', 'count_scale', 'space_scale', 'time_scale', 'version', 'count_scale_force', 'space_scale_force', 'time_scale_force', 'type_prefer', 'precision_force', 'limit_filter', 'limit_filter_force', 'live_filter', 'rank', 'invert_filter', 'predicate', 'names_change', 'speclocal', 'instances', 'ignore_incompat', 'ignore_unknown', 'omit_flat') # The order of preference for options (as present): # 1 - command line options # 2 - options from configuration file(s) # 3 - built-in defaults defined below self.check = 0 self.version = CONFVER self.source = "local:" self.output = None # For pmrep conf file compat only self.speclocal = None self.derived = None self.header = 1 self.globals = 1 self.samples = None # forever self.interval = pmapi.timeval(60) # 60 sec self.opts.pmSetOptionInterval(str(60)) # 60 sec self.delay = 0 self.type = 0 self.type_prefer = self.type self.ignore_incompat = 0 self.ignore_unknown = 0 self.names_change = 0 # ignore self.instances = [] self.live_filter = 0 self.rank = 0 self.limit_filter = 0 self.limit_filter_force = 0 self.invert_filter = 0 self.predicate = None self.omit_flat = 0 self.precision = 3 # .3f self.precision_force = None self.timefmt = "%H:%M:%S" # For compat only self.interpol = 0 self.count_scale = None self.count_scale_force = None self.space_scale = None self.space_scale_force = None self.time_scale = None self.time_scale_force = None self.zabbix_server = ZBXSERVER self.zabbix_port = ZBXPORT self.zabbix_host = None self.zabbix_interval = None self.zabbix_prefix = ZBXPREFIX self.zabbix_lld = 0 # Dictionary storing metric:[instance, instance ...] objects self.lld_history = {} # Internal self.runtime = -1 self.zabbix_prevsend = None self.zabbix_metrics = [] # Performance metrics store # key - metric name # values - 0:txt label, 1:instance(s), 2:unit/scale, 3:type, # 4:width, 5:pmfg item, 6:precision, 7:limit self.metrics = OrderedDict() self.pmfg = None self.pmfg_ts = None # Read configuration and prepare to connect self.config = self.pmconfig.set_config_path(DEFAULT_CONFIG) self.pmconfig.read_options() self.pmconfig.read_cmd_line() self.pmconfig.prepare_metrics() self.pmconfig.set_signal_handler()
def main(stdscr_p): global stdscr stdscr = _StandardOutput(stdscr_p) sort = "" duration = 0.0 i = 1 ss = Subsystem() ss.init_processor_metrics() ss.init_memory_metrics() ss.init_disk_metrics() ss.init_network_metrics() ss.init_process_metrics() cpu = _ProcessorPrint(ss, stdscr) mem = _MemoryPrint(ss, stdscr) disk = _DiskPrint(ss, stdscr) net = _NetPrint(ss, stdscr) proc = _ProcPrint(ss, stdscr) proc.output_type = opts.output_type stdscr.width = opts.width pmc = pmapi.pmContext.fromOptions(opts.opts, sys.argv) if pmc.type == c_api.PM_CONTEXT_ARCHIVE: pmc.pmSetMode(c_api.PM_MODE_FORW, pmapi.timeval(0, 0), 0) host = pmc.pmGetContextHostName() (delta, errmsg) = pmc.pmParseInterval(str(opts.interval_arg) + " seconds") ss.setup_metrics(pmc) if opts.create_archive: delta_seconds = c_api.pmtimevalToReal(delta.tv_sec, delta.tv_usec) msec = str(int(1000.0 * delta_seconds)) configuration = "log mandatory on every " + msec + " milliseconds { " configuration += ss.dump_metrics() configuration += "}" if opts.n_samples != 0: duration = float(opts.n_samples) * delta_seconds else: duration = float(10) * delta_seconds status = record(pmgui.GuiClient(), configuration, duration, opts.output_file, host) if status != "": return status record_add_creator(opts.output_file) sys.exit(0) i_samples = 0 disk.interval = delta.tv_sec disk.replay_archive = opts.replay_archive try: elapsed = ss.get_metric_value('kernel.all.uptime') while (i_samples < opts.n_samples) or (opts.n_samples == 0): ss.get_stats(pmc) stdscr.move(0, 0) stdscr.addstr('ATOP - %s %s elapsed\n\n' % ( time.strftime("%c"), datetime.timedelta(0, elapsed))) elapsed = delta.tv_sec stdscr.move(2, 0) try: cpu.prc() cpu.cpu() mem.mem() disk.disk(pmc) net.net(pmc) proc.set_line() proc.proc() except pmapi.pmErr as e: return str(e) + " while processing " + str(ssx[0]) except Exception as e: # catch all errors, pcp or python or other pass stdscr.move(proc.command_line, 0) stdscr.refresh() stdscr.timeout(delta.tv_sec * 1000) char = stdscr.getch() if char != -1: # user typed a command try: cmd = chr(char) except ValueError: cmd = None if cmd == "q": raise KeyboardInterrupt elif cmd == "":
def __init__(self): """ Construct object, prepare for command line handling """ self.context = None self.daemonize = 0 self.maxlong = pow(2, 63) # java long limit, applied by elasticsearch self.pmconfig = pmconfig.pmConfig(self) self.opts = self.options() # Configuration directives self.keys = ('source', 'output', 'derived', 'header', 'globals', 'samples', 'interval', 'type', 'precision', 'daemonize', 'es_server', 'es_index', 'es_hostid', 'es_search_type', 'count_scale', 'space_scale', 'time_scale', 'version', 'count_scale_force', 'space_scale_force', 'time_scale_force', 'type_prefer', 'precision_force', 'limit_filter', 'limit_filter_force', 'live_filter', 'rank', 'invert_filter', 'predicate', 'names_change', 'speclocal', 'instances', 'ignore_incompat', 'ignore_unknown', 'omit_flat', 'include_labels') # Ignored for pmrep(1) compatibility self.keys_ignore = ('timestamp', 'unitinfo', 'colxrow', 'separate_header', 'fixed_header', 'delay', 'width', 'delimiter', 'extcsv', 'width_force', 'extheader', 'repeat_header', 'timefmt', 'interpol', 'dynamic_header', 'overall_rank', 'overall_rank_alt', 'sort_metric', 'instinfo', 'include_texts') # The order of preference for options (as present): # 1 - command line options # 2 - options from configuration file(s) # 3 - built-in defaults defined below self.check = 0 self.version = CONFVER self.source = "local:" self.output = None # For pmrep conf file compat only self.speclocal = None self.derived = None self.header = 1 self.globals = 1 self.samples = None # forever self.interval = pmapi.timeval(60) # 60 sec self.opts.pmSetOptionInterval(str(60)) # 60 sec self.delay = 0 self.type = 0 self.type_prefer = self.type self.ignore_incompat = 0 self.ignore_unknown = 0 self.names_change = 0 # ignore self.instances = [] self.live_filter = 0 self.rank = 0 self.limit_filter = 0 self.limit_filter_force = 0 self.invert_filter = 0 self.predicate = None self.omit_flat = 0 self.include_labels = 0 self.precision = 3 # .3f self.precision_force = None self.timefmt = "%H:%M:%S" # For compat only self.interpol = 0 self.count_scale = None self.count_scale_force = None self.space_scale = None self.space_scale_force = None self.time_scale = None self.time_scale_force = None self.es_server = ES_SERVER self.es_index = ES_INDEX self.es_search_type = ES_SEARCH_TYPE self.es_hostid = None self.es_failed = False # Internal self.runtime = -1 # Performance metrics store # key - metric name # values - 0:txt label, 1:instance(s), 2:unit/scale, 3:type, # 4:width, 5:pmfg item, 6:precision, 7:limit self.metrics = OrderedDict() self.pmfg = None self.pmfg_ts = None # Read configuration and prepare to connect self.config = self.pmconfig.set_config_path(DEFAULT_CONFIG) self.pmconfig.read_options() self.pmconfig.read_cmd_line() self.pmconfig.prepare_metrics() self.pmconfig.set_signal_handler()
def __init__(self): """ Construct object, prepare for command line handling """ self.context = None self.daemonize = 0 self.pmconfig = pmconfig.pmConfig(self) self.opts = self.options() # Configuration directives self.keys = ('source', 'output', 'derived', 'header', 'globals', 'samples', 'interval', 'type', 'precision', 'daemonize', 'timefmt', # XXX Custom options here, if any (see below) 'count_scale', 'space_scale', 'time_scale', 'version', 'count_scale_force', 'space_scale_force', 'time_scale_force', 'type_prefer', 'precision_force', 'limit_filter', 'limit_filter_force', 'live_filter', 'rank', 'invert_filter', 'predicate', 'names_change', 'speclocal', 'instances', 'ignore_incompat', 'ignore_unknown', 'omit_flat') # Ignored for pmrep(1) compatibility # XXX Keep in sync with self.keys in pmrep self.keys_ignore = ( 'timestamp', 'unitinfo', 'colxrow', 'separate_header', 'fixed_header', 'delay', 'width', 'delimiter', 'extcsv', 'width_force', 'extheader', 'repeat_header', 'interpol', 'dynamic_header', 'overall_rank', 'overall_rank_alt', 'sort_metric', 'instinfo', 'include_labels', 'include_texts') # The order of preference for options (as present): # 1 - command line options # 2 - options from configuration file(s) # 3 - built-in defaults defined below self.check = 0 self.version = CONFVER self.source = "local:" self.output = None # For pmrep conf file compat only self.speclocal = None self.derived = None self.header = 1 self.globals = 1 self.samples = None # forever # XXX Adjust default interval as needed self.interval = pmapi.timeval(10) # 10 sec self.opts.pmSetOptionInterval(str(10)) # 10 sec self.delay = 0 self.type = 0 self.type_prefer = self.type self.ignore_incompat = 0 self.ignore_unknown = 0 self.names_change = 0 # ignore self.instances = [] self.live_filter = 0 self.rank = 0 self.limit_filter = 0 self.limit_filter_force = 0 self.invert_filter = 0 self.predicate = None self.omit_flat = 0 self.precision = 3 # .3f self.precision_force = None self.timefmt = TIMEFMT self.interpol = 0 self.count_scale = None self.count_scale_force = None self.space_scale = None self.space_scale_force = None self.time_scale = None self.time_scale_force = None # Not in pcp2XXX.conf, won't overwrite self.outfile = None # XXX Custom options here, if any (keep in sync with self.keys) # Internal self.runtime = -1 self.writer = None # Performance metrics store # key - metric name # values - 0:txt label, 1:instance(s), 2:unit/scale, 3:type, # 4:width, 5:pmfg item, 6:precision, 7:limit self.metrics = OrderedDict() self.pmfg = None self.pmfg_ts = None # Read configuration and prepare to connect self.config = self.pmconfig.set_config_path(DEFAULT_CONFIG) self.pmconfig.read_options() self.pmconfig.read_cmd_line() self.pmconfig.prepare_metrics() self.pmconfig.set_signal_handler()