cgminer_api_client 0.2.6

data/lib/cgminer_api_client/miner/commands.rb

@@ -0,0 +1,201 @@
+module CgminerApiClient
+  class Miner
+    module Commands
+      module ReadOnly
+        def asc(number)
+          query(:asc, number)
+        end
+
+        def asccount
+          query(:asccount)
+        end
+
+        def check(command)
+          query(:check, command)[0]
+        end
+
+        def coin
+          query(:coin)[0]
+        end
+
+        def config
+          query(:config)[0]
+        end
+
+        def devdetails
+          query(:devdetails)
+        end
+
+        def devs
+          query(:devs)
+        end
+
+        def pga(number)
+          query(:pga, number)
+        end
+
+        def pgacount
+          query(:pgacount)
+        end
+
+        def pools
+          query(:pools)
+        end
+
+        def privileged
+            query(:privileged)
+            true
+          rescue
+            false
+
+        end
+
+        def notify
+          query(:notify)
+        end
+
+        def stats
+          query(:stats)
+        end
+
+        def summary
+          query(:summary)[0]
+        end
+
+        def usbstats
+          query(:usbstats)
+        end
+
+        def version
+          query(:version)[0]
+        end
+      end
+
+      module Privileged
+        module Asc
+          def ascdisable(number)
+            query(:ascdisable, number) unless access_denied?
+          end
+
+          def ascenable(number)
+            query(:ascenable, number) unless access_denied?
+          end
+
+          def ascidentify(number)
+            query(:ascidentify, number) unless access_denied?
+          end
+
+          def ascset(number, option, value = nil)
+            unless access_denied?
+              value ? query(:ascset, number, option, value) : query(:ascset, number, option)
+            end
+          end
+        end
+
+        module Pga
+          def pgadisable(number)
+            query(:pgadisable, number) unless access_denied?
+          end
+
+          def pgaenable(number)
+            query(:pgaenable, number) unless access_denied?
+          end
+
+          def pgaidentify(number)
+            query(:pgaidentify, number) unless access_denied?
+          end
+
+          def pgaset(number, option, value = nil)
+            unless access_denied?
+              value ? query(:pgaset, number, option, value) : query(:pgaset, number, option)
+            end
+          end
+        end
+
+        module Pool
+          def addpool(url, user, pass)
+            query(:addpool, url, user, pass) unless access_denied?
+          end
+
+          def disablepool(number)
+            query(:disablepool, number) unless access_denied?
+          end
+
+          def enablepool(number)
+            query(:enablepool, number) unless access_denied?
+          end
+
+          def poolpriority(*id_order)
+            query(:poolpriority, *id_order) unless access_denied?
+          end
+
+          def poolquota(number, value)
+            query(:poolquota, number, value) unless access_denied?
+          end
+
+          def removepool(number)
+            query(:removepool, number) unless access_denied?
+          end
+
+          def switchpool(number)
+            query(:switchpool, number) unless access_denied?
+          end
+        end
+
+        module System
+          def debug(setting = 'D')
+            query(:debug, setting) unless access_denied?
+          end
+
+          def failover_only(value)
+            query(:'failover-only', value) unless access_denied?
+          end
+
+          def hotplug(seconds)
+            query(:hotplug, seconds) unless access_denied?
+          end
+
+          def quit
+            query(:quit) unless access_denied?
+          end
+
+          def restart
+            query(:restart) unless access_denied?
+          end
+
+          def save(filename = nil)
+            unless access_denied?
+              filename ? query(:save, filename) : query(:save)
+            end
+          end
+
+          def setconfig(name, value)
+            query(:setconfig, name, value) unless access_denied?
+          end
+
+          def zero(which = 'All', full_summary = false)
+            query(:zero, which, full_summary) unless access_denied?
+          end
+        end
+
+        private
+
+        def access_denied?
+          if !privileged
+            raise 'access_denied'
+          else
+            return false
+          end
+        end
+
+        include Miner::Commands::Privileged::Asc
+        include Miner::Commands::Privileged::Pga
+        include Miner::Commands::Privileged::Pool
+        include Miner::Commands::Privileged::System
+      end
+
+      include Miner::Commands::ReadOnly
+      include Miner::Commands::Privileged
+    end
+  end
+end

data/lib/cgminer_api_client/miner_pool.rb

