pcp_easy 0.0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4b614f442db11a712d65f2ecba4018eac61894f9
+  data.tar.gz: 16f2c37d9769f45b5039bf711d3d5bb60cdfc9c5
+SHA512:
+  metadata.gz: f0b87a279801efb5a6073024660258b197c06ad905b4354bd0af06cd7f4c49268e9764b7b4b5fdd1ae77237be0c22cfb9ed16b6e02c0d9f6d27999cbc21c601d
+  data.tar.gz: 6b632132c7978506d09bd5db674534e765ddc171fc4dcd6bc5674c336f1e5d7ec452aad424ad7d195431ba7e971896be440f0034288e28fe6976849ad52121fc

data/ext/pcp_easy/exceptions.c

@@ -0,0 +1,213 @@
+/*
+ * Copyright (C) 2016 Ryan Doyle
+ *
+ * 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 "exceptions.h"
+
+#include <ruby.h>
+#include <pcp/pmapi.h>
+
+/* Error classes */
+VALUE pcpeasy_error = Qnil;
+VALUE pcpeasy_pmns_error = Qnil;
+VALUE pcpeasy_no_pmns_error = Qnil;
+VALUE pcpeasy_dup_pmns_error = Qnil;
+VALUE pcpeasy_text_error = Qnil;
+VALUE pcpeasy_app_version_error = Qnil;
+VALUE pcpeasy_value_error = Qnil;
+VALUE pcpeasy_timeout_error = Qnil;
+VALUE pcpeasy_no_data_error = Qnil;
+VALUE pcpeasy_reset_error = Qnil;
+VALUE pcpeasy_name_error = Qnil;
+VALUE pcpeasy_pmid_error = Qnil;
+VALUE pcpeasy_indom_error = Qnil;
+VALUE pcpeasy_inst_error = Qnil;
+VALUE pcpeasy_unit_error = Qnil;
+VALUE pcpeasy_conv_error = Qnil;
+VALUE pcpeasy_trunc_error = Qnil;
+VALUE pcpeasy_sign_error = Qnil;
+VALUE pcpeasy_profile_error = Qnil;
+VALUE pcpeasy_ipc_error = Qnil;
+VALUE pcpeasy_eof_error = Qnil;
+VALUE pcpeasy_not_host_error = Qnil;
+VALUE pcpeasy_eol_error = Qnil;
+VALUE pcpeasy_mode_error = Qnil;
+VALUE pcpeasy_label_error = Qnil;
+VALUE pcpeasy_log_rec_error = Qnil;
+VALUE pcpeasy_not_archive_error = Qnil;
+VALUE pcpeasy_log_file_error = Qnil;
+VALUE pcpeasy_no_context_error = Qnil;
+VALUE pcpeasy_profile_spec_error = Qnil;
+VALUE pcpeasy_pmid_log_error = Qnil;
+VALUE pcpeasy_indom_log_error = Qnil;
+VALUE pcpeasy_inst_log_error = Qnil;
+VALUE pcpeasy_no_profile_error = Qnil;
+VALUE pcpeasy_no_agent_error = Qnil;
+VALUE pcpeasy_permission_error = Qnil;
+VALUE pcpeasy_connlimit_error = Qnil;
+VALUE pcpeasy_again_error = Qnil;
+VALUE pcpeasy_is_conn_error = Qnil;
+VALUE pcpeasy_not_conn_error = Qnil;
+VALUE pcpeasy_need_port_error = Qnil;
+VALUE pcpeasy_non_leaf_error = Qnil;
+VALUE pcpeasy_type_error = Qnil;
+VALUE pcpeasy_thread_error = Qnil;
+VALUE pcpeasy_no_container_error = Qnil;
+VALUE pcpeasy_bad_store_error = Qnil;
+VALUE pcpeasy_too_small_error = Qnil;
+VALUE pcpeasy_too_big_error = Qnil;
+VALUE pcpeasy_fault_error = Qnil;
+VALUE pcpeasy_pmda_ready_error = Qnil;
+VALUE pcpeasy_pmda_not_ready_error = Qnil;
+VALUE pcpeasy_nyi_error = Qnil;
+
+
+static const struct pmapi_to_ruby_exception {
+    int pmapi_error;
+    VALUE *ruby_exception;
+} pmapi_to_ruby_exception_map[] = {
+        {PM_ERR_GENERIC, &pcpeasy_error},
+        {PM_ERR_PMNS, &pcpeasy_pmns_error},
+        {PM_ERR_NOPMNS, &pcpeasy_no_pmns_error},
+        {PM_ERR_DUPPMNS, &pcpeasy_dup_pmns_error},
+        {PM_ERR_TEXT, &pcpeasy_text_error},
+        {PM_ERR_APPVERSION, &pcpeasy_app_version_error},
+        {PM_ERR_VALUE, &pcpeasy_value_error},
+        {PM_ERR_TIMEOUT, &pcpeasy_timeout_error},
+        {PM_ERR_NODATA, &pcpeasy_no_data_error},
+        {PM_ERR_RESET, &pcpeasy_reset_error},
+        {PM_ERR_NAME, &pcpeasy_name_error},
+        {PM_ERR_PMID, &pcpeasy_pmid_error},
+        {PM_ERR_INDOM, &pcpeasy_indom_error},
+        {PM_ERR_INST, &pcpeasy_inst_error},
+        {PM_ERR_UNIT, &pcpeasy_unit_error},
+        {PM_ERR_CONV, &pcpeasy_conv_error},
+        {PM_ERR_TRUNC, &pcpeasy_trunc_error},
+        {PM_ERR_SIGN, &pcpeasy_sign_error},
+        {PM_ERR_PROFILE, &pcpeasy_profile_error},
+        {PM_ERR_IPC, &pcpeasy_ipc_error},
+        {PM_ERR_EOF, &pcpeasy_eof_error},
+        {PM_ERR_NOTHOST, &pcpeasy_not_host_error},
+        {PM_ERR_EOL, &pcpeasy_eol_error},
+        {PM_ERR_MODE, &pcpeasy_mode_error},
+        {PM_ERR_LABEL, &pcpeasy_label_error},
+        {PM_ERR_LOGREC, &pcpeasy_log_rec_error},
+        {PM_ERR_NOTARCHIVE, &pcpeasy_not_archive_error},
+        {PM_ERR_LOGFILE, &pcpeasy_log_file_error},
+        {PM_ERR_NOCONTEXT, &pcpeasy_no_context_error},
+        {PM_ERR_PROFILESPEC, &pcpeasy_profile_spec_error},
+        {PM_ERR_PMID_LOG, &pcpeasy_pmid_log_error},
+        {PM_ERR_INDOM_LOG, &pcpeasy_indom_log_error},
+        {PM_ERR_INST_LOG, &pcpeasy_inst_log_error},
+        {PM_ERR_NOPROFILE, &pcpeasy_no_profile_error},
+        {PM_ERR_NOAGENT, &pcpeasy_no_agent_error},
+        {PM_ERR_PERMISSION, &pcpeasy_permission_error},
+        {PM_ERR_CONNLIMIT, &pcpeasy_connlimit_error},
+        {PM_ERR_AGAIN, &pcpeasy_again_error},
+        {PM_ERR_ISCONN, &pcpeasy_is_conn_error},
+        {PM_ERR_NOTCONN, &pcpeasy_not_conn_error},
+        {PM_ERR_NEEDPORT, &pcpeasy_need_port_error},
+        {PM_ERR_NONLEAF, &pcpeasy_non_leaf_error},
+        {PM_ERR_TYPE, &pcpeasy_type_error},
+        {PM_ERR_THREAD, &pcpeasy_thread_error},
+        {PM_ERR_NOCONTAINER, &pcpeasy_no_container_error},
+        {PM_ERR_BADSTORE, &pcpeasy_bad_store_error},
+        {PM_ERR_TOOSMALL, &pcpeasy_too_small_error},
+        {PM_ERR_TOOBIG, &pcpeasy_too_big_error},
+        {PM_ERR_FAULT, &pcpeasy_fault_error},
+        {PM_ERR_PMDAREADY, &pcpeasy_pmda_ready_error},
+        {PM_ERR_PMDANOTREADY, &pcpeasy_pmda_not_ready_error},
+        {PM_ERR_NYI, &pcpeasy_nyi_error},
+};
+
+static VALUE get_exception_from_pmapi_error_code(int error_code) {
+    int i, number_of_pmapi_to_ruby_errors;
+    number_of_pmapi_to_ruby_errors = sizeof(pmapi_to_ruby_exception_map) / sizeof(struct pmapi_to_ruby_exception);
+
+    for(i=0; i < number_of_pmapi_to_ruby_errors; i++) {
+        if(pmapi_to_ruby_exception_map[i].pmapi_error == error_code) {
+            return *pmapi_to_ruby_exception_map[i].ruby_exception;
+        }
+    }
+    /* Default to a generic error */
+    return pcpeasy_error;
+}
+
+void pcpeasy_raise_from_pmapi_error(int error_number) {
+    char errmsg[PM_MAXERRMSGLEN];
+    VALUE exception_to_raise;
+
+    exception_to_raise = get_exception_from_pmapi_error_code(error_number);
+
+    rb_raise(exception_to_raise, (const char *)pmErrStr_r(error_number, (char *)&errmsg, sizeof(errmsg)));
+}
+
+
+void pcpeasy_exceptions_init(VALUE pcpeasy_class) {
+    pcpeasy_error = rb_define_class_under(pcpeasy_class, "Error", rb_eStandardError);
+    pcpeasy_pmns_error = rb_define_class_under(pcpeasy_class, "PMNSError", pcpeasy_error);
+    pcpeasy_no_pmns_error = rb_define_class_under(pcpeasy_class, "NoPMNSError", pcpeasy_error);
+    pcpeasy_dup_pmns_error = rb_define_class_under(pcpeasy_class, "DupPMNSError", pcpeasy_error);
+    pcpeasy_text_error = rb_define_class_under(pcpeasy_class, "TextError", pcpeasy_error);
+    pcpeasy_app_version_error = rb_define_class_under(pcpeasy_class, "AppVersionError", pcpeasy_error);
+    pcpeasy_value_error = rb_define_class_under(pcpeasy_class, "ValueError", pcpeasy_error);
+    pcpeasy_timeout_error = rb_define_class_under(pcpeasy_class, "TimeoutError", pcpeasy_error);
+    pcpeasy_no_data_error = rb_define_class_under(pcpeasy_class, "NoDataError", pcpeasy_error);
+    pcpeasy_reset_error = rb_define_class_under(pcpeasy_class, "ResetError", pcpeasy_error);
+    pcpeasy_name_error = rb_define_class_under(pcpeasy_class, "NameError", pcpeasy_error);
+    pcpeasy_pmid_error = rb_define_class_under(pcpeasy_class, "PMIDError", pcpeasy_error);
+    pcpeasy_indom_error = rb_define_class_under(pcpeasy_class, "InDomError", pcpeasy_error);
+    pcpeasy_inst_error = rb_define_class_under(pcpeasy_class, "InstError", pcpeasy_error);
+    pcpeasy_unit_error = rb_define_class_under(pcpeasy_class, "UnitError", pcpeasy_error);
+    pcpeasy_conv_error = rb_define_class_under(pcpeasy_class, "ConvError", pcpeasy_error);
+    pcpeasy_trunc_error = rb_define_class_under(pcpeasy_class, "TruncError", pcpeasy_error);
+    pcpeasy_sign_error = rb_define_class_under(pcpeasy_class, "SignError", pcpeasy_error);
+    pcpeasy_profile_error = rb_define_class_under(pcpeasy_class, "ProfileError", pcpeasy_error);
+    pcpeasy_ipc_error = rb_define_class_under(pcpeasy_class, "IPCError", pcpeasy_error);
+    pcpeasy_eof_error = rb_define_class_under(pcpeasy_class, "EOFError", pcpeasy_error);
+    pcpeasy_not_host_error = rb_define_class_under(pcpeasy_class, "NotHostError", pcpeasy_error);
+    pcpeasy_eol_error = rb_define_class_under(pcpeasy_class, "EOLError", pcpeasy_error);
+    pcpeasy_mode_error = rb_define_class_under(pcpeasy_class, "ModeError", pcpeasy_error);
+    pcpeasy_label_error = rb_define_class_under(pcpeasy_class, "LabelError", pcpeasy_error);
+    pcpeasy_log_rec_error = rb_define_class_under(pcpeasy_class, "LogRecError", pcpeasy_error);
+    pcpeasy_not_archive_error = rb_define_class_under(pcpeasy_class, "NotArchiveError", pcpeasy_error);
+    pcpeasy_log_file_error = rb_define_class_under(pcpeasy_class, "LogFileError", pcpeasy_error);
+    pcpeasy_no_context_error = rb_define_class_under(pcpeasy_class, "NoContextError", pcpeasy_error);
+    pcpeasy_profile_spec_error = rb_define_class_under(pcpeasy_class, "ProfileSpecError", pcpeasy_error);
+    pcpeasy_pmid_log_error = rb_define_class_under(pcpeasy_class, "PMIDLogError", pcpeasy_error);
+    pcpeasy_indom_log_error = rb_define_class_under(pcpeasy_class, "InDomLogError", pcpeasy_error);
+    pcpeasy_inst_log_error = rb_define_class_under(pcpeasy_class, "InstLogError", pcpeasy_error);
+    pcpeasy_no_profile_error = rb_define_class_under(pcpeasy_class, "NoProfileError", pcpeasy_error);
+    pcpeasy_no_agent_error = rb_define_class_under(pcpeasy_class, "NoAgentError", pcpeasy_error);
+    pcpeasy_permission_error = rb_define_class_under(pcpeasy_class, "PermissionError", pcpeasy_error);
+    pcpeasy_connlimit_error = rb_define_class_under(pcpeasy_class, "ConnLimitError", pcpeasy_error);
+    pcpeasy_again_error = rb_define_class_under(pcpeasy_class, "AgainError", pcpeasy_error);
+    pcpeasy_is_conn_error = rb_define_class_under(pcpeasy_class, "IsConnError", pcpeasy_error);
+    pcpeasy_not_conn_error = rb_define_class_under(pcpeasy_class, "NotConnError", pcpeasy_error);
+    pcpeasy_need_port_error = rb_define_class_under(pcpeasy_class, "NeedPortError", pcpeasy_error);
+    pcpeasy_non_leaf_error = rb_define_class_under(pcpeasy_class, "NonLeafError", pcpeasy_error);
+    pcpeasy_type_error = rb_define_class_under(pcpeasy_class, "TypeError", pcpeasy_error);
+    pcpeasy_thread_error = rb_define_class_under(pcpeasy_class, "ThreadError", pcpeasy_error);
+    pcpeasy_no_container_error = rb_define_class_under(pcpeasy_class, "NoContainerError", pcpeasy_error);
+    pcpeasy_bad_store_error = rb_define_class_under(pcpeasy_class, "BadStoreError", pcpeasy_error);
+    pcpeasy_too_small_error = rb_define_class_under(pcpeasy_class, "TooSmallError", pcpeasy_error);
+    pcpeasy_too_big_error = rb_define_class_under(pcpeasy_class, "TooBigError", pcpeasy_error);
+    pcpeasy_fault_error = rb_define_class_under(pcpeasy_class, "FaultError", pcpeasy_error);
+    pcpeasy_pmda_ready_error = rb_define_class_under(pcpeasy_class, "PMDAReadyError", pcpeasy_error);
+    pcpeasy_pmda_not_ready_error = rb_define_class_under(pcpeasy_class, "PMDANotReadyError", pcpeasy_error);
+    pcpeasy_nyi_error = rb_define_class_under(pcpeasy_class, "NYIError", pcpeasy_error);
+}

