pcp_easy 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7b7da9cf7cc2a13ab9973f7c94b5d95eaf31c351
-  data.tar.gz: dd9a83a80fa8ee7614900ee4be39877d26d66682
+  metadata.gz: 21fceb6ebc1d01718e444441471d809eb0e6ccb5
+  data.tar.gz: 2781fbf13fbc283b8eca04db991aaacb48fe1d1e
 SHA512:
-  metadata.gz: 6527fe6f2b9fd4ce89a081db47b6b358cd0dbf4132543f76d1903313a8fe8849e4c440d6067f8e61ee5567396f67f290c6e903c22728b20f0d79de7293af31d7
-  data.tar.gz: 4eb8144063b44ad94807c7134331195913294f38573c3668462f3db3666ca477f2c29609076faf5a6cac533b0fc16a1afc561298d99645cc53fbc69d51586234
+  metadata.gz: 999efdb3455919f84d53a64cabeb2ae52465eb80b7163c889de09c27dbfba4137057413f3ea147a2bd82fb0beb3ca455aee67f7458f74c69d59669b82decfab0
+  data.tar.gz: 5a8915017b4d16586227255d48a9b38346b71ebc94c7872265416bc1e7f74efb71f3cb54542fbede0a86db07f1b40523f17f0700605dd6bfd6b04f5812c2ad84

data/lib/pcp_easy.rb

@@ -0,0 +1,11 @@
+module PCPEasy; end
+require 'pcp_easy/error'
+require 'pcp_easy/pmapi'
+require 'pcp_easy/agent'
+require 'pcp_easy/metric'
+require 'pcp_easy/metric/value'
+require 'pcp_easy/pmapi/pm_value_set'
+require 'pcp_easy/pmapi/pm_result'
+require 'pcp_easy/pmapi/pm_value'
+require 'pcp_easy/pmapi/timeval'
+require 'pcp_easy/pmapi/pm_atom_value'

data/lib/pcp_easy/agent.rb

@@ -0,0 +1,58 @@
+require 'pcp_easy/pmapi'
+
+module PCPEasy
+  class Agent
+
+    attr_reader :host
+
+    def initialize(host)
+      @host = host
+    end
+
+    def metric(name)
+      metrics([name]).first
+    end
+
+    def metrics(names)
+      raise ArgumentError, "array required for metrics" unless names.is_a? Array
+      pmids = pmapi.pmLookupName(names)
+      pmids_names = Hash[pmids.zip(names)]
+      pmapi.pmFetch(pmids).vset.collect {|v| metric_from_vset(v, pmids_names)}
+    end
+
+    private
+
+    def metric_from_vset(pm_value_set, pmid_names)
+      pm_desc = pmapi.pmLookupDesc pm_value_set.pmid
+      name = pmid_names[pm_value_set.pmid]
+
+      if pm_desc.indom == PCPEasy::PMAPI::PM_INDOM_NULL
+        metric_values = metric_value_for_no_indom(pm_value_set, pm_desc)
+      else
+        metric_values = metric_value_for_indoms(pm_value_set, pm_desc)
+      end
+      PCPEasy::Metric.new(name, pm_desc, metric_values)
+    end
+
+    def metric_value_for_no_indom(pm_value_set, pm_desc)
+      value = pmapi.pmExtractValue(pm_value_set.valfmt, pm_desc, pm_value_set.vlist.first)
+      [PCPEasy::Metric::Value.new(value, nil)]
+    end
+
+    def metric_value_for_indoms(pm_value_set, pm_desc)
+      indoms = pmapi.pmGetInDom(pm_desc.indom)
+      pm_value_set.vlist.collect do |v|
+        value = pmapi.pmExtractValue(pm_value_set.valfmt, pm_desc, v)
+        PCPEasy::Metric::Value.new(value, indoms[v.inst])
+      end
+    end
+
+
+
+    def pmapi
+      @pmapi ||= PCPEasy::PMAPI.new(@host)
+    end
+
+  end
+end
+

data/lib/pcp_easy/error.rb

