xymonclient 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 53c615d0c431bab59303f6e27d944dc89b2f8f3c
+  data.tar.gz: d279ec888695080dd90901dd5c3a2230c37b95f6
+SHA512:
+  metadata.gz: bed8acb18cdbb7b3c1dc5ce9c381433c3138fc142637e4a2456b14f1fb15f0a25e8b8f4505a257a2c35ce17b7dca38e2561b8a78ee634cbbe72d820fc748b33e
+  data.tar.gz: 24a02a76ebaff377408a6423f127050a27ec416bcf2c3c6d7c638a31e421833ec4321c79d530b4120946251201100e5c361e25e168f03a6c637d3a88cca36a38

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in xymonclient.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,60 @@
+PATH
+  remote: .
+  specs:
+    xymonclient (0.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ast (2.3.0)
+    codeclimate-test-reporter (1.0.3)
+      simplecov
+    diff-lcs (1.2.5)
+    docile (1.1.5)
+    json (2.0.2-java)
+    parser (2.3.1.4)
+      ast (~> 2.2)
+    powerpack (0.1.1)
+    rainbow (2.1.0)
+    rake (10.5.0)
+    rspec (3.5.0)
+      rspec-core (~> 3.5.0)
+      rspec-expectations (~> 3.5.0)
+      rspec-mocks (~> 3.5.0)
+    rspec-core (3.5.4)
+      rspec-support (~> 3.5.0)
+    rspec-expectations (3.5.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.5.0)
+    rspec-mocks (3.5.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.5.0)
+    rspec-support (3.5.0)
+    rubocop (0.40.0)
+      parser (>= 2.3.1.0, < 3.0)
+      powerpack (~> 0.1)
+      rainbow (>= 1.99.1, < 3.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (~> 1.0, >= 1.0.1)
+    ruby-progressbar (1.8.1)
+    simplecov (0.12.0)
+      docile (~> 1.1.0)
+      json (>= 1.8, < 3)
+      simplecov-html (~> 0.10.0)
+    simplecov-html (0.10.0)
+    unicode-display_width (1.1.1)
+
+PLATFORMS
+  java
+
+DEPENDENCIES
+  bundler (~> 1.13)
+  codeclimate-test-reporter (~> 1.0)
+  rake (~> 10.0)
+  rspec (~> 3.0)
+  rubocop (= 0.40)
+  simplecov (~> 0.12.0)
+  xymonclient!
+
+BUNDLED WITH
+   1.13.6

data/LICENSE

@@ -0,0 +1,13 @@
+Copyright 2016 Orange <http://orange.com>
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.

data/README.md

@@ -0,0 +1,85 @@
+[![Gem Version](https://badge.fury.io/rb/xymonclient.svg)](https://badge.fury.io/rb/xymonclient)
+[![Build Status](https://travis-ci.org/dchauviere/ruby-xymonclient.svg?branch=master)](https://travis-ci.org/dchauviere/ruby-xymonclient)
+[![Code Climate](https://codeclimate.com/github/dchauviere/ruby-xymonclient/badges/gpa.svg)](https://codeclimate.com/github/dchauviere/ruby-xymonclient)
+<a href="https://codeclimate.com/github/dchauviere/ruby-xymonclient/coverage"><img src="https://codeclimate.com/github/dchauviere/ruby-xymonclient/badges/coverage.svg" /></a>
+# XymonClient
+
+XymonClient is a ruby library for interacting with Xymon
+
+Features:
+ * Send status
+ * Ack
+ * Enable/Disable
+ * Helper Class 'Service' for building sensors easily
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'xymonclient'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install xymonclient
+
+## Usage
+
+### Basic usage
+```ruby
+require 'xymonclient'
+
+client = XymonClient::Client.new(['localhost:1984'])
+client.status('myhost', 'service1', 'green', 'additional data')
+
+```
+
+### Service wrapper
+```ruby
+require 'xymonclient/service'
+
+service = XymonClient::Service.new(['localhost:1984'],
+  'name' => 'service1',
+  'host' => 'myhost',
+  'header' => 'A sample header',
+  'footer' => 'A sample footer',
+  'items' => {
+    'ITEM1' => {
+      'label' => 'Gauge Item 1',
+      'type' => 'gauge',
+      'threshold' => {
+        'order' => '<',
+        'critical' => 5,
+        'warning' => 10,
+        'nan_status' => 'red'
+      }
+    },
+    'ITEM2' => {
+      'label' => 'String Item 2',
+      'type' => 'string',
+      'threshold' => {
+        'inclusive' => false,
+        'critical' => ['all is Ok !']
+      }
+    }
+  }
+)
+service.update_item('ITEM1', 3)
+service.update_item('ITEM2', 'all is Ok !')
+service.status
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/dchauviere/xymonclient.

data/Rakefile

@@ -0,0 +1,6 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'xymonclient'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require 'irb'
+IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/xymonclient/discovery.rb

@@ -0,0 +1,23 @@
+require 'xymonclient/exception'
+
+module XymonClient
+  ##
+  # static methods of servers discovery
+  class ServerDiscovery
+    def find_from_file(file = '/etc/xymon/xymonclient.cfg')
+      result = []
+      open(file, 'r').read.each_line do |line|
+        next unless line =~ /^XYMSRV=/ || line =~ /^XYMSERVERS=/
+        ip = line.scan(/[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}/)
+        if ip[0] != '0.0.0.0' && line =~ /^XYMSRV=/
+          result << xymsrv_ip
+          break
+        else
+          result = ip
+        end
+      end
+      raise NoXymonServerDefined if result.empty?
+      result.map { |ip| { host: ip, port: 1984 } }
+    end
+  end
+end

data/lib/xymonclient/exception.rb

@@ -0,0 +1,22 @@
+module XymonClient
+  class NoXymonServerDefined < StandardError
+  end
+
+  class InvalidStatus < StandardError
+  end
+
+  class InvalidServer < StandardError
+  end
+
+  class InvalidDuration < StandardError
+  end
+
+  class InvalidService < StandardError
+  end
+
+  class InvalidHost < StandardError
+  end
+
+  class InvalidServiceItem < StandardError
+  end
+end

data/lib/xymonclient/helpers.rb

@@ -0,0 +1,43 @@
+module XymonClient
+  TIMESTRING_DEFINITION = {
+    '' => 60,
+    'm' => 60,
+    'h' => 60 * 60,
+    'd' => 60 * 60 * 24,
+    'w' => 60 * 60 * 24 * 7
+  }.freeze
+
+  def self.valid_status?(status)
+    %w(green yellow red purple blue clear).include?(status)
+  end
+
+  def self.valid_duration?(duration)
+    duration =~ /^[0-9]+[hmwd]?$/
+  end
+
+  def self.timestring_to_time(timestring)
+    time_matched = /^([0-9]+)([hmdw]{0,1})$/.match(timestring)
+    raise InvalidTimeString unless time_matched
+    time_matched[1].to_i * TIMESTRING_DEFINITION[time_matched[2]]
+  end
+
+  def self.hostsvc(host, service)
+    raise XymonClient::InvalidHost, host if host == ''
+    raise XymonClient::InvalidService, service if service == ''
+    host.tr('.', ',') + '.' + service
+  end
+
+  ##
+  # Class container for isolating context for ERB templating
+  class ERBContext
+    def initialize(hash)
+      hash.each_pair do |key, value|
+        instance_variable_set('@' + key.to_s, value)
+      end
+    end
+
+    def context
+      binding
+    end
+  end
+end

data/lib/xymonclient/service.rb

@@ -0,0 +1,133 @@
+require 'erb'
+require 'xymonclient'
+require 'xymonclient/helpers'
+require 'xymonclient/serviceitem'
+
+module XymonClient
+  ##
+  # Manage a Service, can contains multiple items to monitor
+  class Service < XymonClient::Client
+    attr_reader :name
+    attr_accessor :status
+    attr_reader :details
+    DEFAULT_DETAILS_TEMPLATE = 'Generated at <%= @timestamp %> ' \
+      "for <%= @lifetime %> \n<%= @header %>\n" \
+      '<% @items.each do |item| %>' \
+      "&<%= item['status'] %> <%= item['label'] %>: <%= item['value'] %>\n" \
+      "<% end %>\n" \
+      "<%= @footer %>\n".freeze
+
+    def initialize(servers, config)
+      super(servers)
+      @info = { 'items' => {} }
+      update_config(config)
+    end
+
+    def update_config(config)
+      raise InvalidService if config.fetch('name', '') == ''
+      raise InvalidService if config.fetch('host', '') == ''
+      @info['name'] = config['name']
+      @info['host'] = config['host']
+      @info['details_template'] = config.fetch(
+        'details_template',
+        DEFAULT_DETAILS_TEMPLATE
+      )
+      @info['lifetime'] = config.fetch('lifetime', '30m')
+      @info['enabled'] = config.fetch('enabled', true)
+      @info['header'] = config.fetch('header', '')
+      @info['footer'] = config.fetch('footer', '')
+      if config.fetch('items', {}).empty?
+        @info['items'] = {}
+      else
+        _update_items_config(config)
+      end
+      @info['purple_item_status'] = config.fetch('purple_item_status', 'red')
+      @info['status'] = @info.fetch('status', config.fetch('status', 'purple'))
+    end
+
+    def update_item(name, value)
+      raise InvalidServiceItem unless @info['items'].include?(name)
+      @info['items'][name].value = value
+    end
+
+    def status
+      return 'clear' unless @info['enabled']
+      items_status = @info['items'].map do |_key, value|
+        if value.info['status'] == 'purple'
+          @info['purple_item_status']
+        else
+          value.info['status']
+        end
+      end
+      @info['status'] = unless items_status.empty?
+                          if items_status.include?('red')
+                            'red'
+                          elsif items_status.include?('yellow') && \
+                                @status != 'red'
+                            'yellow'
+                          else
+                            'green'
+                          end
+                        end
+      details = _details
+      super(
+        @info['host'],
+        @info['name'],
+        @info['status'],
+        details,
+        @info['lifetime']
+      )
+      [@info['status'], details]
+    end
+
+    def enable
+      super(@info['host'], @info['name'])
+    end
+
+    def disable(duration, message)
+      super(@info['host'], @info['name'], duration, message)
+    end
+
+    def board(fields = [])
+      super(@info['host'], @info['name'], fields)
+    end
+
+    def ack(duration, message)
+      super(@info['host'], @info['name'], duration, message)
+    end
+
+    private
+
+    def _details
+      @info['timestamp'] = Time.now
+      context = @info.reject { |key, _value| key == 'items' }
+      context['items'] = @info['items'].map { |_key, value| value.info }
+      ERB.new(@info['details_template']).result(
+        XymonClient::ERBContext.new(context).context
+      )
+    end
+
+    def _create_serviceitem(config)
+      case config.fetch('type', '')
+      when 'gauge'
+        ServiceItemGauge.new(config)
+      when 'string'
+        ServiceItemString.new(config)
+      else
+        ServiceItem.new(config)
+      end
+    end
+
+    def _update_items_config(config)
+      # cleanup old items and update old items
+      @info['items'].keep_if { |key, _value| config.fetch('items').key?(key) }
+      @info['items'].each do |item_name, item_value|
+        item_value.update_config(config['items'][item_name])
+      end
+      # add new items
+      config['items'].each do |item_name, item_config|
+        @info['items'][item_name] = _create_serviceitem(item_config)
+      end
+    end
+  end
+end

data/lib/xymonclient/serviceitem.rb

@@ -0,0 +1,133 @@
+require 'xymonclient'
+require 'xymonclient/helpers'
+
+module XymonClient
+  ##
+  # Manage an item to monitor
+  class ServiceItem
+    attr_accessor :value
+    attr_reader :info
+
+    def initialize(config)
+      raise InvalidServiceItemName if config.fetch('label', '') == ''
+      @info = {
+        'label' => config['label'],
+        'type' => config['type'],
+        'description' => config.fetch('description', ''),
+        'enabled' => config.fetch('enabled', true),
+        'status' => 'purple',
+        'lifetime' => config.fetch('lifetime', '30m'),
+        'time' => Time.at(0)
+      }
+    end
+
+    def value=(value)
+      @info['value'] = value
+      @info['time'] = Time.now
+      status
+    end
+
+    def value
+      @info['value']
+    end
+
+    def status
+      @info['status'] = \
+        if !@info['enabled']
+          'clear'
+        elsif Time.now - @info['time'] > \
+              XymonClient.timestring_to_time(@info['lifetime'])
+          'purple'
+        elsif XymonClient.valid_status?(@info['value'])
+          @info['value']
+        else
+          'red'
+        end
+    end
+  end
+
+  ##
+  class ServiceItemGauge < ServiceItem
+    def initialize(config)
+      super(config)
+      @info['threshold'] = config.fetch('threshold', {})
+      @info['nan_status'] = config.fetch('nan_status', 'green')
+    end
+
+    def status
+      @info['status'] = \
+        if !@info['enabled']
+          'clear'
+        elsif Time.now - @info['time'] > \
+              XymonClient.timestring_to_time(@info['lifetime'])
+          'purple'
+        elsif value.instance_of?(Float) && value.nan?
+          @info['threshold'].fetch('nan_status', 'red')
+        elsif @info['threshold'].key?('critical') && \
+              _threshold_reached?('critical')
+          'red'
+        elsif @info['threshold'].key?('warning') && \
+              _threshold_reached?('warning')
+          'yellow'
+        else
+          'green'
+        end
+    end
+
+    private
+
+    def _threshold_reached?(threshold)
+      case @info['threshold'].fetch('order', '<')
+      when '<'
+        @info['value'] < @info['threshold'][threshold]
+      when '>'
+        @info['value'] > @info['threshold'][threshold]
+      when '<='
+        @info['value'] <= @info['threshold'][threshold]
+      when '>='
+        @info['value'] >= @info['threshold'][threshold]
+      end
+    end
+  end
+
+  ##
+  class ServiceItemString < ServiceItem
+    def initialize(config)
+      super(config)
+      @info['threshold'] = config.fetch('threshold', {})
+    end
+
+    def status
+      @info['status'] = \
+        if !@info['enabled']
+          'clear'
+        elsif Time.now - @info['time'] > \
+              XymonClient.timestring_to_time(@info['lifetime'])
+          'purple'
+        elsif @info['threshold'].key?('critical') && \
+              _threshold_reached?('critical')
+          'red'
+        elsif @info['threshold'].key?('warning') && \
+              _threshold_reached?('warning')
+          'yellow'
+        else
+          'green'
+        end
+    end
+
+    private
+
+    def _threshold_reached?(threshold)
+      inclusive = @info['threshold'].fetch('inclusive', true)
+      values = @info['value']
+      if values.instance_of?(Array)
+        value_is_included = values.any? do |value|
+          @info['threshold'][threshold].include?(value)
+        end
+      else
+        value_is_included = @info['threshold'][threshold].include?(values)
+      end
+      (inclusive && value_is_included) || (!inclusive && !value_is_included)
+    end
+  end
+end

data/lib/xymonclient/version.rb

@@ -0,0 +1,3 @@
+module XymonClient
+  VERSION = '0.1.1'.freeze
+end

data/lib/xymonclient.rb

@@ -0,0 +1,105 @@
+require 'xymonclient/version'
+require 'xymonclient/exception'
+require 'xymonclient/discovery'
+require 'xymonclient/helpers'
+require 'socket'
+
+module XymonClient
+  ##
+  # Client object for interacting with Xymon server(s)
+  # Params:
+  # - servers: array of string 'hostname' or 'hostname:port'
+  #            (port default to 1984)
+  class Client
+    attr_reader :servers
+
+    def initialize(servers = [])
+      @servers = \
+        if servers.empty?
+          XymonClient::ServerDiscovery.find_from_file
+        else
+          _parse_servers(servers)
+        end
+    end
+
+    def status(host, service, status, message, lifetime = '30m')
+      raise XymonClient::InvalidDuration, lifetime \
+        unless XymonClient.valid_duration?(lifetime)
+      raise XymonClient::InvalidStatus, status \
+        unless XymonClient.valid_status?(status)
+      _send_to_all(
+        "status+#{lifetime} " \
+        "#{XymonClient.hostsvc(host, service)} #{status} #{message}"
+      )
+    end
+
+    def disable(host, service, duration, message)
+      raise XymonClient::InvalidDuration, duration \
+        unless XymonClient.valid_duration?(duration)
+      _send_to_all(
+        "disable #{XymonClient.hostsvc(host, service)} #{duration} #{message}"
+      )
+    end
+
+    def enable(host, service)
+      _send_to_all("enable #{XymonClient.hostsvc(host, service)}")
+    end
+
+    def drop(host, service = '')
+      _send_to_all("drop #{host} #{service}")
+    end
+
+    def board(host, service, fields = [])
+      response = {}
+      @servers.each do |server|
+        response[server] = _send(
+          server,
+          "xymondboard host=#{host} test=#{service} fields=#{fields.join(';')}"
+        )
+      end
+      response
+    end
+
+    def ack(host, service, duration, message)
+      raise XymonClient::InvalidDuration, duration \
+        unless XymonClient.valid_duration?(duration)
+      cookies = board(host, service, ['cookie'])
+      @servers.each do |server|
+        _send(
+          server,
+          "xymondack #{cookies[server].to_i} #{duration} #{message}"
+        ) if cookies[server].to_i != -1
+      end
+    end
+
+    private
+
+    def _send_to_all(message)
+      @servers.each { |server| _send(server, message) }
+    end
+
+    def _send(server, message)
+      # TODO: validate response from all servers ( and retry ?)
+      socket = TCPSocket.open(server[:host], server[:port])
+      socket.puts message
+      socket.close_write
+      socket.gets
+    ensure
+      socket.close if socket
+    end
+
+    def _parse_servers(servers = [])
+      raise XymonClient::NoXymonServerDefined if servers.empty?
+      servers.map do |server|
+        case server
+        when /[^:]+:[0-9]*/
+          { host: server.split(':')[0], port: server.split(':')[1].to_i }
+        when /[^:]*/
+          { host: server, port: 1984 }
+        else
+          raise XymonClient::InvalidServer, server
+        end
+      end
+    end
+  end
+end

data/spec/service_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+require 'xymonclient/service'
+require 'socket'
+
+describe XymonClient do
+  describe XymonClient::Service do
+    let(:service) do
+      XymonClient::Service.new(
+        ['localhost'],
+        'name' => 'service1',
+        'host' => 'myhost',
+        'header' => 'A sample header',
+        'footer' => 'A sample footer',
+        'items' => {
+          'ITEM1' => {
+            'label' => 'Gauge Item 1',
+            'type' => 'gauge',
+            'threshold' => {
+              'order' => '<',
+              'critical' => 5,
+              'warning' => 10,
+              'nan_status' => 'red'
+            }
+          },
+          'ITEM2' => {
+            'label' => 'String Item 2',
+            'type' => 'string',
+            'threshold' => {
+              'inclusive' => false,
+              'critical' => ['all is Ok !']
+            }
+          }
+        }
+      )
+    end
+
+    it 'should send a valid status and details' do
+      service.update_item('ITEM1', 3)
+      service.update_item('ITEM2', 'all is Ok !')
+      allow(service).to receive(:_send) { '' }
+      # rubocop:disable LineLength
+      expect(service.status[0]).to eq('red')
+      expect(service.status[1]).to match(
+        /Generated at .* for 30m \nA sample header\n&red Gauge Item 1: 3\n&green String Item 2: all is Ok !\n\nA sample footer/
+      )
+      # rubocop:enable LineLength
+    end
+  end
+end

data/spec/serviceitem_spec.rb

@@ -0,0 +1,94 @@
+require 'spec_helper'
+require 'xymonclient'
+require 'xymonclient/serviceitem'
+
+describe XymonClient do
+  describe XymonClient::ServiceItem do
+    let(:config) { { 'label' => 'Item 1' } }
+
+    it 'should return purple status at start' do
+      expect(described_class.new(config).status).to eq('purple')
+    end
+
+    it 'should return red status on bad value' do
+      baditem = described_class.new(config)
+      baditem.value = 'badstatus'
+      expect(baditem.status).to eq('red')
+    end
+
+    it 'should return clear status if disabled' do
+      config['enabled'] = false
+      expect(described_class.new(config).status).to eq('clear')
+    end
+  end
+
+  describe XymonClient::ServiceItemGauge do
+    let(:config) { { 'label' => 'Item 1' } }
+
+    it 'should return red status when value is above critical threshold' do
+      config['threshold'] = { 'order' => '>', 'critical' => 10, 'warning' => 5 }
+      item = described_class.new(config)
+      item.value = 11
+      expect(item.status).to eq('red')
+    end
+
+    it 'should return yellow status when value is between warning and ' \
+       'critical threshold' do
+      config['threshold'] = { 'order' => '>', 'critical' => 10, 'warning' => 5 }
+      item = described_class.new(config)
+      item.value = 7
+      expect(item.status).to eq('yellow')
+    end
+
+    it 'should return green status when value is under warning threshold' do
+      config['threshold'] = { 'order' => '>', 'critical' => 10, 'warning' => 5 }
+      item = described_class.new(config)
+      item.value = 3
+      expect(item.status).to eq('green')
+    end
+  end
+
+  describe XymonClient::ServiceItemString do
+    describe 'inclusive' do
+      let(:config) { { 'label' => 'Item 1', 'threshold' => {'inclusive' => true, 'critical' => ['foo'], 'warning' => ['bar']}} }
+      it 'should return red status when value is included in critical threshold' do
+        item = described_class.new(config)
+        item.value = 'foo'
+        expect(item.status).to eq('red')
+      end
+
+      it 'should return yellow status when value is included in warning threshold' do
+        item = described_class.new(config)
+        item.value = 'bar'
+        expect(item.status).to eq('yellow')
+      end
+
+      it 'should return green status when values is not included in critical/warning threshold' do
+        item = described_class.new(config)
+        item.value = 'other'
+        expect(item.status).to eq('green')
+      end
+    end
+
+    describe 'exclusive' do
+      let(:config) { { 'label' => 'Item 1', 'threshold' => {'inclusive' => false, 'critical' => ['foo'], 'warning' => ['bar']}} }
+      it 'should return red status when "foo" is not included in critical threshold' do
+        item = described_class.new(config)
+        item.value = ['bar']
+        expect(item.status).to eq('red')
+      end
+
+      it 'should return yellow status when "bar" is not included in warning threshold' do
+        item = described_class.new(config)
+        item.value = ['foo']
+        expect(item.status).to eq('yellow')
+      end
+
+      it 'should return green status when all values are included in critical/warning threshold' do
+        item = described_class.new(config)
+        item.value = ['foo', 'bar']
+        expect(item.status).to eq('green')
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,5 @@
+require 'simplecov'
+SimpleCov.start
+
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'xymonclient'

data/spec/xymonclient_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+require 'xymonclient/helpers'
+
+describe XymonClient do
+  describe XymonClient::Client do
+    let(:client) { XymonClient::Client.new(['foo', 'bar:19840']) }
+
+    it 'should send a status with default lifetime (30m)' do
+      allow(client).to receive(:_send) { '' }
+      expect(client).to receive(:_send).with(
+        kind_of(Hash),
+        'status+30m my,host.myservice green all is good'
+      )
+      client.status('my.host', 'myservice', 'green', 'all is good')
+    end
+  end
+end

metadata

@@ -0,0 +1,147 @@
+--- !ruby/object:Gem::Specification
+name: xymonclient
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- David Chauviere
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-11-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: '0.40'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: '0.40'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.12.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.12.0
+- !ruby/object:Gem::Dependency
+  name: codeclimate-test-reporter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: Interact with Xymon server, send status, ack, enable/disable
+email:
+- david.chauviere@orange.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/xymonclient.rb
+- lib/xymonclient/discovery.rb
+- lib/xymonclient/exception.rb
+- lib/xymonclient/helpers.rb
+- lib/xymonclient/service.rb
+- lib/xymonclient/serviceitem.rb
+- lib/xymonclient/version.rb
+- spec/service_spec.rb
+- spec/serviceitem_spec.rb
+- spec/spec_helper.rb
+- spec/xymonclient_spec.rb
+homepage: https://github.com/dchauviere/ruby-xymonclient
+licenses:
+- Apache-2.0
+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.6.6
+signing_key: 
+specification_version: 4
+summary: Xymon client library
+test_files: []
+has_rdoc: