reign-client 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d7ef2a4f1499e567a2d11ea36a34b5e748193fb5
-  data.tar.gz: 0c07a8647b4921d711808ac610d7daf579a92cc3
+  metadata.gz: dea8b1909cfb4ccaed04143d9e072ff208d0e766
+  data.tar.gz: 3dafa685d1295e9a61836c3ca7c83d696b5e2902
 SHA512:
-  metadata.gz: feaba5efe9fa2d672df6105d1a591040c5228cfb6cc78a7eed36073eeeac68904679b654dab1097485a17f3470e68b502c6862f8c88cac3e2110c9dbed669294
-  data.tar.gz: 15e56f2e5df98abd192588a527e88eb8db061fe0f85fa13c6ce676ee9931c872645efd0ea48a7b21ca3ff5f9af6505950547598317c769b165cfd4bbae79ca19
+  metadata.gz: a3e45de40719a90c267dbcb5023486dae58a26834c71baf3a718d09d813a5bc69525b21234d2353008dd943599f673725f0c52c65927c831b216d8809338f8d7
+  data.tar.gz: 359b9a37ae6f58ec2a42324a446aa952061be5998d3d7cd7e6b2a2d234c62475931efe61ae4e16717d7a005dd05ad3a230a126b575547950f01d4cf775ae2cb1

data/.gitignore

@@ -0,0 +1,36 @@
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/spec/examples.txt
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalization:
+/.bundle/
+/vendor/bundle
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+# Gemfile.lock
+# .ruby-version
+# .ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc

data/Gemfile

@@ -0,0 +1,5 @@
+# A sample Gemfile
+source 'https://rubygems.org'
+
+gem "rest-client"
+gem "json"

data/Gemfile.lock