@@ -0,0 +1,120 @@
+require 'pcp_easy/pmapi'
+
+
+module PCPEasy
+  class Error < StandardError
+
+    GenericError = Class.new(self)
+    PMNSError = Class.new(self)
+    NoPMNSError = Class.new(self)
+    DupPMNSError = Class.new(self)
+    TextError = Class.new(self)
+    AppVersionError = Class.new(self)
+    ValueError = Class.new(self)
+    TimeoutError = Class.new(self)
+    NoDataError = Class.new(self)
+    ResetError = Class.new(self)
+    NameError = Class.new(self)
+    PMIDError = Class.new(self)
+    InDomError  = Class.new(self)
+    InstError  = Class.new(self)
+    UnitError  = Class.new(self)
+    ConvError  = Class.new(self)
+    TruncError  = Class.new(self)
+    SignError  = Class.new(self)
+    ProfileError  = Class.new(self)
+    IPCError = Class.new(self)
+    EOFError = Class.new(self)
+    NotHostError = Class.new(self)
+    EOLError = Class.new(self)
+    ModeError = Class.new(self)
+    LabelError = Class.new(self)
+    LogRecError = Class.new(self)
+    NotArchiveError = Class.new(self)
+    LogFileError = Class.new(self)
+    NoContextError = Class.new(self)
+    ProfileSpecError = Class.new(self)
+    PMIDLogError = Class.new(self)
+    InDomLogError = Class.new(self)
+    InstLogError = Class.new(self)
+    NoProfileError = Class.new(self)
+    NoAgentError = Class.new(self)
+    PermissionError = Class.new(self)
+    ConnLimitError = Class.new(self)
+    AgainError = Class.new(self)
+    IsConnError = Class.new(self)
+    NotConnError = Class.new(self)
+    NeedPortError = Class.new(self)
+    NonLeafError = Class.new(self)
+    TypeError = Class.new(self)
+    ThreadError = Class.new(self)
+    NoContainerError = Class.new(self)
+    BadStoreError = Class.new(self)
+    TooSmallError = Class.new(self)
+    TooBigError = Class.new(self)
+    FaultError = Class.new(self)
+    PMDAReadyError = Class.new(self)
+    PMDANotReadyError = Class.new(self)
+    NYIError = Class.new(self)
+
+    ERRORS = {
+        PCPEasy::PMAPI::PM_ERR_GENERIC => GenericError,
+        PCPEasy::PMAPI::PM_ERR_PMNS => PMNSError,
+        PCPEasy::PMAPI::PM_ERR_NOPMNS => NoPMNSError,
+        PCPEasy::PMAPI::PM_ERR_DUPPMNS=> DupPMNSError,
+        PCPEasy::PMAPI::PM_ERR_TEXT => TextError,
+        PCPEasy::PMAPI::PM_ERR_APPVERSION => AppVersionError,
+        PCPEasy::PMAPI::PM_ERR_VALUE => ValueError,
+        PCPEasy::PMAPI::PM_ERR_TIMEOUT => TimeoutError,
+        PCPEasy::PMAPI::PM_ERR_NODATA => NoDataError,
+        PCPEasy::PMAPI::PM_ERR_RESET=> ResetError,
+        PCPEasy::PMAPI::PM_ERR_NAME => NameError,
+        PCPEasy::PMAPI::PM_ERR_PMID => PMIDError,
+        PCPEasy::PMAPI::PM_ERR_INDOM => InDomError,
+        PCPEasy::PMAPI::PM_ERR_INST => InstError,
+        PCPEasy::PMAPI::PM_ERR_UNIT => UnitError,
+        PCPEasy::PMAPI::PM_ERR_CONV => ConvError,
+        PCPEasy::PMAPI::PM_ERR_CONV => TruncError,
+        PCPEasy::PMAPI::PM_ERR_SIGN => SignError,
+        PCPEasy::PMAPI::PM_ERR_PROFILE => ProfileError,
+        PCPEasy::PMAPI::PM_ERR_IPC => IPCError,
+        PCPEasy::PMAPI::PM_ERR_EOF => EOFError,
+        PCPEasy::PMAPI::PM_ERR_NOTHOST => NotHostError,
+        PCPEasy::PMAPI::PM_ERR_EOL => EOLError,
+        PCPEasy::PMAPI::PM_ERR_MODE => ModeError,
+        PCPEasy::PMAPI::PM_ERR_LABEL => LabelError,
+        PCPEasy::PMAPI::PM_ERR_LOGREC => LogRecError,
+        PCPEasy::PMAPI::PM_ERR_NOTARCHIVE => NotArchiveError,
+        PCPEasy::PMAPI::PM_ERR_LOGFILE => LogFileError,
+        PCPEasy::PMAPI::PM_ERR_NOCONTEXT => NoContextError,
+        PCPEasy::PMAPI::PM_ERR_PROFILESPEC => ProfileSpecError,
+        PCPEasy::PMAPI::PM_ERR_PMID_LOG => PMIDLogError,
+        PCPEasy::PMAPI::PM_ERR_INDOM_LOG => InDomLogError,
+        PCPEasy::PMAPI::PM_ERR_INST_LOG => InstLogError,
+        PCPEasy::PMAPI::PM_ERR_NOPROFILE => NoProfileError,
+        PCPEasy::PMAPI::PM_ERR_NOAGENT => NoAgentError,
+        PCPEasy::PMAPI::PM_ERR_PERMISSION => PermissionError,
+        PCPEasy::PMAPI::PM_ERR_CONNLIMIT => ConnLimitError,
+        PCPEasy::PMAPI::PM_ERR_AGAIN => AgainError,
+        PCPEasy::PMAPI::PM_ERR_ISCONN => IsConnError,
+        PCPEasy::PMAPI::PM_ERR_NOTCONN => NotConnError,
+        PCPEasy::PMAPI::PM_ERR_NEEDPORT => NeedPortError,
+        PCPEasy::PMAPI::PM_ERR_NONLEAF => NonLeafError,
+        PCPEasy::PMAPI::PM_ERR_TYPE => TypeError,
+        PCPEasy::PMAPI::PM_ERR_THREAD => ThreadError,
+        PCPEasy::PMAPI::PM_ERR_NOCONTAINER => NoContainerError,
+        PCPEasy::PMAPI::PM_ERR_BADSTORE => BadStoreError,
+        PCPEasy::PMAPI::PM_ERR_TOOSMALL => TooSmallError,
+        PCPEasy::PMAPI::PM_ERR_TOOBIG => TooBigError,
+        PCPEasy::PMAPI::PM_ERR_FAULT => FaultError,
+        PCPEasy::PMAPI::PM_ERR_PMDAREADY => PMDAReadyError,
+        PCPEasy::PMAPI::PM_ERR_PMDANOTREADY => PMDANotReadyError,
+        PCPEasy::PMAPI::PM_ERR_NYI => NYIError,
+    }
+
+    def self.from_pmapi_error_number(number)
+      error_class = ERRORS[number] ||= self
+      error_class.new PMAPI.pmErrStr(number)
+    end
+  end
+end

