pvdgm-bs-client 0.1.0

data/lib/pvdgm-bs-client/prompters/job_prompter.rb

@@ -0,0 +1,32 @@
+module JobPrompter
+
+  def job_id(allow_none=false)
+    return options[:job_id] if options[:job_id]
+    return options[:job_id] = ENV['JOB_ID'] if ENV['JOB_ID']
+    return options[:job_Id] = prompt_for_job_id(allow_none)
+  end
+
+  private
+
+  def prompt_for_job_id(allow_none)
+    puts
+    command = prompter.choose do | menu |
+      menu.prompt = "Which tube state do you want to peek into? "
+      menu.choice("Ready") { 'ready' }
+      menu.choice("Delayed") { 'delayed' }
+      menu.choice("Buried") { 'buried' }
+    end
+    
+    result = get("beanstalk/tubes/#{Base64.urlsafe_encode64(tube_name)}/#{command}")
+    return -1 if result.has_key?('error')
+
+    # Build a menu of the job
+    puts
+    return prompter.choose do | menu |
+      menu.prompt = "Select the job: "
+      menu.choice("No Selection") { -1 } if allow_none
+      menu.choice("Job ID: #{result.keys.first}") { result.keys.first }
+    end
+  end
+
+end

data/lib/pvdgm-bs-client/prompters/to_tube_prompter.rb

@@ -0,0 +1,25 @@
+module ToTubePrompter
+
+  def to_tube_name(allow_none=false)
+    return options[:to_tube] if options[:to_tube]
+    return options[:to_tube] = ENV['TO_TUBE_NAME'] if ENV['TO_TUBE_NAME']
+    return options[:to_tube] = prompt_for_to_tube_name(allow_none)
+  end
+
+  private
+
+  def prompt_for_to_tube_name(allow_none)
+    result = get("beanstalk/tubes")
+
+    # Build a menu of the tube names
+    puts
+    return prompter.choose do | menu |
+      menu.prompt = "Select the destination beanstalk tube: "
+      menu.choice("No Selection") { -1 } if allow_none
+      result.each do | tube_name |
+        menu.choice(tube_name) { tube_name }
+      end
+    end
+  end
+
+end

data/lib/pvdgm-bs-client/prompters/tube_prompter.rb

@@ -0,0 +1,25 @@
+module TubePrompter
+
+  def tube_name(allow_none=false)
+    return options[:tube] if options[:tube]
+    return options[:tube] = ENV['TUBE_NAME'] if ENV['TUBE_NAME']
+    return options[:tube] = prompt_for_tube_name(allow_none)
+  end
+
+  private
+
+  def prompt_for_tube_name(allow_none)
+    result = get("beanstalk/tubes")
+
+    # Build a menu of the tube names
+    puts
+    return prompter.choose do | menu |
+      menu.prompt = "Select the beanstalk tube: "
+      menu.choice("No Selection") { -1 } if allow_none
+      result.each do | tube_name |
+        menu.choice(tube_name) { tube_name }
+      end
+    end
+  end
+
+end

data/lib/pvdgm-bs-client/resources/job.rb

@@ -0,0 +1,61 @@
+module Resources
+
+  class Job < BaseResource
+    include TubePrompter
+    include JobPrompter
+
+    def list
+      tube = tube_name
+      job = job_id
+
+      if job == -1
+        puts "\nNo jobs in state"
+        puts
+        return
+      end
+
+      result = get("beanstalk/jobs/#{job}")
+
+      if result.has_key?('error')
+        puts
+        puts result['error']
+      else
+        table = Terminal::Table.new headings: [ 'Id', 'Body' ] do | t |
+          t << [ result['job'].keys.first, result['job'].values.first ]
+        end
+        puts table
+        puts
+
+        table = Terminal::Table.new headings: [ 'Key', 'Value' ] do | t |
+          result['statistics'].each_pair do | key, value |
+            t << [ key, value ]
+          end
+        end
+        puts table
+      end
+      puts
+    end
+
+    def destroy
+      tube = tube_name
+      job = job_id(true)
+
+      if job == -1
+        puts "\nNo jobs in state"
+        puts
+        return
+      end
+
+      result = delete("beanstalk/jobs/#{job}")
+      if result.has_key?('error')
+        puts
+        puts result['error']
+      else
+        puts result['job']
+      end
+      puts
+    end
+
+  end
+
+end