data/ext/pcp_easy/exceptions.h

@@ -0,0 +1,27 @@
+/*
+ * Copyright (C) 2016 Ryan Doyle
+ *
+ * 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/>.
+ *
+ */
+
+#ifndef PCPEASY_RUBY_EXCEPTIONS_H
+#define PCPEASY_RUBY_EXCEPTIONS_H 1
+
+#include <ruby.h>
+VALUE pcpeasy_error;
+void pcpeasy_exceptions_init(VALUE pcpeasy_class);
+void pcpeasy_raise_from_pmapi_error(int error_number);
+
+#endif

data/ext/pcp_easy/extconf.rb

@@ -0,0 +1,5 @@
+require 'mkmf'
+extension_name = 'pcp_easy'
+asplode('pcp') unless find_library('pcp', 'pmNewContext')
+dir_config(extension_name)
+create_makefile(extension_name)

data/ext/pcp_easy/metric.c

@@ -0,0 +1,133 @@
+/*
+ * Copyright (C) 2016 Ryan Doyle
+ *
+ * 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 <ruby.h>
+#include <pcp/pmapi.h>
+
+#include "exceptions.h"
+
+#define READ_ONLY 1, 0
+#define CONSTRUCTOR_ARGS 4
+
+VALUE pcpeasy_metric_class;
+VALUE pcpeasy_metric_semantics_counter;
+VALUE pcpeasy_metric_semantics_instant;
+VALUE pcpeasy_metric_semantics_discrete;
+VALUE pcpeasy_metric_semantics_unknown;
+
+static VALUE initialize(VALUE self, VALUE name, VALUE value, VALUE instance, VALUE semantics) {
+    rb_iv_set(self, "@name", name);
+    rb_iv_set(self, "@value", value);
+    rb_iv_set(self, "@instance", instance);
+    rb_iv_set(self, "@semantics", semantics);
+
+    return self;
+}
+
+static VALUE semantics_symbol(int semantics) {
+    switch(semantics) {
+        case PM_SEM_COUNTER:
+            return pcpeasy_metric_semantics_counter;
+        case PM_SEM_DISCRETE:
+            return pcpeasy_metric_semantics_discrete;
+        case PM_SEM_INSTANT:
+            return pcpeasy_metric_semantics_instant;
+        default:
+            return pcpeasy_metric_semantics_unknown;
+    }
+}
+
+static VALUE instance_name(char *instance) {
+    if(instance == NULL) {
+        return Qnil;
+    }
+    return rb_tainted_str_new_cstr(instance);
+}
+
+static VALUE value(int value_format, pmValue *pm_value, int type) {
+    pmAtomValue pm_atom_value;
+    int error;
+
+    if((error = pmExtractValue(value_format, pm_value, type, &pm_atom_value, type)) < 0) {
+        pcpeasy_raise_from_pmapi_error(error);
+    }
+
+    switch(type) {
+        case PM_TYPE_32:
+            return LONG2NUM(pm_atom_value.l);
+        case PM_TYPE_U32:
+            return ULONG2NUM(pm_atom_value.ul);
+        case PM_TYPE_64:
+            return LL2NUM(pm_atom_value.ll);
+        case PM_TYPE_U64:
+            return ULL2NUM(pm_atom_value.ull);
+        case PM_TYPE_FLOAT:
+            return DBL2NUM(pm_atom_value.f);
+        case PM_TYPE_DOUBLE:
+            return DBL2NUM(pm_atom_value.d);
+        case PM_TYPE_STRING:
+            return rb_tainted_str_new_cstr(pm_atom_value.vbp->vbuf);
+        default:
+            rb_raise(pcpeasy_error, "Metric type %d not supported", type);
+    }
+}
+
+static int is_field_equal(const char *name, VALUE self, VALUE other) {
+    return TYPE(rb_funcall(rb_iv_get(self, name), rb_intern("=="), 1, rb_iv_get(other, name))) == T_TRUE;
+}
+
+static VALUE equal(VALUE self, VALUE other) {
+    if(rb_class_of(other) != pcpeasy_metric_class)
+        return Qfalse;
+    if(!is_field_equal("@name", self, other))
+        return Qfalse;
+    if(!is_field_equal("@value", self, other))
+        return Qfalse;
+    if(!is_field_equal("@instance", self, other))
+        return Qfalse;
+    if(!is_field_equal("@semantics", self, other))
+        return Qfalse;
+
+    return Qtrue;
+}
+
+VALUE pcpeasy_metric_new(char *metric_name, char *instance, pmValue *pm_value, pmDesc *pm_desc, int value_format) {
+    VALUE args[CONSTRUCTOR_ARGS];
+    args[0] = rb_tainted_str_new_cstr(metric_name);
+    args[1] = value(value_format, pm_value, pm_desc->type);
+    args[2] = instance_name(instance);
+    args[3] = semantics_symbol(pm_desc->sem);
+
+    return rb_class_new_instance(CONSTRUCTOR_ARGS, args, pcpeasy_metric_class);
+}
+
+void pcpeasy_metric_init(VALUE pcpeasy_class) {
+    pcpeasy_metric_class = rb_define_class_under(pcpeasy_class, "Metric", rb_cObject);
+
+    pcpeasy_metric_semantics_counter = ID2SYM(rb_intern("counter"));
+    pcpeasy_metric_semantics_discrete = ID2SYM(rb_intern("discrete"));
+    pcpeasy_metric_semantics_instant = ID2SYM(rb_intern("instant"));
+    pcpeasy_metric_semantics_unknown = ID2SYM(rb_intern("unknown"));
+
+    rb_define_method(pcpeasy_metric_class, "initialize", initialize, CONSTRUCTOR_ARGS);
+    rb_define_method(pcpeasy_metric_class, "==", equal, 1);
+    rb_define_attr(pcpeasy_metric_class, "name", READ_ONLY);
+    rb_define_attr(pcpeasy_metric_class, "value", READ_ONLY);
+    rb_define_attr(pcpeasy_metric_class, "instance", READ_ONLY);
+    rb_define_attr(pcpeasy_metric_class, "semantics", READ_ONLY);
+}

data/ext/pcp_easy/metric.h

@@ -0,0 +1,28 @@
+/*
+ * Copyright (C) 2016 Ryan Doyle
+ *
+ * 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/>.
+ *
+ */
+
+#ifndef PCPEASY_RUBY_METRIC_H
+#define PCPEASY_RUBY_METRIC_H 1
+
+#include <ruby.h>
+#include <pcp/pmapi.h>
+
+void pcpeasy_metric_init(VALUE pcpeasy_class);
+VALUE pcpeasy_metric_new(char *metric_name, char *instance, pmValue *pm_value, pmDesc *pm_desc, int value_format);
+
+#endif