data/lib/pcp_easy/metric.rb

@@ -0,0 +1,153 @@
+require 'pcp_easy/pmapi'
+
+module PCPEasy
+  class Metric
+
+    def initialize(name, pm_desc, metric_values)
+      @name = name
+      @pm_desc = pm_desc
+      @metric_values = metric_values
+    end
+
+    def name
+      @name
+    end
+
+    def values
+      @metric_values
+    end
+
+    def ==(other)
+      self.class == other.class && \
+      name == other.name && \
+      values == other.values && \
+      semantics == other.semantics && \
+      type == other.type && \
+      units == other.units
+    end
+
+    def semantics
+      case @pm_desc.sem
+        when PCPEasy::PMAPI::PM_SEM_COUNTER
+          :counter
+        when PCPEasy::PMAPI::PM_SEM_INSTANT
+          :instant
+        when PCPEasy::PMAPI::PM_SEM_DISCRETE
+          :discrete
+        else
+          :unknown
+      end
+    end
+
+
+    def type
+      case @pm_desc.type
+        when PCPEasy::PMAPI::PM_TYPE_NOSUPPORT
+          :no_support
+        when PCPEasy::PMAPI::PM_TYPE_32
+          :int32
+        when PCPEasy::PMAPI::PM_TYPE_U32
+          :uint32
+        when PCPEasy::PMAPI::PM_TYPE_64
+          :int64
+        when PCPEasy::PMAPI::PM_TYPE_U64
+          :uint64
+        when PCPEasy::PMAPI::PM_TYPE_FLOAT
+          :float
+        when PCPEasy::PMAPI::PM_TYPE_DOUBLE
+          :double
+        when PCPEasy::PMAPI::PM_TYPE_STRING
+          :string
+        when PCPEasy::PMAPI::PM_TYPE_AGGREGATE
+          :aggregate
+        when PCPEasy::PMAPI::PM_TYPE_AGGREGATE_STATIC
+          :aggregate_static
+        when PCPEasy::PMAPI::PM_TYPE_EVENT
+          :event
+        when PCPEasy::PMAPI::PM_TYPE_HIGHRES_EVENT
+          :highres_event
+        else
+          :unknown
+      end
+    end
+
+    def units
+      pm_units = @pm_desc.units
+
+      if pm_units.dim_space == 1 && pm_units.dim_time == 0 && pm_units.dim_count == 0
+        {:domain => space_unit(pm_units.scale_space), :range => nil}
+      elsif pm_units.dim_space == 1 && pm_units.dim_time == -1 && pm_units.dim_count == 0
+        {:domain => space_unit(pm_units.scale_space), :range => time_unit(pm_units.scale_time)}
+      elsif pm_units.dim_space == 1 && pm_units.dim_time == 0 && pm_units.dim_count == -1
+        {:domain => space_unit(pm_units.scale_space), :range => count_unit(pm_units.scale_count)}
+
+      elsif pm_units.dim_space == 0 && pm_units.dim_time == 1 && pm_units.dim_count == 0
+        {:domain => time_unit(pm_units.scale_time), :range => nil}
+      elsif pm_units.dim_space == -1 && pm_units.dim_time == 1 && pm_units.dim_count == 0
+        {:domain => time_unit(pm_units.scale_time), :range => space_unit(pm_units.scale_space)}
+      elsif pm_units.dim_space == 0 && pm_units.dim_time == 1 && pm_units.dim_count == -1
+        {:domain => time_unit(pm_units.scale_time), :range => count_unit(pm_units.scale_count)}
+
+      elsif pm_units.dim_space == 0 && pm_units.dim_time == 0 && pm_units.dim_count == 1
+        {:domain => count_unit(pm_units.scale_count), :range => nil}
+      elsif pm_units.dim_space == -1 && pm_units.dim_time == 0 && pm_units.dim_count == 1
+        {:domain => count_unit(pm_units.scale_count), :range => space_unit(pm_units.scale_space)}
+      elsif pm_units.dim_space == 0 && pm_units.dim_time == -1 && pm_units.dim_count == 1
+        {:domain => count_unit(pm_units.scale_count), :range => time_unit(pm_units.scale_time)}
+      else
+        {:domain => nil, :range => nil}
+      end
+    end
+
+    def inspect
+      "<#{self.class.to_s} name=#{name} values=#{values} semantics=#{semantics} type=#{type} units=#{units}>"
+    end
+
+    private
+
+    def count_unit(exponent)
+      "count#{exponent}".to_sym
+    end
+
+    def space_unit(unit)
+      case unit
+        when PCPEasy::PMAPI::PM_SPACE_BYTE
+          :bytes
+        when PCPEasy::PMAPI::PM_SPACE_KBYTE
+          :kilobytes
+        when PCPEasy::PMAPI::PM_SPACE_MBYTE
+          :megabytes
+        when PCPEasy::PMAPI::PM_SPACE_GBYTE
+          :gigabytes
+        when PCPEasy::PMAPI::PM_SPACE_TBYTE
+          :terabytes
+        when PCPEasy::PMAPI::PM_SPACE_PBYTE
+          :petabytes
+        when PCPEasy::PMAPI::PM_SPACE_EBYTE
+          :exabytes
+        else
+          nil
+      end
+    end
+
+    def time_unit(unit)
+      case unit
+        when PCPEasy::PMAPI::PM_TIME_NSEC
+          :nanoseconds
+        when PCPEasy::PMAPI::PM_TIME_USEC
+          :microseconds
+        when PCPEasy::PMAPI::PM_TIME_MSEC
+          :milliseconds
+        when PCPEasy::PMAPI::PM_TIME_SEC
+          :seconds
+        when PCPEasy::PMAPI::PM_TIME_MIN
+          :minutes
+        when PCPEasy::PMAPI::PM_TIME_HOUR
+          :hours
+        else
+          nil
+      end
+    end
+
+  end
+end