data/lib/pvdgm-bs-client/resources/statistics.rb

@@ -0,0 +1,29 @@
+module Resources
+
+  class Statistics < BaseResource
+
+    def list
+
+      filter = Proc.new do | key |
+        if options[:all_stats]
+          true
+        else
+          not key =~ /(^cmd-|^max-|^pid|^version|^rusage|^binlog|^id)/
+        end
+      end
+
+      result = get("beanstalk")
+      puts "\nBeanstalk global statistics"
+      table = Terminal::Table.new headings: [ 'Key', 'Value' ] do | t |
+        result.keys.sort.each do | key |
+          next unless filter.call(key)
+          t << [ key, result[key] ]
+        end
+      end
+      puts table
+      puts
+    end
+
+  end
+
+end

data/lib/pvdgm-bs-client/resources/tube.rb

@@ -0,0 +1,124 @@
+module Resources
+
+  class Tube < BaseResource
+    include TubePrompter
+    include ToTubePrompter
+
+    def list
+      result = get("beanstalk/tubes")
+      puts "\nBeanstalk tubes"
+      table = Terminal::Table.new headings: [ 'Tube Name' ] do | t |
+        result.each do | tube_name |
+          t << [ tube_name ]
+        end
+      end
+      puts table
+      puts
+    end
+
+    def show
+      tube = tube_name
+      result = get("beanstalk/tubes/#{Base64.urlsafe_encode64(tube_name)}")
+      puts "\nStatistics for tube: #{tube}"
+      table = Terminal::Table.new headings: [ 'Key', 'Value' ] do | t |
+        result.each_pair do | key, value |
+          t << [ key, value ]
+        end
+      end
+      puts table
+      puts
+    end
+
+    def ready
+      tube = tube_name
+      result = get("beanstalk/tubes/#{Base64.urlsafe_encode64(tube_name)}/ready")
+      if result.has_key?('error')
+        puts
+        puts result['error']
+      else
+        puts "\nJobs in the Ready state:"
+        table = Terminal::Table.new headings: [ 'Id', 'Body' ] do | t |
+          t << [ result.keys.first, result.values.first ]
+        end
+        puts table
+      end
+      puts
+    end
+
+    def delayed
+      tube = tube_name
+      result = get("beanstalk/tubes/#{Base64.urlsafe_encode64(tube_name)}/delayed")
+      if result.has_key?('error')
+        puts
+        puts result['error']
+      else
+        puts "\nJobs in the Delayed state:"
+        table = Terminal::Table.new headings: [ 'Id', 'Body' ] do | t |
+          t << [ result.keys.first, result.values.first ]
+        end
+        puts table
+      end
+      puts
+    end
+
+    def buried
+      tube = tube_name
+      result = get("beanstalk/tubes/#{Base64.urlsafe_encode64(tube_name)}/buried")
+      if result.has_key?('error')
+        puts
+        puts result['error']
+      else
+        puts "\nJobs in the Buried state:"
+        table = Terminal::Table.new headings: [ 'Id', 'Body' ] do | t |
+          t << [ result.keys.first, result.values.first ]
+        end
+        puts table
+      end
+      puts
+    end
+
+    def delete_one_job
+      tube = tube_name
+      result = delete("beanstalk/tubes/#{Base64.urlsafe_encode64(tube_name)}/one_job")
+      puts "\nJob deleted"
+      puts result['eat_job']
+      puts
+    end
+
+    def delete_all_jobs
+      tube = tube_name
+      result = delete("beanstalk/tubes/#{Base64.urlsafe_encode64(tube_name)}/all_jobs")
+      puts "\nAll jobs deleted"
+      puts result['eat_job']
+      puts
+    end
+
+    def move
+      tube = tube_name
+      to_tube = to_tube_name
+      result = delete("beanstalk/tubes/#{Base64.urlsafe_encode64(tube_name)}/move/#{Base64.urlsafe_encode64(to_tube)}")
+      puts "\nAll jobs moved from '#{tube}' to '#{to_tube}':"
+      puts result['eat_job']
+      puts
+    end
+
+    def kill_worker
+      tube = tube_name
+      result = delete("beanstalk/tubes/#{Base64.urlsafe_encode64(tube_name)}/worker")
+      puts "\nWorker killed:"
+      puts result['kill_worker']
+      puts
+    end
+
+    def kick
+      tube = tube_name
+      num_jobs = prompter.ask("Number of jobs to kick: ", Integer) { |q| q.default = 1 }
+      result = get("beanstalk/tubes/#{Base64.urlsafe_encode64(tube_name)}/kick/#{num_jobs}")
+      puts "\nKick #{num_jobs} in tube '#{tube}':"
+      puts result['kick']
+      puts
+    end
+
+  end
+
+end