@@ -0,0 +1,68 @@
+module CgminerApiClient
+  class MinerPool
+    include Miner::Commands
+
+    attr_accessor :miners
+
+    def initialize
+      load_miners!
+    end
+
+    def reload_miners!
+      @miners = nil
+      load_miners!
+    end
+
+    def query(method, *params)
+      threads = @miners.collect do |miner|
+        Thread.new do
+          begin
+            miner.query(method, *params)
+          rescue => e
+            $stderr.puts "#{e.class}: #{e}"
+            []
+          end
+        end
+      end
+      threads.each { |thr| thr.join }
+      threads.collect(&:value)
+    end
+
+    def available_miners(force_reload = false)
+      threads = @miners.collect do |miner|
+        Thread.new do
+          begin
+            miner if miner.available?(force_reload)
+          rescue
+            nil
+          end
+        end
+      end
+      threads.each { |thr| thr.join }
+      threads.collect(&:value).compact
+    end
+
+    def unavailable_miners(force_reload = false)
+      @miners - available_miners(force_reload)
+    end
+
+    def method_missing(name, *args)
+      query(name, *args)
+    end
+
+    private
+
+    def load_miners!
+      raise 'Please create config/miners.yml' unless File.exist?('config/miners.yml')
+
+      miners_config = YAML.load_file('config/miners.yml')
+      @miners = miners_config.collect{|miner|
+        CgminerApiClient::Miner.new(
+          miner['host'],
+          miner['port'],
+          miner['timeout']
+        )
+      }
+    end
+  end
+end

data/lib/cgminer_api_client/socket_with_timeout.rb

@@ -0,0 +1,30 @@
+module CgminerApiClient
+  module SocketWithTimeout
+    def open_socket(host, port, timeout)
+      addr     = Socket.getaddrinfo(host, nil)
+      sockaddr = Socket.pack_sockaddr_in(port, addr[0][3])
+
+      Socket.new(Socket.const_get(addr[0][0]), Socket::SOCK_STREAM, 0).tap do |socket|
+        socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
+
+        begin
+          socket.connect_nonblock(sockaddr)
+        rescue IO::WaitWritable
+          if IO.select(nil, [socket], nil, timeout)
+            begin
+              socket.connect_nonblock(sockaddr)
+            rescue Errno::EISCONN
+              # the socket is connected
+            rescue
+              socket.close
+              raise
+            end
+          else
+            socket.close
+            raise "Connection timeout"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cgminer_api_client/version.rb

@@ -0,0 +1,3 @@
+module CgminerApiClient
+  VERSION = "0.2.6"
+end

data/spec/cgminer_api_client/miner/commands_spec.rb

