subaru 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1dd0e11ac22422831de4f5b6852fd029792f48a7
+  data.tar.gz: 769c66c9d6da8deb6292eabe37f21d70f1703c24
+SHA512:
+  metadata.gz: ccffba240eb408226b094ed8dff4cf2f4d357864419cdbd497e7d90f47d56c64980a04493bbe4ba4395279205e44cd62bbda59c2bad1be601d0827810dfccb2f
+  data.tar.gz: 06a7b92779b99595e2328de537251c187ae90f38f8502f84719974daeb61ca345307202bfb411c4bef31ca4b00fcd97e828bc80b31e6620200ff365fdd35b200

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Ken J.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

data/README.md

@@ -0,0 +1,79 @@
+# Subaru
+
+A gem to run RESTful (kinda) API server to industrial relays.
+
+The `subaru` command will launch a [Sinatra](http://www.sinatrarb.com) based server, functioning as a gateway to your web-enabled relays.
+
+## Supported Relays
+
+- Xytronix (a.k.a. ControlByWeb)
+  - WebRelay
+  - WebRelay-10
+
+I welcome requests for other relay equipment. If development/evaluation units can be provided, that would increase the likelyhood of support.
+
+## Requirements
+
+- Ruby 2.0.0 <=
+- [Kajiki](http://www.kenj.rocks/kajiki/) 1.1 <=
+- Sinatra 1.4 <=
+
+## Getting Started
+
+### Install
+
+```
+$ gem install subaru
+```
+
+### Configure
+
+Store configuration in a YAML file. If you need a template, just try to start Subaru without the `--config` option and it'll output an example.
+
+```yaml
+---
+:global:
+  :pretty_json: YES
+  :auth_tokens:
+    :any:
+      - abcd # This is the auth token. List as many as you want, or remove it to disable auth.
+
+:devices:
+  factory: # This is the device name to use in the URL.
+    :definition: Xytronix::WebRelay
+    :url: http://192.168.0.10
+    :password: password
+    :read_timeout: 15
+```
+
+### Run
+
+```
+$ subaru start -c config.yml
+```
+
+### Consume
+
+`GET` to read the state.
+
+```
+$ curl http://subaru/factory
+{
+  "relay": "off",
+  "input": "off"
+}
+```
+
+`PUT` to set the state.
+
+```
+$ curl -X PUT http://subaru/factory -d '{"relay":"on"}'
+{
+  "relay": "on",
+  "input": "off"
+}
+```
+
+## Security
+
+For obvious reasons, you should not expose this server to the public. If so, at least protect behind a reverse proxy, like NGINX, and/or require auth over HTTPS.

data/bin/subaru

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+require 'kajiki'
+require 'subaru'
+
+
+opts = Kajiki.preset_options(:server, {config: true, error: false, user: false})
+
+Kajiki.run(opts) do |cmd|
+  case cmd
+  when 'start'
+    Subaru::Server.run!(opts)
+  end
+end

data/lib/config_temp.yml

@@ -0,0 +1,13 @@
+---
+:global:
+  :pretty_json: YES
+  :auth_tokens:
+    :any:
+      - abcd
+
+:devices:
+  factory:
+    :definition: Xytronix::WebRelay
+    :url: http://192.168.0.10
+    :password: password
+    :read_timeout: 15

data/lib/subaru.rb

@@ -0,0 +1,63 @@
+require 'sinatra/base'
+require 'yaml'
+require 'subaru/helper'
+
+
+module Subaru
+
+  # The Sinatra server
+  class Server < Sinatra::Base
+
+    def self.run!(opts = {})
+      unless opts[:config]
+        puts "Configuration file required. Example:\n\n"
+        puts IO.read(File.expand_path('../config_temp.yml', __FILE__))
+        abort
+      end
+      config = YAML.load_file(opts[:config])
+      super(bind: opts[:address], port: opts[:port], subaru_config: config)
+    end
+
+    helpers Helper
+
+    configure do
+      disable :static
+    end
+
+    before do
+      halt 401 unless valid_token?(params[:auth])
+    end
+
+    get '/:device' do |device|
+      dev = device_with_name(device)
+      halt 404 unless dev
+      res = dev.read
+      halt 500 unless res
+      json_with_object(res)
+    end
+
+    put '/:device' do |device|
+      dev = device_with_name(device)
+      halt 404 unless dev
+      request.body.rewind  # in case someone already read it
+      res = dev.write(request.body.read)
+      halt 500 unless res
+      json_with_object(res)
+    end
+
+    not_found do
+      json_with_object({message: 'Not found.'})
+    end
+
+    error 401 do
+      json_with_object({message: 'Auth required.'})
+    end
+
+    error do
+      status 500
+      json_with_object({message: 'Sorry, internal error.'})
+    end
+
+  end
+
+end

data/lib/subaru/d-xytronix.rb

@@ -0,0 +1,155 @@
+require 'open-uri'
+require 'uri'
+require 'rexml/document'
+
+
+module Subaru
+
+  module Definitions
+
+    module Xytronix
+
+      module Common
+        attr_accessor :options
+
+        # @param url [String] device url; e.g., `http://10.1.1.11:8888`.
+        # @param opts [Hash] the device options.
+        def initialize(opts = {})
+          @options = opts
+        end
+
+        # Generate query string.
+        # @param query_hash [hash] resources and their state to set to.
+        # @return [String] query string.
+        def generate_query(query_hash)
+          return nil unless query_hash.class == Hash
+          h = {}
+          query_hash.each do |k, v|
+            case v
+            when "off"
+              h["#{k}State"] = 0
+            when "on"
+              h["#{k}State"] = 1
+            end
+          end
+          return nil if h.empty?
+          return URI.encode_www_form(h)
+        end
+
+        # Access the device.
+        # @param query [String] encoded query string.
+        # @return [Object] XML document returned from the device.
+        def send_request(query = nil)
+          uri = "#{@options[:url]}/stateFull.xml"
+          uri << "?#{query}" if query
+          o = {}
+          o[:http_basic_authentication] = [nil, @options[:password]] if @options[:password]
+          o[:read_timeout] = @options[:read_timeout] if @options[:read_timeout]
+          response = open(uri, o)
+          return REXML::Document.new(response.read)
+        rescue => e
+          puts e.message
+          return nil
+        end
+
+        # Search the XML document.
+        # @param doc [Object] XML document.
+        # @param resource [String] resource name to search.
+        # @param ch [Fixnum] resource channel number.
+        # @return [String] state of the resource; e.g., `on`, `off`.
+        def state_from_xml(doc, resource, ch = nil)
+          case REXML::XPath.first(doc, "//datavalues/#{resource}#{ch}state").text.to_i
+          when 0
+            s = "off"
+          when 1
+            s = "on"
+          else
+            s = "unknown"
+          end
+          return s
+        rescue => e
+          puts e.message
+          return nil
+        end
+
+      end
+
+      class WebRelay
+        include Common
+
+        # Read resources from device.
+        # @return [Hash] resources and their state.
+        def read
+          return parse_xml(send_request)
+        end
+
+        # Set resource state of a device.
+        # @param data [String] POST/PUT data.
+        # @return [Hash] resulting resources and their state.
+        def write(data)
+          q = generate_query(JSON.parse(data))
+          return nil unless q
+          return parse_xml(send_request(q))
+        rescue => e
+          puts e.message
+          return nil
+        end
+
+        # Parse XML document response.
+        # @param xml [Object] XML document.
+        # @return [Hash]
+        def parse_xml(xml)
+          results = {}
+          ['relay', 'input'].each do |r|
+            results[r] = state_from_xml(xml, r)
+          end
+          return results
+        rescue => e
+          puts e.message
+          return nil
+        end
+
+      end
+
+      class WebRelay10
+        include Common
+
+        # Read resources from device.
+        # @return [Hash] resources and their state.
+        def read
+          return parse_xml(send_request)
+        end
+
+        # Set resource state of a device.
+        # @param data [String] POST/PUT data.
+        # @return [Hash] resulting resources and their state.
+        def write(data)
+          q = generate_query(JSON.parse(data))
+          return nil unless q
+          return parse_xml(send_request(q))
+        rescue => e
+          puts e.message
+          return nil
+        end
+
+        # Parse XML document response.
+        # @param xml [Object] XML document.
+        # @return [Hash]
+        def parse_xml(xml)
+          results = {}
+          (1..10).each do |ch|
+            results["relay#{ch}"] = state_from_xml(xml, 'relay', ch)
+          end
+          return results
+        rescue => e
+          puts e.message
+          return nil
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/subaru/helper.rb

@@ -0,0 +1,48 @@
+require 'json'
+require 'subaru/d-xytronix'
+
+
+module Subaru
+  
+  # Sinatra helper
+  module Helper
+
+    # Convert object into JSON.
+    def json_with_object(object, opts = {pretty: settings.subaru_config[:global][:pretty_json]})
+      return '{}' if object.nil?
+      if opts[:pretty] == true
+        opts = {
+          indent: '  ',
+          space: ' ',
+          object_nl: "\n",
+          array_nl: "\n"
+        }
+      end
+      JSON.fast_generate(object, opts)
+    rescue => e
+      puts e.message
+      raise
+    end
+
+    # Validate auth token, if configured.
+    def valid_token?(token, method = :any)
+      tokens = settings.subaru_config[:global][:auth_tokens][method]
+      return true if tokens.nil?
+      tokens.include?(token)
+    end
+
+    # Create device object with name
+    # @param name [String]
+    # @return [Object]
+    def device_with_name(name)
+      c = settings.subaru_config[:devices][name]
+      return Object.const_get("Subaru::Definitions::#{c[:definition]}").new(c) if c
+    rescue => e
+      puts e.message
+      return nil
+    end
+
+  end
+
+end
+

data/subaru.gemspec

@@ -0,0 +1,17 @@
+Gem::Specification.new do |s|
+  s.name          = "subaru"
+  s.version       = "1.0.0"
+  s.authors       = ["Ken J."]
+  s.email         = ["kenjij@gmail.com"]
+  s.description   = %q{RESTful API to industrial web relays}
+  s.summary       = %q{RESTful API server gem to industrial web relays.}
+  s.homepage      = "https://github.com/kenjij/subaru"
+  s.license       = "MIT"
+
+  s.files         = `git ls-files`.split($/)
+  s.executables   = s.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_runtime_dependency "kajiki", "~> 1.1"
+  s.add_runtime_dependency "sinatra", "~> 1.4"
+end

metadata

@@ -0,0 +1,81 @@
+--- !ruby/object:Gem::Specification
+name: subaru
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Ken J.
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-04-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: kajiki
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: sinatra
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+description: RESTful API to industrial web relays
+email:
+- kenjij@gmail.com
+executables:
+- subaru
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- bin/subaru
+- lib/config_temp.yml
+- lib/subaru.rb
+- lib/subaru/d-xytronix.rb
+- lib/subaru/helper.rb
+- subaru.gemspec
+homepage: https://github.com/kenjij/subaru
+licenses:
+- MIT
+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.4.3
+signing_key: 
+specification_version: 4
+summary: RESTful API server gem to industrial web relays.
+test_files: []