data/spec/base_resource_spec.rb

@@ -0,0 +1,208 @@
+require 'spec_helper'
+
+describe BaseResource do
+
+  context 'Private Methods' do
+
+    before(:each) do 
+      @cut = BaseResource.new({ use_ssl: false, server: 'localhost:3000', api_token: 'sltc_api_token'})
+    end
+
+    context '#invoke_rest' do
+
+      it "should return a raw string if a non-JSON response is made from the block" do
+        result = @cut.send(:invoke_rest, false) do 
+          "abc123"
+        end
+        expect(result).to eq("abc123")
+      end
+
+      it "should parse a response as JSON by default" do
+        result = @cut.send(:invoke_rest) do
+          '{ "message": "from the other side" }'
+        end
+        expect(result).to eq({ 'message' => 'from the other side' })
+      end
+
+      it "should output an error message and exit if the JSON payload is invalid" do
+        expect {
+          @cut.send(:invoke_rest) do
+            '{ message => 3'
+          end
+        }.to raise_error(SystemExit)
+      end
+
+      it "should output an error message and exit if there is a non-403,404 exception" do
+        mock_response = double("Response")
+        mock_response.should_receive(:code).any_number_of_times.and_return(500)
+        mock_response.should_receive(:description).and_return("System error")
+
+        expect {
+          @cut.send(:invoke_rest) do
+            raise RestClient::Exception.new(mock_response, 500)
+          end
+        }.to raise_error(SystemExit)
+      end
+
+      it "should output an error message and exit if there is a 403 exception with no json" do
+        mock_response = double("Response")
+        mock_response.should_receive(:code).any_number_of_times.and_return(403)
+        mock_response.should_receive(:description).and_return("Some other error")
+
+        expect {
+          @cut.send(:invoke_rest, false) do
+            raise RestClient::Exception.new(mock_response, 403)
+          end
+        }.to raise_error(SystemExit)
+      end
+
+      it "should output an error message and exit if there is a 404 exception with error json" do
+        mock_response = double("Response")
+        mock_response.should_receive(:code).any_number_of_times.and_return(404)
+        mock_response.should_receive(:description).and_return("Some other error")
+        mock_response.should_receive(:http_body).and_return('{ "error" : "Error message" }')
+
+        expect {
+          @cut.send(:invoke_rest) do
+            raise RestClient::Exception.new(mock_response, 404)
+          end
+        }.to raise_error(SystemExit)
+      end
+
+      it "should output an error message and exit if there is a 403 exception with validation error json" do
+        mock_response = double("Response")
+        mock_response.should_receive(:code).any_number_of_times.and_return(403)
+        mock_response.should_receive(:description).and_return("Some other error")
+        mock_response.should_receive(:http_body).and_return('{ "validation_error" : { "name" : [ "Error 1", "Error 2" ] } }')
+
+        expect {
+          @cut.send(:invoke_rest) do
+            raise RestClient::Exception.new(mock_response, 403)
+          end
+        }.to raise_error(SystemExit)
+      end
+
+      it "should output an error message and exit if there is a 403 exception with some other error json" do
+        mock_response = double("Response")
+        mock_response.should_receive(:code).any_number_of_times.and_return(403)
+        mock_response.should_receive(:description).and_return("Some other error")
+        mock_response.should_receive(:http_body).and_return('{ "other_error" : { "name" : [ "Error 1", "Error 2" ] } }')
+
+        expect {
+          @cut.send(:invoke_rest) do
+            raise RestClient::Exception.new(mock_response, 403)
+          end
+        }.to raise_error(SystemExit)
+      end
+
+      it "should output an error message and exit if there is a 403 exception with invalid validation error json" do
+        mock_response = double("Response")
+        mock_response.should_receive(:code).any_number_of_times.and_return(403)
+        mock_response.should_receive(:description).and_return("Some other error")
+        mock_response.should_receive(:http_body).any_number_of_times.and_return('{ "validation_error" : { "name" :  "Error 1", "Error 2" ] } }')
+
+        expect {
+          @cut.send(:invoke_rest) do
+            raise RestClient::Exception.new(mock_response, 403)
+          end
+        }.to raise_error(SystemExit)
+      end
+
+      it "should output an error message and exit if there is an unknown exception raised in the block" do
+        expect {
+          @cut.send(:invoke_rest) do
+            raise "Some unknown exception"
+          end
+        }.to raise_error(SystemExit)
+      end
+
+    end
+
+    context '#get' do
+
+      it "should return the response from the GET call" do
+        @cut.should_receive(:invoke_rest).with(true).and_yield
+        
+        RestClient.should_receive(:get).
+          with('http://localhost:3000/tubes', {"Authorization"=>"Token token=\"sltc_api_token\"" }).
+          and_return({ hey: 'guy' })
+
+        expect(@cut.send(:get, 'tubes')).to eq({ hey: 'guy' })
+      end
+
+    end
+
+    context '#delete' do
+
+      it "should return the response from the DELETE call" do
+        @cut.should_receive(:invoke_rest).with(true).and_yield
+        
+        RestClient.should_receive(:delete).
+          with('http://localhost:3000/tubes', {"Authorization"=>"Token token=\"sltc_api_token\"" }).
+          and_return({ hey: 'guy' })
+
+        expect(@cut.send(:delete, 'tubes')).to eq({ hey: 'guy' })
+      end
+
+    end
+
+    context '#post' do
+
+      it "should return the response from the POST call" do
+        @cut.should_receive(:invoke_rest).with(true).and_yield
+        
+        RestClient.should_receive(:post).
+          with('http://localhost:3000/tubes', 
+               {"param1"=>"pvalue"},
+               {"Authorization"=>"Token token=\"sltc_api_token\"" }).
+          and_return({ hey: 'guy' })
+
+        expect(@cut.send(:post, 'tubes', { 'param1' => 'pvalue' })).to eq({ hey: 'guy' })
+      end
+
+    end
+
+    context '#put' do
+
+      it "should return the response from the PUT call" do
+        @cut.should_receive(:invoke_rest).with(true).and_yield
+        
+        RestClient.should_receive(:put).
+          with('http://localhost:3000/tubes', 
+               {"param1"=>"pvalue"},
+               {"Authorization"=>"Token token=\"sltc_api_token\"" }).
+          and_return({ hey: 'guy' })
+
+        expect(@cut.send(:put, 'tubes', { 'param1' => 'pvalue' })).to eq({ hey: 'guy' })
+      end
+
+    end
+
+    context '#build_url' do
+
+      it "should return the properly formatted url" do
+        @cut.options[:use_ssl] = false
+        @cut.options[:server] = 'www.bob.com'
+
+        expect(@cut.send(:build_url, 'the_uri')).to eq('http://www.bob.com/the_uri')
+
+        @cut.options[:use_ssl] = true
+        
+        expect(@cut.send(:build_url, 'the_uri')).to eq('https://www.bob.com/the_uri')
+      end
+
+    end
+
+    context '#authentication_headers' do
+
+      it "should return a hash containing the authentication headers" do
+        @cut.options[:api_token] = 'this is the token string'
+        expect(@cut.send(:authentication_headers)).
+          to eq( { 'Authorization' => "Token token=\"this is the token string\"" } )
+      end
+
+    end
+
+  end
+
+end