data/lib/pcp_easy/metric/value.rb

@@ -0,0 +1,19 @@
+module PCPEasy; class Metric
+  class Value
+
+    attr_reader :value, :instance
+
+    def initialize(value, instance)
+      @value = value
+      @instance = instance
+    end
+
+    def ==(other)
+      self.class == other.class && \
+      value == other.value && \
+      instance == other.instance
+    end
+
+  end
+end
+end

data/lib/pcp_easy/pmapi.rb

@@ -0,0 +1,248 @@
+require 'ffi'
+require 'pcp_easy/error'
+require 'pcp_easy/pmapi/pm_desc'
+require 'pcp_easy/pmapi/pm_result'
+require 'pcp_easy/pmapi/pm_value'
+require 'pcp_easy/pmapi/pm_atom_value'
+
+module PCPEasy
+  module FFIInternal
+    extend FFI::Library
+    ffi_lib 'libpcp.so.3'
+
+    typedef :uint, :pmid
+    typedef :uint, :indom
+
+    attach_function :pmNewContext, [:int, :string], :int
+    attach_function :pmErrStr_r, [:int, :pointer, :int], :string
+    attach_function :pmUseContext, [:int], :void
+    attach_function :pmLookupName, [:int, :pointer, :pointer], :int
+    attach_function :pmLookupDesc, [:pmid, :pointer], :int
+    attach_function :pmDestroyContext, [:int], :int
+    attach_function :pmFetch, [:int, :pointer, :pointer], :int
+    attach_function :pmFreeResult, [:pointer], :void
+    attach_function :pmGetInDom, [:indom, :pointer, :pointer], :int
+    attach_function :pmExtractValue, [:int, PMAPI::PmValue, :int, PMAPI::PmAtomValue, :int], :int
+  end
+  module LibC
+    extend FFI::Library
+    ffi_lib FFI::Library::LIBC
+    attach_function :free, [:pointer], :void
+  end
+
+  class PMAPI
+    extend Forwardable
+
+    PM_CONTEXT_HOST = 1
+
+    PM_MAXERRMSGLEN = 128
+
+    PM_TYPE_NOSUPPORT = -1
+    PM_TYPE_32    = 0
+    PM_TYPE_U32   = 1
+    PM_TYPE_64    = 2
+    PM_TYPE_U64   = 3
+    PM_TYPE_FLOAT   = 4
+    PM_TYPE_DOUBLE  = 5
+    PM_TYPE_STRING  = 6
+    PM_TYPE_AGGREGATE         = 7
+    PM_TYPE_AGGREGATE_STATIC  = 8
+    PM_TYPE_EVENT   = 9
+    PM_TYPE_HIGHRES_EVENT = 10
+    PM_TYPE_UNKNOWN	      = 255
+
+    PM_VAL_INSITU	= 0
+    PM_VAL_DPTR	= 1
+    PM_VAL_SPTR	= 2
+
+
+    PM_INDOM_NULL	= 0xffffffff
+
+    PM_SEM_COUNTER  = 1
+    PM_SEM_INSTANT  = 3
+    PM_SEM_DISCRETE = 4
+
+    PM_SPACE_BYTE = 0
+    PM_SPACE_KBYTE = 1
+    PM_SPACE_MBYTE = 2
+    PM_SPACE_GBYTE = 3
+    PM_SPACE_TBYTE = 4
+    PM_SPACE_PBYTE = 5
+    PM_SPACE_EBYTE = 6
+
+    PM_TIME_NSEC = 0
+    PM_TIME_USEC = 1
+    PM_TIME_MSEC = 2
+    PM_TIME_SEC = 3
+    PM_TIME_MIN = 4
+    PM_TIME_HOUR = 5
+
+    PM_COUNT_ONE = 0
+
+    PM_ERR_BASE2 = 12345
+    PM_ERR_BASE = PM_ERR_BASE2
+
+    PM_ERR_GENERIC = (-PM_ERR_BASE-0)
+    PM_ERR_PMNS = (-PM_ERR_BASE-1)
+    PM_ERR_NOPMNS = (-PM_ERR_BASE-2)
+    PM_ERR_DUPPMNS = (-PM_ERR_BASE-3)
+    PM_ERR_TEXT = (-PM_ERR_BASE-4)
+    PM_ERR_APPVERSION = (-PM_ERR_BASE-5)
+    PM_ERR_VALUE = (-PM_ERR_BASE-6)
+    PM_ERR_TIMEOUT = (-PM_ERR_BASE-8)
+    PM_ERR_NODATA = (-PM_ERR_BASE-9)
+    PM_ERR_RESET = (-PM_ERR_BASE-10)
+    PM_ERR_NAME	= (-PM_ERR_BASE-12)
+    PM_ERR_PMID	= (-PM_ERR_BASE-13)
+    PM_ERR_INDOM = (-PM_ERR_BASE-14)
+    PM_ERR_INST	= (-PM_ERR_BASE-15)
+    PM_ERR_UNIT = (-PM_ERR_BASE-16)
+    PM_ERR_CONV = (-PM_ERR_BASE-17)
+    PM_ERR_TRUNC = (-PM_ERR_BASE-18)
+    PM_ERR_SIGN = (-PM_ERR_BASE-19)
+    PM_ERR_PROFILE = (-PM_ERR_BASE-20)
+    PM_ERR_IPC = (-PM_ERR_BASE-21)
+    PM_ERR_EOF = (-PM_ERR_BASE-23)
+    PM_ERR_NOTHOST = (-PM_ERR_BASE-24)
+    PM_ERR_EOL = (-PM_ERR_BASE-25)
+    PM_ERR_MODE = (-PM_ERR_BASE-26)
+    PM_ERR_LABEL = (-PM_ERR_BASE-27)
+    PM_ERR_LOGREC = (-PM_ERR_BASE-28)
+    PM_ERR_NOTARCHIVE	= (-PM_ERR_BASE-29)
+    PM_ERR_LOGFILE = (-PM_ERR_BASE-30)
+    PM_ERR_NOCONTEXT = (-PM_ERR_BASE-31)
+    PM_ERR_PROFILESPEC = (-PM_ERR_BASE-32)
+    PM_ERR_PMID_LOG = (-PM_ERR_BASE-33)
+    PM_ERR_INDOM_LOG = (-PM_ERR_BASE-34)
+    PM_ERR_INST_LOG = (-PM_ERR_BASE-35)
+    PM_ERR_NOPROFILE = (-PM_ERR_BASE-36)
+    PM_ERR_NOAGENT = (-PM_ERR_BASE-41)
+    PM_ERR_PERMISSION = (-PM_ERR_BASE-42)
+    PM_ERR_CONNLIMIT = (-PM_ERR_BASE-43)
+    PM_ERR_AGAIN = (-PM_ERR_BASE-44)
+    PM_ERR_ISCONN = (-PM_ERR_BASE-45)
+    PM_ERR_NOTCONN = (-PM_ERR_BASE-46)
+    PM_ERR_NEEDPORT = (-PM_ERR_BASE-47)
+    PM_ERR_NONLEAF = (-PM_ERR_BASE-49)
+    PM_ERR_TYPE	= (-PM_ERR_BASE-52)
+    PM_ERR_THREAD = (-PM_ERR_BASE-53)
+    PM_ERR_NOCONTAINER = (-PM_ERR_BASE-54)
+    PM_ERR_BADSTORE = (-PM_ERR_BASE-55)
+    PM_ERR_TOOSMALL = (-PM_ERR_BASE-98)
+    PM_ERR_TOOBIG = (-PM_ERR_BASE-99)
+    PM_ERR_FAULT = (-PM_ERR_BASE-100)
+    PM_ERR_PMDAREADY = (-PM_ERR_BASE-1048)
+    PM_ERR_PMDANOTREADY = (-PM_ERR_BASE-1049)
+    PM_ERR_NYI = (-PM_ERR_BASE-8999)
+
+
+    def_delegator self, :pmExtractValue
+
+    def initialize(host)
+      @context = FFIInternal.pmNewContext PM_CONTEXT_HOST, host
+      raise PCPEasy::Error.from_pmapi_error_number(@context) if @context < 0
+      ObjectSpace.define_finalizer(self, self.class.finalize(@context) )
+    end
+
+    def self.pmErrStr(number)
+      buffer = FFI::MemoryPointer.new(:char, PM_MAXERRMSGLEN)
+      FFIInternal.pmErrStr_r number, buffer, PM_MAXERRMSGLEN
+    end
+
+    def pmLookupName(names)
+      pmUseContext
+
+      names_ptr = FFI::MemoryPointer.new(:pointer, names.size)
+      names_ptr.write_array_of_pointer names.collect {|n| FFI::MemoryPointer.from_string n}
+      pmid_ptr = FFI::MemoryPointer.new(:uint, names.size)
+
+      error_code = FFIInternal.pmLookupName names.size, names_ptr, pmid_ptr
+      raise PCPEasy::Error.from_pmapi_error_number(error_code) if error_code < 0
+
+      pmid_ptr.get_array_of_uint 0, names.size
+    end
+
+    def pmLookupDesc(pmid)
+      pmUseContext
+
+      pm_desc = PCPEasy::PMAPI::PmDesc.new
+      error_code = FFIInternal.pmLookupDesc(pmid, pm_desc.to_ptr)
+      raise PCPEasy::Error.from_pmapi_error_number(error_code) if error_code < 0
+
+      pm_desc
+    end
+
+    def pmFetch(pmids)
+      pmUseContext
+
+      pmids_ptr = FFI::MemoryPointer.new(:uint, pmids.size)
+      pmids_ptr.write_array_of_uint pmids
+      pm_result_ptr = FFI::MemoryPointer.new :pointer
+
+      error_code = FFIInternal.pmFetch(pmids.size, pmids_ptr, pm_result_ptr)
+      raise PCPEasy::Error.from_pmapi_error_number(error_code) if error_code < 0
+
+      pm_result_ptr = FFI::AutoPointer.new(pm_result_ptr.get_pointer(0), FFIInternal.method(:pmFreeResult))
+
+      PCPEasy::PMAPI::PmResult.new(pm_result_ptr)
+    end
+
+    def pmGetInDom(indom)
+      pmUseContext
+
+      internal_ids = FFI::MemoryPointer.new :pointer
+      external_names = FFI::MemoryPointer.new :pointer
+
+      error_or_num_results = FFIInternal.pmGetInDom indom, internal_ids, external_names
+      raise PCPEasy::Error.from_pmapi_error_number(error_or_num_results) if error_or_num_results < 0
+
+      ids = internal_ids.get_pointer(0).get_array_of_int(0, error_or_num_results)
+      names = external_names.get_pointer(0).get_array_of_string(0, error_or_num_results)
+      Hash[ids.zip(names)]
+    end
+
+    def self.pmExtractValue(value_format, pm_desc, pm_value)
+
+      atom = PCPEasy::PMAPI::PmAtomValue.new
+      error_code = FFIInternal.pmExtractValue(value_format, pm_value.pointer, pm_desc.type, atom.pointer, pm_desc.type)
+      raise PCPEasy::Error.from_pmapi_error_number(error_code) if error_code < 0
+
+      case pm_desc.type
+        when PM_TYPE_32
+          atom.l
+        when PM_TYPE_U32
+          atom.ul
+        when PM_TYPE_64
+          atom.ll
+        when PM_TYPE_U64
+          atom.ull
+        when PM_TYPE_FLOAT
+          atom.f
+        when PM_TYPE_DOUBLE
+          atom.d
+        when PM_TYPE_STRING
+          str = atom.cp.read_string
+          LibC.free(atom.cp) if atom.cp
+          str
+        when PM_TYPE_AGGREGATE || PM_TYPE_EVENT || PM_TYPE_HIGHRES_EVENT
+          # No support, make sure we free the pointer
+          LibC.free(atom.vbp) if atom.vbp
+          raise PCPEasy::Error.new "Metric type #{pm_desc.type} not supported"
+        else
+          raise ArgumentError.new "Type #{pm_desc.type} not valid"
+      end
+    end
+
+    private
+
+    def pmUseContext
+      FFIInternal.pmUseContext @context
+    end
+
+    def self.finalize(context)
+      proc { FFIInternal.pmDestroyContext(context) }
+    end
+
+  end
+
+end