@@ -0,0 +1,27 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    domain_name (0.5.20160310)
+      unf (>= 0.0.5, < 1.0.0)
+    http-cookie (1.0.2)
+      domain_name (~> 0.5)
+    json (1.8.3)
+    mime-types (2.99.1)
+    netrc (0.11.0)
+    rest-client (1.8.0)
+      http-cookie (>= 1.0.2, < 2.0)
+      mime-types (>= 1.16, < 3.0)
+      netrc (~> 0.7)
+    unf (0.1.4)
+      unf_ext
+    unf_ext (0.0.7.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  json
+  rest-client
+
+BUNDLED WITH
+   1.11.2

data/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "{}"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright {yyyy} {name of copyright owner}
+
+   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 @@
+# reign-client-ruby

data/lib/common.rb

@@ -0,0 +1,260 @@
+require 'openssl'
+require 'base64'
+
+module Reign
+  #Constants for API resources
+  GET_REGIONS_URI = '/api/v1/regions'
+  GET_PRESENCE_URI = '/api/v1/presence/'
+  HEARTBEAT_URI = '/api/v1/heartbeat/'
+  KEY_VALUE_URI = '/api/v1/kv/'
+  LEASE_URI = '/api/v1/lease/' 
+  WATCH_URI = '/api/v1/watch/'
+
+  def self.generate_categories_uri(namespace)
+    if namespace == nil
+      raise ArgumentError.new("must pass namespace")
+    end
+    return GET_PRESENCE_URI + namespace
+  end
+
+  def self.generate_nodes_in_category_uri args
+    category = args[:category]
+    namespace = args[:namespace]
+    status = args[:status]
+    if category == nil
+      raise ArgumentError.new("must pass category")
+    end
+    if status != nil and not ["OK", "NOK"].include?(status) 
+      raise ArgumentError.new("status must be OK or NOK if passed")
+    end
+    if namespace == nil
+      raise ArgumentError.new("must pass namespace")
+    end
+
+    uri = Reign::GET_PRESENCE_URI + namespace + "/" + category
+    if status != nil
+      uri = uri + Reign.generate_query_string({"status" => status})
+    end
+    return uri
+  end
+
+  def self.generate_upsert_kv_uri args
+    uri = Reign.generate_kv_uri(args[:namespace], args[:kv_path])
+    query_params = {}
+    if args[:owner_id]
+      query_params["owner_id"] = args[:owner_id]
+    end
+    if args[:sig]
+      query_params["sig"] = args[:sig]
+    end
+    uri = uri + Reign.generate_query_string(query_params)
+    return uri
+  end
+
+  def self.generate_delete_kv_uri args
+    if args[:sig] == nil
+      raise ArgumentError.new("must pass sig parameter in order to delete entry")
+    end
+    uri = Reign.generate_kv_uri(args[:namespace], args[:kv_path])
+    uri = uri + Reign.generate_query_string({"sig" => args[:sig]})
+    return uri
+  end
+
+  def self.generate_get_kv_uri args
+    return Reign.generate_kv_uri(args[:namespace], args[:kv_path])
+  end
+
+  def self.generate_kv_uri(namespace, kv_path)
+    if namespace == nil
+      raise ArgumentError.new("must pass namespace")
+    end
+    if kv_path == nil
+      raise ArgumentError.new("must pass kv_path")
+    end
+    kv_path.slice!(0) if kv_path[0] == "/"
+    kv_path.chomp!("/")
+    return KEY_VALUE_URI + namespace + "/" + kv_path
+  end
+
+  def self.generate_acquire_lease_uri args
+    term_s = args[:term_s]
+    owner_id = args[:owner_id]
+    if term_s == nil
+      raise ArgumentError.new("must pass term_s")
+    end
+    if owner_id == nil
+      raise ArgumentError.new("must pass owner_id")
+    end
+    term_s = term_s.to_s
+    query_params = {"op" => "acquire", "term_s" => term_s, "owner_id" => owner_id}
+
+    uri = Reign.generate_lease_uri(args[:namespace], args[:lease_path])
+    return uri + Reign.generate_query_string(query_params) 
+  end
+
+  def self.generate_release_lease_uri args
+    sig = args[:sig]
+    if sig == nil
+      raise ArgumentError.new("must pass sig.  This value is returned in the response body when the lease is acquired")
+    end
+
+    query_params = {"op" => "release", "sig" => sig}
+    uri = Reign.generate_lease_uri(args[:namespace], args[:lease_path])
+    return uri + Reign.generate_query_string(query_params)
+  end
+
+  def self.generate_revoke_lease_uri args
+    sig = args[:sig]
+    if sig == nil
+      raise ArgumentError.new("must pass sig.  This value is returned in the response body when the lease is acquired")
+    end
+
+    query_params = {"op" => "revoke", "sig" => sig}
+    uri = Reign.generate_lease_uri(args[:namespace], args[:lease_path])
+    return uri + Reign.generate_query_string(query_params)
+  end
+
+  def self.generate_get_lease_uri args
+    return Reign.generate_lease_uri(args[:namespace], args[:lease_path])
+  end
+
+  def self.generate_lease_uri(namespace, lease_path)
+    if namespace == nil
+      raise ArgumentError.new("must pass namespace")
+    end
+    if lease_path == nil or lease_path.length == 0
+      raise ArgumentError.new("must pass non-trivial lease_path")
+    end  
+    lease_path.slice!(0) if lease_path[0] == "/"
+    lease_path.chomp!("/")
+    return LEASE_URI + namespace + "/" + lease_path
+  end
+
+  def self.generate_watch_uri(namespace, watch_entity_path)
+    if namespace == nil
+      raise ArgumentError.new("must pass namespace")
+    end
+    if watch_entity_path == nil
+      raise ArgumentError.new("must pass watch_entity_path")
+    end
+    watch_entity_path.slice!(0) if watch_entity_path[0] == "/"
+    watch_entity_path.chomp!("/")
+    return WATCH_URI + namespace + "/" + watch_entity_path
+  end
+
+  def self.generate_heartbeat_uri(namespace)
+    if namespace == nil
+      raise ArgumentError.new("must pass namespace")
+    end
+    return Reign::HEARTBEAT_URI + namespace
+  end  
+ 
+  def self.generate_heartbeat_body args
+    node_id = args[:node_id]
+    host = args[:host]
+    port = args[:port]
+    status = args[:status]
+    hb_to_s = args[:hb_to_s]      
+    category = args[:category]
+    namespace = args[:namespace]
+    if node_id == nil
+      raise ArgumentError.new("must pass node_id")
+    end
+    if not (status == "OK" or status == "NOK")
+      raise ArgumentError.new("must pass status = OK / NOK")
+    end 
+    if hb_to_s == nil
+      raise ArgumentError.new("must pass heartbeat timeout secs")
+    end
+    if namespace == nil
+      raise ArgumentError.new("must pass namespace")
+    end
+    if category == nil
+      raise ArgumentError.new("must pass category")
+    end
+
+    request_body = {}
+    request_body['presence'] = {}
+    request_body['presence']['category'] = category
+      
+    node = {}
+    node['id'] = node_id
+    node['host'] = host
+    node['port'] = port
+    node['status'] = status
+    node['hb_to_s'] = hb_to_s
+
+    request_body['presence']['node'] = node
+    return request_body
+  end
+
+  def self.generate_query_string(map)
+    query = "?"
+    map.each {
+      |k, v|
+      query.concat(k)
+      query.concat("=")
+      query.concat(v)
+      query.concat("&")
+    }
+    return query.chomp("&")
+  end
+
+  def self.generate_watch_body_template(owner_id, email_contacts, webhook_contacts) 
+    if owner_id == nil
+      raise ArgumentError.new("must pass owner_id")
+    end
+
+    email_contacts = email_contacts ? email_contacts : []
+    webhook_contacts = webhook_contacts ? webhook_contacts : []
+
+    body = {}
+    body["watch"] = {}
+    body["watch"]["webhooks"] = []
+    body["watch"]["emails"] = []
+    body["watch"]["owner_id"] = owner_id
+
+    email_contacts.each {|email| body["watch"]["emails"].push(email)}
+    webhook_contacts.each {|webhook| body["watch"]["webhooks"].push(webhook)}
+   
+    return body
+  end
+
+  def self.generate_header_for_request(args)
+    #parse arguments
+    request_method = args[:method] or raise ArgumentError, 'must pass :method'
+    request_uri = args[:request_uri] or raise ArgumentError, 'must pass :request_uri'
+    api_key = args[:api_key] or raise ArgumentError, 'must pass :api_key'
+    secret_key = args[:secret_key] or raise ArgumentError, 'must pass :secret_key'
+    region = args[:region] or raise ArgumentError, 'must pass :region'
+    payload = args[:payload]
+
+    now = Time.new
+    date_header_value = now.strftime("%a, %d %b %Y %X %z")    
+
+    case request_method
+    when :get
+      message = date_header_value + "\n" + "GET" + "\n" + request_uri
+    when :post
+      if payload != nil
+        message = date_header_value + "\n" + "POST" + "\n" + request_uri + "\n" + Base64.strict_encode64(payload.strip) 
+      else 
+        message = date_header_value + "\n" + "POST" + "\n" + request_uri
+      end
+    when :put
+      if payload != nil
+        message = date_header_value + "\n" + "PUT" + "\n" + request_uri + "\n" + Base64.strict_encode64(payload.strip)
+      else
+        message = date_header_value + "\n" + "PUT" + "\n" + request_uri
+      end
+    when :delete
+      message = date_header_value + "\n" + "DELETE" + "\n" + request_uri
+    end
+
+    hash  = Base64.strict_encode64(OpenSSL::HMAC.digest('sha256', secret_key, message)).strip 
+    auth = 'REIGN-HMAC-SHA256 ' + api_key + ":" + hash   
+    headers = {:Date => date_header_value, :Authorization => auth, :'Reign-Region' => region}
+
+    return headers
+  end
+end

data/lib/reign-client.rb

@@ -0,0 +1,216 @@
+require 'json'
+require 'rest-client'
+require 'base64'
+require File.dirname(__FILE__) + '/common.rb'
+
+module Reign
+  class Client
+    def initialize args
+      #example endpoint: https://int-usw2.reign.io
+      @endpoint = args[:endpoint] or raise ArgumentError.new("must pass endpoint")
+      @endpoint = @endpoint.chomp("/")
+      @api_key = args[:api_key] or raise ArgumentError.new("must pass api_key")
+      @secret_key = args[:secret_key] or raise ArgumentError.new("must pass secret_key")
+      @region = args[:region] || "default"
+    end
+
+    def heartbeat args
+      request_body = Reign.generate_heartbeat_body(args)
+      request_body = JSON.generate(request_body)
+      uri = Reign.generate_heartbeat_uri(args[:namespace])
+      headers = Reign.generate_header_for_request(:method => :post, :request_uri => uri, :api_key => @api_key, 
+                                                  :secret_key => @secret_key, :payload => request_body, :region => @region) 
+      begin
+        return JSON.parse(RestClient::Request.execute(:method => :post, :url => @endpoint + uri, 
+                                                      :payload => request_body, :headers => headers))
+      rescue RestClient::ExceptionWithResponse => e 
+        url = @endpoint + uri
+        raise "Bad response from Reign server.  Message = #{e.response}.  URL = #{url}. payload = #{request_body}"
+      end
+    end
+
+    def get_regions
+      headers = Reign.generate_header_for_request(:method => :get, :request_uri => Reign::GET_REGIONS_URI, :api_key => @api_key, 
+                                                  :secret_key => @secret_key, :region => @region)
+      begin
+        return JSON.parse(RestClient::Request.execute(:method => :get, :url => @endpoint + Reign::GET_REGIONS_URI, 
+                                                      :headers => headers))
+      rescue RestClient::ExceptionWithResponse => e
+        url = @endpoint + uri
+        raise "Bad response from Reign server. Message = #{e.response}.  URL = #{url}"
+      end
+    end
+
+    def get_categories_in_namespace args
+      uri = Reign.generate_categories_uri(args[:namespace])
+      headers = Reign.generate_header_for_request(:method => :get, :request_uri => uri, :api_key => @api_key,
+                                                  :secret_key => @secret_key, :region => @region)
+
+      begin
+        return JSON.parse(RestClient::Request.execute(:method => :get, :url => @endpoint + uri, :headers => headers)) 
+      rescue RestClient::ExceptionWithResponse => e
+        url = @endpoint + uri
+        raise "Bad response from Reign server. Message = #{e.response}.  URL = #{url}"
+      end
+    end
+
+    def get_nodes_in_category args
+      uri = Reign.generate_nodes_in_category_uri args
+      headers = Reign.generate_header_for_request(:method => :get, :request_uri => uri, :api_key => @api_key,
+                                                  :secret_key => @secret_key, :region => @region)
+      begin
+        return JSON.parse(RestClient::Request.execute(:method => :get, :url => @endpoint + uri, :headers => headers))
+      rescue RestClient::ExceptionWithResponse => e
+        url = @endpoint + uri
+        raise "Bad response from Reign server. Message = #{e.response}.  URL = #{url}"
+      end
+    end
+ 
+    def upsert_key_value args
+      if args[:kv_data] == nil
+        raise ArgumentError.new("must pass some data in raw bytes for kv_data")
+      end
+      raw_data = Base64.strict_encode64(args[:kv_data])
+      uri = Reign.generate_upsert_kv_uri args
+      headers = Reign.generate_header_for_request(:method => :put, :request_uri => uri, :api_key => @api_key,
+                                            :secret_key => @secret_key, :region => @region, :payload => raw_data)      
+      begin
+        response = RestClient::Request.execute(:method => :put, :url => @endpoint + uri, :headers => headers, 
+                                         :payload => raw_data)
+        return response.headers[:etag]
+      rescue RestClient::ExceptionWithResponse => e
+        url = @endpoint + uri
+        raise "Bad response from Reign server. Message = #{e.response}. URL = #{url}"
+      end
+    end
+
+    def get_key_value args
+      uri = Reign.generate_get_kv_uri args
+      headers = Reign.generate_header_for_request(:method => :get, :request_uri => uri, :api_key => @api_key,
+                                            :secret_key => @secret_key, :region => @region)      
+      begin
+        response = RestClient::Request.execute(:method => :get, :url => @endpoint + uri, :headers => headers)
+        sig = response.headers[:etag]
+        owner_id = response.headers[:"reign_owner_id"]
+        data = Base64.strict_decode64(response.to_str)
+        return {:sig => sig, :kv_data => data, :owner_id => owner_id}
+      rescue RestClient::ExceptionWithResponse => e
+        url = @endpoint + uri
+        raise "Bad response from Reign server. Message = #{e.response}. URL = #{url}"
+      end
+    end
+
+    def delete_key_value args
+      uri = Reign.generate_delete_kv_uri args 
+      headers = Reign.generate_header_for_request(:method => :delete, :request_uri => uri, :api_key => @api_key,
+                                            :secret_key => @secret_key, :region => @region)      
+      begin
+        RestClient::Request.execute(:method => :delete, :url => @endpoint + uri, :headers => headers)
+      rescue RestClient::ExceptionWithResponse => e
+        url = @endpoint + uri
+        raise "Bad response from Reign server. Message = #{e.response}. URL = #{url}"
+      end
+    end
+
+    def acquire_lease args
+      uri = Reign.generate_acquire_lease_uri args
+      headers = Reign.generate_header_for_request(:method => :post, :request_uri => uri, :api_key => @api_key,
+                                            :secret_key => @secret_key, :region => @region)
+      
+      begin
+        return JSON.parse(RestClient::Request.execute(:method => :post, :url => @endpoint + uri, :headers => headers))
+      rescue RestClient::ExceptionWithResponse => e
+	url = @endpoint + uri
+	raise "Bad response from Reign server. Message = #{e.response}. URL = #{url}"
+      end
+    end
+    
+    def release_lease args
+      uri = Reign.generate_release_lease_uri args
+      headers = Reign.generate_header_for_request(:method => :post, :request_uri => uri, :api_key => @api_key,
+                                            :secret_key => @secret_key, :region => @region)
+
+      begin
+        return RestClient::Request.execute(:method => :post, :url => @endpoint + uri, :headers => headers)
+      rescue RestClient::ExceptionWithResponse => e
+        url = @endpoint + uri
+	raise "Bad response from Reign server. Message = #{e.response}. URL = #{url}"
+      end
+    end
+
+    def revoke_lease args
+      uri = Reign.generate_revoke_lease_uri args
+      headers = Reign.generate_header_for_request(:method => :post, :request_uri => uri, :api_key => @api_key,
+                                            :secret_key => @secret_key, :region => @region)
+      begin
+        return RestClient::Request.execute(:method => :post, :url => @endpoint + uri, :headers => headers)
+      rescue RestClient::ExceptionWithResponse => e
+        url = @endpoint + uri
+	raise "Bad response from Reign server. Message = #{e.response}. URL = #{url}"
+      end
+    end
+ 
+    def get_lease_info args
+      uri = Reign.generate_get_lease_uri args
+      headers = Reign.generate_header_for_request(:method => :get, :request_uri => uri, :api_key => @api_key,
+                                            :secret_key => @secret_key, :region => @region)
+      begin
+        return JSON.parse(RestClient::Request.execute(:method => :get, :url => @endpoint + uri, :headers => headers))
+      rescue RestClient::ExceptionWithResponse => e
+        url = @endpoint + uri
+	raise "Bad response from Reign server. Message = #{e.response}. URL = #{url}"
+      end
+    end
+
+    def create_watch_with_contacts args
+      args[:action] = "set"
+      return modify_watches_helper args
+    end
+
+    def add_contacts_to_watch args
+      args[:action] = "add"
+      if args[:sig] == nil
+        raise ArgumentError.new("Must pass sig parameter to modify watch") 
+      end
+      return modify_watches_helper args
+    end
+   
+    def remove_contacts_from_watch args
+      args[:action] = "rm"
+      if args[:sig] == nil
+        raise ArgumentError.new("Must pass sig parameter to modify watch") 
+      end
+      return modify_watches_helper args
+    end
+
+    def get_watches args
+      uri = Reign.generate_watch_uri(args[:namespace], args[:watch_entity_path])
+      headers = Reign.generate_header_for_request(:method => :get, :request_uri => uri, :api_key => @api_key,
+                                            :secret_key => @secret_key, :region => @region)
+      return RestClient::Request.execute(:method => :get, :url => @endpoint + uri, :headers => headers)
+    end
+ 
+    def modify_watches_helper args
+      sig = args[:sig]
+      template = Reign.generate_watch_body_template(args[:owner_id], args[:emails], args[:webhooks])
+      request_payload = JSON.generate(template)
+
+      query_params = {"op" => args[:action]}
+      if sig != nil
+        query_params["sig"] = sig
+      end
+      uri = Reign.generate_watch_uri(args[:namespace], args[:watch_entity_path]) + Reign.generate_query_string(query_params) 
+      headers = Reign.generate_header_for_request(:method => :post, :request_uri => uri, :api_key => @api_key,
+                                            :secret_key => @secret_key, :region => @region, :payload => request_payload)
+    
+      begin     
+        return JSON.parse(RestClient::Request.execute(:method => :post, :url => @endpoint + uri, :headers => headers,
+                                                      :payload => request_payload))
+      rescue => e
+        url = @endpoint + uri
+        raise "Bad response from Reign server.  Message: #{e.response}.  URL: #{url}. Request body: #{request_payload}"
+      end
+    end
+  end
+end
+

data/reign-client.gemspec

@@ -0,0 +1,11 @@
+Gem::Specification.new do |s|
+  s.name = 'reign-client'
+  s.version = '0.0.2'
+  s.summary = 'A simple blocking client for interaction against the Reign API.'
+  s.authors = ['Harrison Chu']
+  s.description = 'A simple blocking client for interaction against the Reign API.'
+  s.files = `git ls-files -z`.split("\0")
+
+  s.add_dependency('json', '~> 1.8')
+  s.add_dependency('rest-client', '~> 1.8')
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: reign-client
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Harrison Chu
@@ -43,7 +43,15 @@ email:
 executables: []
 extensions: []
 extra_rdoc_files: []
-files: []
+files:
+- ".gitignore"
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- lib/common.rb
+- lib/reign-client.rb
+- reign-client.gemspec
 homepage: 
 licenses: []
 metadata: {}