diplomat-scalp42 0.224

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 4af72b023e01a90621ae2e0283e129497551bbc7b8d48c0dee9e70e21c36be80
+  data.tar.gz: 76f9c34ae8858d8a5c6b220748b1bf9771dd8a7fdb8b3c324aa5773af4465c00
+SHA512:
+  metadata.gz: 581e42f80580429fd6c1bd792937bf219ef88bf0a23d6ad86af96f2e776797697c290a22ea6fa374ccb02a62e8e88d4b851d84dcb5aacc97ff7a60c13e00fc04
+  data.tar.gz: c6033ae90a86d589bcbdea9e1ee30ee74af3bcafb984b08cf48a414486018ca6f86bb335c368ad8ad80484d1370fc8e221dbb0e42703514333042268be35d8c1

data/LICENSE

@@ -0,0 +1,24 @@
+Copyright (c) 2014, Diplomat project contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of the Ruby FFI project nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1,356 @@
+# Diplomat
+[![Gem Version](https://badge.fury.io/rb/diplomat.svg)](https://rubygems.org/gems/diplomat) [![Gem](https://img.shields.io/gem/dt/diplomat.svg)](https://rubygems.org/gems/diplomat/versions/2.0.0) [![Build Status](https://travis-ci.org/WeAreFarmGeek/diplomat.svg?branch=master)](https://travis-ci.org/WeAreFarmGeek/diplomat) [![Code Climate](https://codeclimate.com/github/johnhamelink/diplomat.svg)](https://codeclimate.com/github/WeAreFarmGeek/diplomat) [![Inline docs](http://inch-ci.org/github/wearefarmgeek/diplomat.svg?branch=master)](http://inch-ci.org/github/wearefarmgeek/diplomat)
+### A HTTP Ruby API for [Consul](http://www.consul.io/)
+
+![Diplomacy Board Game](http://i.imgur.com/Nkuy4b7.jpg)
+
+
+## FAQ
+
+#### What's Diplomat for?
+
+Diplomat allows any ruby application to interact with [Consul's](http://www.consul.io/) distributed key value store, and also receive information about services currently available in the Consul cluster.
+
+#### Does it work in rails?
+
+Yup! In fact, we're using it in all of our rails production apps instead of any previous case where it'd be right to use environment variables according to [12Factor configuration principals](http://12factor.net/config). This gives us the ability to scale up without making any changes to the actual project codebase, and to move applications around the cluster with ease.
+
+Here's what a production database.yml file might look like:
+
+```erb
+<% if Rails.env.production? %>
+production:
+  adapter:            postgresql
+  encoding:           unicode
+  host:               <%= Diplomat::Service.get('postgres').Address %>
+  database:           <%= Diplomat::Kv.get('project/db/name') %>
+  pool:               5
+  username:           <%= Diplomat::Kv.get('project/db/user') %>
+  password:           <%= Diplomat::Kv.get('project/db/pass') %>
+  port:               <%= Diplomat::Service.get('postgres').ServicePort %>
+<% end %>
+```
+
+#### Why would I use Consul over ZooKeeper, Doozerd, etcd, Nagios, Sensu, SmartStack, SkyDNS, Chef, Puppet, Ansible, etc?
+
+[Read up what makes Consul different here](http://www.consul.io/intro/vs/index.html)
+
+#### How do I install Consul?
+
+[See here](http://www.consul.io/intro/). I managed to roll it out on my production machines with the help of [Ansible](http://www.ansible.com/) in one working day.
+
+### Which versions of Ruby does Diplomat support? Where did my ruby 1.9 compatibility go?
+
+Check out [Travis](https://travis-ci.org/WeAreFarmGeek/diplomat) to see which versions of ruby we currently test when we're making builds.
+
+We've dropped ruby 1.9 support. You can still depend on Diplomat by directly using the `ruby-1.9-compatible` branch on github, although be advised it's not actively maintained anymore.
+
+## Usage
+
+[The most up to date place to read about the API is here.](http://rubydoc.info/github/WeAreFarmGeek/diplomat)
+
+Here's a few examples of how diplomat works:
+
+### Key Values
+
+#### Setting
+
+Setting the value of a key is easy as pie:
+
+```ruby
+foo = Diplomat::Kv.put('foo', 'bar')
+# => "bar"
+```
+
+#### Getting
+
+Getting the value of a key is just as simple:
+
+```ruby
+foo = Diplomat::Kv.get('foo')
+# => "bar"
+```
+
+Or retrieve a value from another datacenter:
+
+```ruby
+foo = Diplomat::Kv.get('foo', :dc => 'dc-west')
+# => "baz"
+```
+
+You can also retrieve values recursively:
+
+```ruby
+Diplomat::Kv.put('foo/a', 'lorem')
+Diplomat::Kv.put('foo/b', 'ipsum')
+Diplomat::Kv.put('foo/c', 'dolor')
+
+Diplomat::Kv.get('foo/', recurse: true)
+# => [{:key=>"foo/a", :value=>"lorem"}, {:key=>"foo/b", :value=>"ipsum"}, {:key=>"foo/c", :value=>"dolor"}]
+```
+
+
+Or list all available keys:
+
+```ruby
+Diplomat::Kv.get('/', :keys => true) # => ['foo/a', 'foo/b']
+```
+You can convert the consul data to a ruby hash
+
+```ruby
+Diplomat::Kv.put('foo/a', 'lorem')
+Diplomat::Kv.put('foo/b', 'ipsum')
+Diplomat::Kv.put('foo/c', 'dolor')
+
+Diplomat::Kv.get('foo/', recurse: true, convert_to_hash: true)
+# => {"foo"=>{"a"=>"lorem", "b"=>"ipsum", "c"=>"dolor"}}
+```
+
+### Nodes
+
+#### Getting
+
+Look up a node:
+
+```ruby
+foo_service = Diplomat::Node.get('foo')
+# => {"Node"=>{"Node"=>"foobar", "Address"=>"10.1.10.12"}, "Services"=>{"consul"=>{"ID"=>"consul", "Service"=>"consul", "Tags"=>nil, "Port"=>8300}, "redis"=>{"ID"=>"redis", "Service"=>"redis", "Tags"=>["v1"], "Port"=>8000}}}
+```
+
+Get all nodes:
+
+```ruby
+nodes = Diplomat::Node.get_all
+# => [#<OpenStruct Address="10.1.10.12", Node="foo">, #<OpenStruct Address="10.1.10.13", Node="bar">]
+```
+
+Get all nodes for a particular datacenter
+
+```ruby
+nodes = Diplomat::Node.get_all({ :dc => 'My_Datacenter' })
+# => [#<OpenStruct Address="10.1.10.12", Node="foo">, #<OpenStruct Address="10.1.10.13", Node="bar">]
+```
+
+Register a node:
+
+```ruby
+Diplomat::Node.register({ :Node => "app1", :Address => "10.0.0.2" })
+# => true
+```
+
+De-register a node:
+
+```ruby
+Diplomat::Node.deregister({ :Node => "app1", :Address => "10.0.0.2" })
+# => true
+```
+
+### Services
+
+#### Getting
+
+Looking up a service is easy as pie:
+
+```ruby
+foo_service = Diplomat::Service.get('foo')
+# => #<OpenStruct Node="hotel", Address="1.2.3.4", ServiceID="hotel_foo", ServiceName="foo", ServiceTags=["foo"], ServicePort=5432>
+```
+Or if you have multiple nodes per service:
+
+```ruby
+foo_service = Diplomat::Service.get('foo', :all)
+# => [#<OpenStruct Node="hotel", Address="1.2.3.4", ServiceID="hotel_foo", ServiceName="foo", ServiceTags=["foo"], ServicePort=5432>,#<OpenStruct Node="indigo", Address="1.2.3.5", ServiceID="indigo_foo", ServiceName="foo", ServiceTags=["foo"], ServicePort=5432>]
+```
+
+Or if you want to find services for a particular datacenter
+
+```ruby
+foo_service = Diplomat::Service.get('foo', :all, { :dc => 'My_Datacenter'})
+# => [#<OpenStruct Node="hotel", Address="1.2.3.4", ServiceID="hotel_foo", ServiceName="foo", ServiceTags=["foo"], ServicePort=5432>,#<OpenStruct Node="indigo", Address="1.2.3.5", ServiceID="indigo_foo", ServiceName="foo", ServiceTags=["foo"], ServicePort=5432>]
+```
+
+If you wish to list all the services on consul:
+
+```ruby
+services = Diplomat::Service.get_all
+# => #<OpenStruct consul=[], foo=[], bar=[]>
+```
+
+If you wish to list all the services for a specific datacenter:
+
+```ruby
+services = Diplomat::Service.get_all({ :dc => 'My_Datacenter' })
+# => #<OpenStruct consul=[], foo=[], bar=[]>
+```
+
+### Datacenters
+
+Getting a list of datacenters is quite simple and gives you the option to extract all services out of
+all accessible datacenters if you need to.
+
+```ruby
+datacenters = Diplomat::Datacenter.get()
+# => ["DC1", "DC2"]
+```
+
+### Sessions
+
+Creating a session:
+
+```ruby
+sessionid = Diplomat::Session.create({:Node => "server1", :Name => "my-lock"})
+# => "fc5ca01a-c317-39ea-05e8-221da00d3a12"
+```
+Or destroying a session:
+
+```ruby
+Diplomat::Session.destroy("fc5ca01a-c317-39ea-05e8-221da00d3a12")
+```
+
+Renew a session:
+```ruby
+Diplomat::Session.renew(sessionid)
+```
+
+List sessions:
+```ruby
+Diplomat::Session.list.each {|session| puts "#{session["ID"]} #{session["Name"]}"}
+```
+
+### Locks
+
+Acquire a lock:
+
+```ruby
+sessionid = Diplomat::Session.create({:Node => "server1", :Name => "my-lock"})
+lock_acquired = Diplomat::Lock.acquire("/key/to/lock", sessionid)
+# => true
+```
+Or wait for a lock to be acquired:
+
+```ruby
+sessionid = Diplomat::Session.create({:hostname => "server1", :ipaddress => "4.4.4.4"})
+lock_acquired = Diplomat::Lock.wait_to_acquire("/key/to/lock", sessionid)
+```
+
+Release a lock:
+
+```ruby
+Diplomat::Lock.release("/key/to/lock", sessionid )
+```
+
+### Events
+
+Fire an event:
+
+```ruby
+Diplomat::Event.fire('do_something', 'payload')
+```
+
+List all events with a certain name received by the local agent:
+
+```ruby
+Diplomat::Event.get_all('do_something')
+```
+
+Get the latest event with a certain name received by the local agent:
+
+```ruby
+Diplomat::Event.get('do_something')
+```
+
+Iterate through the events with a certain name received by the local agent:
+
+```ruby
+events = Enumerator.new do |y|
+  ret = {token: :first}
+  while ret = begin Diplomat::Event.get('do_something', ret[:token], :reject) rescue nil end
+    y.yield(ret[:value])
+  end
+end
+
+events.each{ |e| puts e }
+```
+
+### Status
+
+Returns information about the status of the Consul cluster.
+
+Get the raft leader for the datacenter in which the local consul agent is running
+
+```ruby
+Diplomat::Status.leader()
+```
+
+Get an array of Raft peers for the datacenter in which the agent is running
+
+```ruby
+Diplomat::Status.peers()
+```
+
+### Maintenance mode
+
+Enable maintenance mode on a host, with optional reason and DC (requires access to local agent)
+
+```ruby
+Diplomat::Maintenance.enable(true, 'doing stuff', :dc => 'abc')
+```
+
+Determine if a host has maintenance mode enabled
+
+```ruby
+Diplomat::Maintenance.enabled('foobar')
+# => { :enabled => true, :reason => 'doing stuff' }
+```
+
+### Custom configuration
+
+You can create a custom configuration using the following syntax:
+
+```ruby
+Diplomat.configure do |config|
+  # Set up a custom Consul URL
+  config.url = "http://localhost:8888"
+  # Set up a custom Faraday Middleware
+  config.middleware = MyCustomMiddleware
+  # Set extra Faraday configuration options and custom access token (ACL)
+  config.options = {ssl: {version: :TLSv1_2}, headers: {"X-Consul-Token" => "xxxxxxxx-yyyy-zzzz-1111-222222222222"}}
+end
+```
+
+This is traditionally kept inside the `config/initializers` directory if you're using rails. The middleware allows you to customise what happens when faraday sends and receives data. This can be useful if you want to instrument your use of diplomat, for example. You can read more about Faraday's custom middleware [here](http://stackoverflow.com/a/20973008).
+
+Alternatively, configuration settings can be overriden at each method call allowing for instance to address different consul agents, with some other token.
+
+```ruby
+Diplomat::Service.get('foo', { http_addr: 'http://consu01:8500' })
+Diplomat::Service.get('foo', { http_addr: 'http://consu02:8500' })
+Diplomat::Kv.put('key/path', 'value', { http_addr: 'http://localhost:8500', dc: 'dc1', token: '111-222-333-444-555' })
+```
+
+Most common options are:
+* dc: target datacenter
+* token: identity used to perform the corresponding action
+* http_addr: to target a remote consul node
+* stale: use consistency mode that allows any server to service the read regardless of whether it is the leader
+
+### Todo
+
+-  [ ] Updating Docs with latest changes
+-  [ ] Using custom objects for response objects (instead of openStruct)
+-  [ ] PUTing and DELETEing services
+-  [x] Custom SSL Cert Middleware for faraday
+-  [x] Allowing the custom configuration of the consul url to connect to
+-  [x] Deleting Keys
+-  [x] Listing available services
+-  [x] Health
+-  [x] Members
+-  [x] Status
+-  [x] Datacenter support for services
+-  [x] Ruby 1.8 support
+-  [x] Events
+
+
+## Enjoy!
+
+![Photo Copyright "merlinmann" https://www.flickr.com/photos/merlin/. All rights reserved.](http://i.imgur.com/3mBwzR9.jpg)

data/features/configuration.feature

@@ -0,0 +1,9 @@
+Feature: Configuration
+
+  Scenario: I'm Setting up Diplomat with a default config
+    Given I am setting up a default diplomat
+    Then I should be able to get and put keys
+
+  Scenario: I'm Setting up Diplomat with a custom config
+    Given I am setting up a custom diplomat
+    Then I should be able to get and put keys

data/features/step_definitions/setup_diplomat.rb

@@ -0,0 +1,24 @@
+require 'diplomat'
+
+Given 'I am setting up a default diplomat' do
+end
+
+Given 'I am setting up a custom diplomat' do
+  class StubMiddleware # :nodoc:
+    def initialize(app, options = {})
+      @app = app
+      @options = options
+    end
+
+    def call(env)
+      @app.call(env)
+    end
+  end
+
+  expect do
+    Diplomat.configure do |config|
+      config.url = 'http://localhost:8500'
+      config.middleware = StubMiddleware
+    end
+  end.to_not raise_error
+end

data/features/step_definitions/test_key_value.rb

@@ -0,0 +1,9 @@
+Then 'I should be able to get and put keys' do
+  # High-fructose Corn Syrup
+  Diplomat.put('drink', 'Irn Bru')
+  expect(Diplomat.get('drink')).to eq('Irn Bru')
+
+  # Sugar
+  Diplomat::Kv.put('cake', 'Sponge')
+  expect(Diplomat::Kv.get('cake')).to eq('Sponge')
+end

data/lib/diplomat/acl.rb

@@ -0,0 +1,81 @@
+module Diplomat
+  # Methods for interacting with the Consul ACL API endpoint
+  class Acl < Diplomat::RestClient
+    @access_methods = %i[list info create destroy update]
+    attr_reader :id, :type, :acl
+
+    # Get Acl info by ID
+    # @param id [String] ID of the Acl to get
+    # @param options [Hash] options parameter hash
+    # @return [Hash]
+    # rubocop:disable PerceivedComplexity
+    def info(id, options = {}, not_found = :reject, found = :return)
+      @id = id
+      @options = options
+      custom_params = []
+      custom_params << use_consistency(options)
+
+      raw = send_get_request(@conn_no_err, ["/v1/acl/info/#{id}"], options, custom_params)
+
+      if raw.status == 200 && raw.body.chomp != 'null'
+        case found
+        when :reject
+          raise Diplomat::AclAlreadyExists, id
+        when :return
+          @raw = raw
+          return parse_body
+        end
+      elsif raw.status == 200 && raw.body.chomp == 'null'
+        case not_found
+        when :reject
+          raise Diplomat::AclNotFound, id
+        when :return
+          return nil
+        end
+      else
+        raise Diplomat::UnknownStatus, "status #{raw.status}: #{raw.body}"
+      end
+    end
+    # rubocop:enable PerceivedComplexity
+
+    # List all Acls
+    # @param options [Hash] options parameter hash
+    # @return [List] list of [Hash] of Acls
+    def list(options = {})
+      @raw = send_get_request(@conn_no_err, ['/v1/acl/list'], options)
+      parse_body
+    end
+
+    # Update an Acl definition, create if not present
+    # @param value [Hash] Acl definition, ID field is mandatory
+    # @param options [Hash] options parameter hash
+    # @return [Hash] The result Acl
+    def update(value, options = {})
+      raise Diplomat::IdParameterRequired unless value['ID'] || value[:ID]
+
+      custom_params = use_cas(@options)
+      @raw = send_put_request(@conn, ['/v1/acl/update'], options, value, custom_params)
+      parse_body
+    end
+
+    # Create an Acl definition
+    # @param value [Hash] Acl definition, ID field is mandatory
+    # @param options [Hash] options parameter hash
+    # @return [Hash] The result Acl
+    def create(value, options = {})
+      custom_params = use_cas(@options)
+      @raw = send_put_request(@conn, ['/v1/acl/create'], options, value, custom_params)
+      parse_body
+    end
+
+    # Destroy an ACl token by its id
+    # @param ID [String] the Acl ID
+    # @param options [Hash] options parameter hash
+    # @return [Bool]
+    def destroy(id, options = {})
+      @id = id
+      @raw = send_put_request(@conn, ["/v1/acl/destroy/#{@id}"], options, nil)
+      @raw.body.chomp == 'true'
+    end
+  end
+end

data/lib/diplomat/agent.rb

@@ -0,0 +1,42 @@
+require 'base64'
+require 'faraday'
+
+module Diplomat
+  # Agent API endpoint methods
+  # @see https://www.consul.io/docs/agent/http/agent.html
+  class Agent < Diplomat::RestClient
+    @access_methods = %i[self checks services members]
+
+    # Get agent configuration
+    # @param options [Hash] options parameter hash
+    # @return [OpenStruct] all data associated with the node
+    def self(options = {})
+      ret = send_get_request(@conn, ['/v1/agent/self'], options)
+      JSON.parse(ret.body).tap { |node| OpenStruct.new node }
+    end
+
+    # Get local agent checks
+    # @param options [Hash] options parameter hash
+    # @return [OpenStruct] all agent checks
+    def checks(options = {})
+      ret = send_get_request(@conn, ['/v1/agent/checks'], options)
+      JSON.parse(ret.body).tap { |node| OpenStruct.new node }
+    end
+
+    # Get local agent services
+    # @param options [Hash] options parameter hash
+    # @return [OpenStruct] all agent services
+    def services(options = {})
+      ret = send_get_request(@conn, ['/v1/agent/services'], options)
+      JSON.parse(ret.body).tap { |node| OpenStruct.new node }
+    end
+
+    # Get cluster members (as seen by the agent)
+    # @param options [Hash] options parameter hash
+    # @return [OpenStruct] all members
+    def members(options = {})
+      ret = send_get_request(@conn, ['/v1/agent/members'], options)
+      JSON.parse(ret.body).map { |node| OpenStruct.new node }
+    end
+  end
+end

data/lib/diplomat/check.rb

@@ -0,0 +1,109 @@
+module Diplomat
+  # Methods for interacting with the Consul check API endpoint
+  class Check < Diplomat::RestClient
+    @access_methods = %i[checks register_script register_ttl
+                         deregister pass warn fail]
+
+    # Get registered checks
+    # @return [OpenStruct] all data associated with the service
+    def checks(options = {})
+      ret = send_get_request(@conn, ['/v1/agent/checks'], options)
+      JSON.parse(ret.body)
+    end
+
+    # Register a check
+    # @param check_id [String] the unique id of the check
+    # @param name [String] the name
+    # @param notes [String] notes about the check
+    # @param args [String[]] command to be run for check
+    # @param interval [String] frequency (with units) of the check execution
+    # @param options [Hash] options parameter hash
+    # @return [Integer] Status code
+    # rubocop:disable ParameterLists
+    def register_script(check_id, name, notes, args, interval, options = {})
+      unless args.is_a?(Array)
+        raise(Diplomat::DeprecatedArgument, 'Script usage is deprecated, replace by an array of args')
+      end
+
+      definition = JSON.generate(
+        'ID' => check_id,
+        'Name' => name,
+        'Notes' => notes,
+        'Args' => args,
+        'Interval' => interval
+      )
+      ret = send_put_request(@conn, ['/v1/agent/check/register'], options, definition)
+      ret.status == 200
+    end
+    # rubocop:enable ParameterLists
+
+    # Register a TTL check
+    # @param check_id [String] the unique id of the check
+    # @param name [String] the name
+    # @param notes [String] notes about the check
+    # @param ttl [String] time (with units) to mark a check down
+    # @param options [Hash] options parameter hash
+    # @return [Boolean] Success
+    def register_ttl(check_id, name, notes, ttl, options = {})
+      definition = JSON.generate(
+        'ID' => check_id,
+        'Name' => name,
+        'Notes' => notes,
+        'TTL' => ttl
+      )
+      ret = send_put_request(@conn, ['/v1/agent/check/register'], options, definition)
+      ret.status == 200
+    end
+
+    # Deregister a check
+    # @param check_id [String] the unique id of the check
+    # @param options [Hash] options parameter hash
+    # @return [Integer] Status code
+    def deregister(check_id, options = {})
+      ret = send_put_request(@conn, ["/v1/agent/check/deregister/#{check_id}"], options, nil)
+      ret.status == 200
+    end
+
+    # Update a TTL check
+    # @param check_id [String] the unique id of the check
+    # @param status [String] status of the check. Valid values are "passing", "warning", and "critical"
+    # @param output [String] human-readable message will be passed through to the check's Output field
+    # @param options [Hash] options parameter hash
+    # @return [Integer] Status code
+    def update_ttl(check_id, status, output = nil, options = {})
+      definition = JSON.generate(
+        'Status' => status,
+        'Output' => output
+      )
+      ret = send_put_request(@conn, ["/v1/agent/check/update/#{check_id}"], options, definition)
+      ret.status == 200
+    end
+
+    # Pass a check
+    # @param check_id [String] the unique id of the check
+    # @param output [String] human-readable message will be passed through to the check's Output field
+    # @param options [Hash] options parameter hash
+    # @return [Integer] Status code
+    def pass(check_id, output = nil, options = {})
+      update_ttl(check_id, 'passing', output, options)
+    end
+
+    # Warn a check
+    # @param check_id [String] the unique id of the check
+    # @param output [String] human-readable message will be passed through to the check's Output field
+    # @param options [Hash] options parameter hash
+    # @return [Integer] Status code
+    def warn(check_id, output = nil, options = {})
+      update_ttl(check_id, 'warning', output, options)
+    end
+
+    # Fail a check
+    # @param check_id [String] the unique id of the check
+    # @param output [String] human-readable message will be passed through to the check's Output field
+    # @param options [Hash] options parameter hash
+    # @return [Integer] Status code
+    def fail(check_id, output = nil, options = {})
+      update_ttl(check_id, 'critical', output, options)
+    end
+  end
+end