data/ext/pcp_easy/pcp_easy.c

@@ -0,0 +1,181 @@
+/*
+ * Copyright (C) 2016 Ryan Doyle
+ *
+ * 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 <ruby.h>
+#include <pcp/pmapi.h>
+
+#include "exceptions.h"
+#include "metric.h"
+
+VALUE pcpeasy_class = Qnil;
+VALUE pcpeasy_agent_class = Qnil;
+
+
+typedef struct {
+    int pm_context;
+} PcpEasyAgent;
+
+static void pcpeasy_agent_deallocate(void *untyped_pcpeasy_agent) {
+    PcpEasyAgent *pcpqz_agent = (PcpEasyAgent*)untyped_pcpeasy_agent;
+    pmDestroyContext(pcpqz_agent->pm_context);
+    xfree(pcpqz_agent);
+}
+
+static VALUE pcpeasy_agent_allocate(VALUE self) {
+    PcpEasyAgent *pcpeasy_agent;
+    return Data_Make_Struct(self, PcpEasyAgent, 0, pcpeasy_agent_deallocate, pcpeasy_agent);
+};
+
+static VALUE pcpeasy_agent_initialize(VALUE self, VALUE hostname_rb) {
+    PcpEasyAgent *pcpeasy_agent;
+    const char *hostname;
+    int pm_context;
+
+    Data_Get_Struct(self, PcpEasyAgent, pcpeasy_agent);
+    hostname = StringValueCStr(hostname_rb);
+
+    if((pm_context = pmNewContext(PM_CONTEXT_HOST, hostname)) < 0) {
+        pcpeasy_raise_from_pmapi_error(pm_context);
+    }
+
+    rb_iv_set(self, "@host", hostname_rb);
+
+    /* Store away with this instance */
+    pcpeasy_agent->pm_context = pm_context;
+
+    return self;
+}
+
+static char* get_name_from_instance_id(int instance_id, int maximum_instances, int *instance_ids, char **instance_names) {
+    int i;
+    for(i=0; i<maximum_instances; i++) {
+        if(instance_id == instance_ids[i]) {
+            return instance_names[i];
+        }
+    }
+    return NULL;
+}
+
+static VALUE decode_multiple_instances(pmDesc pm_desc, pmValueSet *pm_value_set, char *metric_name) {
+    int error, i;
+    int number_of_instances = pm_value_set->numval;
+    int *instances = NULL;
+    char **instance_names = NULL;
+    VALUE result = rb_ary_new2(number_of_instances);
+
+
+    if((error = pmGetInDom(pm_desc.indom, &instances, &instance_names)) < 0) {
+        pcpeasy_raise_from_pmapi_error(error);
+    }
+
+    for(i = 0; i < number_of_instances; i++) {
+        char *instance_name = get_name_from_instance_id(pm_value_set->vlist[i].inst, number_of_instances, instances, instance_names);
+        rb_ary_push(result, pcpeasy_metric_new(metric_name, instance_name, &pm_value_set->vlist[i], &pm_desc, pm_value_set->valfmt));
+    }
+
+    free(instances);
+    free(instance_names);
+
+    return result;
+}
+
+static VALUE decode_single_instance(pmDesc pm_desc, pmValueSet *pm_value_set, char *metric_name) {
+    return pcpeasy_metric_new(metric_name, NULL, &pm_value_set->vlist[0], &pm_desc, pm_value_set->valfmt);
+}
+
+static VALUE decode_single_metric(pmID pmid, pmValueSet *pm_value_set, char *metric_name) {
+    int error;
+    pmDesc pm_desc;
+
+    /* No values, bail out */
+    if(pm_value_set->numval == 0) {
+        return Qnil;
+    }
+
+    /* Find out how to decode the metric */
+    if((error = pmLookupDesc(pmid, &pm_desc))) {
+        pcpeasy_raise_from_pmapi_error(error);
+    }
+
+    /* Do we have instances? */
+    if(pm_desc.indom == PM_INDOM_NULL) {
+        return decode_single_instance(pm_desc, pm_value_set, metric_name);
+    } else {
+        return decode_multiple_instances(pm_desc, pm_value_set, metric_name);
+    }
+
+}
+
+static VALUE decode_pm_result(pmID pmid, pmResult *pm_result, char *metric_name) {
+    /* No values (or somehow more than 1) */
+    if (pm_result->numpmid != 1) {
+        return Qnil;
+    }
+
+    return decode_single_metric(pmid, pm_result->vset[0], metric_name);
+}
+
+static VALUE pcpeasy_agent_metric(VALUE self, VALUE metric_string_rb) {
+    /* Get our context */
+    PcpEasyAgent *pcpeasy_agent;
+    Data_Get_Struct(self, PcpEasyAgent, pcpeasy_agent);
+    pmUseContext(pcpeasy_agent->pm_context);
+
+    /* Get the pmID */
+    int error;
+    pmID pmid;
+    pmID *pmid_list = ALLOC(pmID);
+    char **metric_list = ALLOC(char*);
+    char *metric_name = StringValueCStr(metric_string_rb);
+    metric_list[0] = metric_name;
+    if((error = pmLookupName(1, metric_list, pmid_list)) < 0) {
+        xfree(pmid_list);
+        xfree(metric_list);
+        pcpeasy_raise_from_pmapi_error(error);
+    }
+    pmid = pmid_list[0];
+    xfree(pmid_list);
+    xfree(metric_list);
+
+
+    /* Do the fetch */
+    pmResult *pm_result;
+    VALUE result;
+    if((error = pmFetch(1, &pmid, &pm_result))) {
+        pcpeasy_raise_from_pmapi_error(error);
+    }
+
+    /* Decode the result */
+    result = decode_pm_result(pmid, pm_result, metric_name);
+    pmFreeResult(pm_result);
+
+    return result;
+}
+
+void Init_pcp_easy() {
+    pcpeasy_class = rb_define_module("PCPEasy");
+    pcpeasy_agent_class = rb_define_class_under(pcpeasy_class, "Agent", rb_cObject);
+    pcpeasy_exceptions_init(pcpeasy_class);
+    pcpeasy_metric_init(pcpeasy_class);
+
+    rb_define_alloc_func(pcpeasy_agent_class, pcpeasy_agent_allocate);
+    rb_define_method(pcpeasy_agent_class, "initialize", pcpeasy_agent_initialize, 1);
+    rb_define_method(pcpeasy_agent_class, "metric", pcpeasy_agent_metric, 1);
+    rb_define_attr(pcpeasy_agent_class, "host", 1, 0);
+
+}

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification
+name: pcp_easy
+version: !ruby/object:Gem::Version
+  version: 0.0.3
+platform: ruby
+authors:
+- Ryan Doyle
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-03-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email: 
+executables: []
+extensions:
+- ext/pcp_easy/extconf.rb
+extra_rdoc_files: []
+files:
+- ext/pcp_easy/exceptions.c
+- ext/pcp_easy/exceptions.h
+- ext/pcp_easy/extconf.rb
+- ext/pcp_easy/metric.c
+- ext/pcp_easy/metric.h
+- ext/pcp_easy/pcp_easy.c
+homepage: 
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Simple query interface for Performance Co-Pilot
+test_files: []