@@ -0,0 +1,501 @@
+require 'spec_helper'
+
+describe CgminerApiClient::Miner::Commands do
+  let(:host)     { '127.0.0.1' }
+  let(:port)     { 4028 }
+  let(:instance) { CgminerApiClient::Miner.new(host, port) }
+
+  describe CgminerApiClient::Miner::Commands::ReadOnly do
+    context '#asc' do
+      it 'should require one argument' do
+        expect {
+          instance.asc
+        }.to raise_error(ArgumentError, 'wrong number of arguments (given 0, expected 1)')
+      end
+
+      it 'should query the miner' do
+        expect(instance).to receive(:query).with(:asc, 0).and_return('asc' => {})
+        instance.asc(0)
+      end
+    end
+
+    context '#asccount' do
+      it 'should query the miner' do
+        expect(instance).to receive(:query).with(:asccount).and_return('asccount' => {})
+        instance.asccount
+      end
+    end
+
+    context '#check' do
+      it 'should require one argument' do
+        expect {
+          instance.check
+        }.to raise_error(ArgumentError, 'wrong number of arguments (given 0, expected 1)')
+      end
+
+      it 'should query the miner' do
+        expect(instance).to receive(:query).with(:check, :foo).and_return('foo' => [{}])
+        instance.check(:foo)
+      end
+    end
+
+    context '#coin' do
+      it 'should query the miner' do
+        expect(instance).to receive(:query).with(:coin).and_return('coin' => [{}])
+        instance.coin
+      end
+    end
+
+    context '#config' do
+      it 'should query the miner' do
+        expect(instance).to receive(:query).with(:config).and_return('config' => [{}])
+        instance.config
+      end
+    end
+
+    context '#devdetails' do
+      it 'should query the miner' do
+        expect(instance).to receive(:query).with(:devdetails).and_return('devdetails' => [{}])
+        instance.devdetails
+      end
+    end
+
+    context '#devs' do
+      it 'should query the miner' do
+        expect(instance).to receive(:query).with(:devs).and_return('devs' => [{}])
+        instance.devs
+      end
+    end
+
+    context '#pga' do
+      it 'should require one argument' do
+        expect {
+          instance.pga
+        }.to raise_error(ArgumentError, 'wrong number of arguments (given 0, expected 1)')
+      end
+
+      it 'should query the miner' do
+        expect(instance).to receive(:query).with(:pga, 0).and_return('pga' => [{}])
+        instance.pga(0)
+      end
+    end
+
+    context '#pgacount' do
+      it 'should query the miner' do
+        expect(instance).to receive(:query).with(:pgacount).and_return('pgacount' => [{}])
+        instance.pgacount
+      end
+    end
+
+    context '#pools' do
+      it 'should query the miner' do
+        expect(instance).to receive(:query).with(:pools).and_return('pools' => [{}])
+        instance.pools
+      end
+    end
+
+    context '#privileged' do
+      it 'should query the miner' do
+        expect(instance).to receive(:query).with(:privileged).and_return(nil)
+        instance.privileged
+      end
+
+      context 'an exception' do
+        before do
+          expect(instance).to receive(:query).with(:privileged).and_raise('something')
+        end
+
+        it 'should return false' do
+          expect(instance.privileged).to eq false
+        end
+      end
+
+      context 'success' do
+        before do
+          expect(instance).to receive(:query).with(:privileged).and_return(nil)
+        end
+
+        it 'should return true' do
+          expect(instance.privileged).to eq true
+        end
+      end
+    end
+
+    context '#notify' do
+      it 'should query the miner' do
+        expect(instance).to receive(:query).with(:notify).and_return('notify' => [{}])
+        instance.notify
+      end
+    end
+
+    context '#stats' do
+      it 'should query the miner' do
+        expect(instance).to receive(:query).with(:stats).and_return('stats' => [{}])
+        instance.stats
+      end
+    end
+
+    context '#summary' do
+      it 'should query the miner' do
+        expect(instance).to receive(:query).with(:summary).and_return('summary' => [{}])
+        instance.summary
+      end
+    end
+
+    context '#usbstats' do
+      it 'should query the miner' do
+        expect(instance).to receive(:query).with(:usbstats).and_return('usbstats' => [{}])
+        instance.usbstats
+      end
+    end
+
+    context '#version' do
+      it 'should query the miner' do
+        expect(instance).to receive(:query).with(:version).and_return('version' => [{}])
+        instance.version
+      end
+    end
+  end
+
+  describe CgminerApiClient::Miner::Commands::Privileged do
+    context 'access_denied?' do
+      context 'when not privileged' do
+        before do
+          allow(instance).to receive(:privileged).and_return(false)
+        end
+
+        it 'should raise an error' do
+          expect {
+            instance.send(:access_denied?)
+          }.to raise_error('access_denied')
+        end
+      end
+
+      context 'when privileged' do
+        before do
+          allow(instance).to receive(:privileged).and_return(true)
+        end
+
+        it 'should return false' do
+          expect(instance.send(:access_denied?)).to eq false
+        end
+      end
+    end
+
+    describe CgminerApiClient::Miner::Commands::Privileged::Asc do
+      before do
+        allow(instance).to receive(:access_denied?).and_return(false)
+      end
+
+      context 'ascdisable' do
+        it 'should require one argument' do
+          expect {
+            instance.ascdisable
+          }.to raise_error(ArgumentError, 'wrong number of arguments (given 0, expected 1)')
+        end
+
+        it 'should query the miner with arguments' do
+          expect(instance).to receive(:query).with(:ascdisable, :number)
+          instance.ascdisable(:number)
+        end
+      end
+
+      context 'ascenable' do
+        it 'should require one argument' do
+          expect {
+            instance.ascenable
+          }.to raise_error(ArgumentError, 'wrong number of arguments (given 0, expected 1)')
+        end
+
+        it 'should query the miner with arguments' do
+          expect(instance).to receive(:query).with(:ascenable, :number)
+          instance.ascenable(:number)
+        end
+      end
+
+      context 'ascidentify' do
+        it 'should require one argument' do
+          expect {
+            instance.ascidentify
+          }.to raise_error(ArgumentError, 'wrong number of arguments (given 0, expected 1)')
+        end
+
+        it 'should query the miner with arguments' do
+          expect(instance).to receive(:query).with(:ascidentify, :number)
+          instance.ascidentify(:number)
+        end
+      end
+
+      context 'ascset' do
+        it 'should require 2-3 arguments' do
+          expect {
+            instance.ascset
+          }.to raise_error(ArgumentError, 'wrong number of arguments (given 0, expected 2..3)')
+        end
+
+        it 'should query the miner with 2 arguments' do
+          expect(instance).to receive(:query).with(:ascset, :number, :foo)
+          instance.ascset(:number, :foo)
+        end
+
+        it 'should query the miner with 3 arguments' do
+          expect(instance).to receive(:query).with(:ascset, :number, :foo, :bar)
+          instance.ascset(:number, :foo, :bar)
+        end
+      end
+    end
+
+    describe CgminerApiClient::Miner::Commands::Privileged::Pga do
+      before do
+        allow(instance).to receive(:access_denied?).and_return(false)
+      end
+
+      context 'pgadisable' do
+        it 'should require one argument' do
+          expect {
+            instance.pgadisable
+          }.to raise_error(ArgumentError, 'wrong number of arguments (given 0, expected 1)')
+        end
+
+        it 'should query the miner with arguments' do
+          expect(instance).to receive(:query).with(:pgadisable, :number)
+          instance.pgadisable(:number)
+        end
+      end
+
+      context 'pgaenable' do
+        it 'should require one argument' do
+          expect {
+            instance.pgaenable
+          }.to raise_error(ArgumentError, 'wrong number of arguments (given 0, expected 1)')
+        end
+
+        it 'should query the miner with arguments' do
+          expect(instance).to receive(:query).with(:pgaenable, :number)
+          instance.pgaenable(:number)
+        end
+      end
+
+      context 'pgaidentify' do
+        it 'should require one argument' do
+          expect {
+            instance.pgaidentify
+          }.to raise_error(ArgumentError, 'wrong number of arguments (given 0, expected 1)')
+        end
+
+        it 'should query the miner with arguments' do
+          expect(instance).to receive(:query).with(:pgaidentify, :number)
+          instance.pgaidentify(:number)
+        end
+      end
+
+      context 'pgaset' do
+        it 'should require 2-3 arguments' do
+          expect {
+            instance.pgaset
+          }.to raise_error(ArgumentError, 'wrong number of arguments (given 0, expected 2..3)')
+        end
+
+        it 'should query the miner with 2 arguments' do
+          expect(instance).to receive(:query).with(:pgaset, :number, :foo)
+          instance.pgaset(:number, :foo)
+        end
+
+        it 'should query the miner with 3 arguments' do
+          expect(instance).to receive(:query).with(:pgaset, :number, :foo, :bar)
+          instance.pgaset(:number, :foo, :bar)
+        end
+      end
+    end
+
+    describe CgminerApiClient::Miner::Commands::Privileged::Pool do
+      before do
+        allow(instance).to receive(:access_denied?).and_return(false)
+      end
+
+      context 'addpool' do
+        it 'should require three arguments' do
+          expect {
+            instance.addpool
+          }.to raise_error(ArgumentError, 'wrong number of arguments (given 0, expected 3)')
+        end
+
+        it 'should query the miner with arguments' do
+          expect(instance).to receive(:query).with(:addpool, :url, :user, :pass)
+          instance.addpool(:url, :user, :pass)
+        end
+      end
+
+      context 'disablepool' do
+        it 'should require one argument' do
+          expect {
+            instance.disablepool
+          }.to raise_error(ArgumentError, 'wrong number of arguments (given 0, expected 1)')
+        end
+
+        it 'should query the miner with arguments' do
+          expect(instance).to receive(:query).with(:disablepool, :pool_number)
+          instance.disablepool(:pool_number)
+        end
+      end
+
+      context 'enablepool' do
+        it 'should require one argument' do
+          expect {
+            instance.enablepool
+          }.to raise_error(ArgumentError, 'wrong number of arguments (given 0, expected 1)')
+        end
+
+        it 'should query the miner with arguments' do
+          expect(instance).to receive(:query).with(:enablepool, :pool_number)
+          instance.enablepool(:pool_number)
+        end
+      end
+
+      context 'poolpriority' do
+        it 'should query the miner with arguments' do
+          expect(instance).to receive(:query).with(:poolpriority, :pool_number_1, :pool_number_2, :pool_number_3)
+          instance.poolpriority(:pool_number_1, :pool_number_2, :pool_number_3)
+        end
+      end
+
+      context 'poolquota' do
+        it 'should require two arguments' do
+          expect {
+            instance.poolquota
+          }.to raise_error(ArgumentError, 'wrong number of arguments (given 0, expected 2)')
+        end
+
+        it 'should query the miner with arguments' do
+          expect(instance).to receive(:query).with(:poolquota, :pool_number, :quota)
+          instance.poolquota(:pool_number, :quota)
+        end
+      end
+
+      context 'removepool' do
+        it 'should require one argument' do
+          expect {
+            instance.removepool
+          }.to raise_error(ArgumentError, 'wrong number of arguments (given 0, expected 1)')
+        end
+
+        it 'should query the miner with arguments' do
+          expect(instance).to receive(:query).with(:removepool, :pool_number)
+          instance.removepool(:pool_number)
+        end
+      end
+
+      context 'switchpool' do
+        it 'should require one argument' do
+          expect {
+            instance.switchpool
+          }.to raise_error(ArgumentError, 'wrong number of arguments (given 0, expected 1)')
+        end
+
+        it 'should query the miner with arguments' do
+          expect(instance).to receive(:query).with(:switchpool, :pool_number)
+          instance.switchpool(:pool_number)
+        end
+      end
+    end
+
+    describe CgminerApiClient::Miner::Commands::Privileged::System do
+      before do
+        allow(instance).to receive(:access_denied?).and_return(false)
+      end
+
+      context 'debug' do
+        it 'should query the miner with defaults' do
+          expect(instance).to receive(:query).with(:debug, 'D')
+          instance.debug
+        end
+
+        it 'should query the miner with arguments' do
+          expect(instance).to receive(:query).with(:debug, :setting)
+          instance.debug(:setting)
+        end
+      end
+
+      context 'failover_only' do
+        it 'should require one argument' do
+          expect {
+            instance.failover_only
+          }.to raise_error(ArgumentError, 'wrong number of arguments (given 0, expected 1)')
+        end
+
+        it 'should query the miner with arguments' do
+          expect(instance).to receive(:query).with(:'failover-only', :value)
+          instance.failover_only(:value)
+        end
+      end
+
+      context 'hotplug' do
+        it 'should require one argument' do
+          expect {
+            instance.hotplug
+          }.to raise_error(ArgumentError, 'wrong number of arguments (given 0, expected 1)')
+        end
+
+        it 'should query the miner with arguments' do
+          expect(instance).to receive(:query).with(:hotplug, :value)
+          instance.hotplug(:value)
+        end
+      end
+
+      context 'quit' do
+        it 'should query the miner' do
+          expect(instance).to receive(:query).with(:quit)
+          instance.quit
+        end
+      end
+
+      context 'restart' do
+        it 'should query the miner' do
+          expect(instance).to receive(:query).with(:restart)
+          instance.restart
+        end
+      end
+
+      context 'save' do
+        context 'without filename' do
+          it 'should query the miner' do
+            expect(instance).to receive(:query).with(:save)
+            instance.save
+          end
+        end
+
+        context 'with filename' do
+          it 'should query the miner with arguments' do
+            expect(instance).to receive(:query).with(:save, :filename)
+            instance.save(:filename)
+          end
+        end
+      end
+
+      context 'setconfig' do
+        it 'should require two arguments' do
+          expect {
+            instance.setconfig
+          }.to raise_error(ArgumentError, 'wrong number of arguments (given 0, expected 2)')
+        end
+
+        it 'should query the miner with arguments' do
+          expect(instance).to receive(:query).with(:setconfig, :name, :value)
+          instance.setconfig(:name, :value)
+        end
+      end
+
+      context 'zero' do
+        it 'should query the miner with defaults' do
+          expect(instance).to receive(:query).with(:zero, 'All', false)
+          instance.zero
+        end
+
+        it 'should query the miner with arguments' do
+          expect(instance).to receive(:query).with(:zero, :which, :full_summary)
+          instance.zero(:which, :full_summary)
+        end
+      end
+    end
+  end
+end