rscalr 0.0.12 → 0.0.15

data/README.md

@@ -43,6 +43,24 @@ script = dashboard.get_script 'my-script-name'
 script.execute farm.id
 ```
 
+Configuration
+-------------
+
+If you use this tool a lot from the command line, you can set environment variables that will automagically configure your Scalr or Dashboard instance. The following code sets the relevant parameters:
+```bash
+export SCALR_API_KEY=your-api-key
+export SCALR_API_SECRET=your-api-secret
+export SCALR_ENV_ID=id-of-desired-environment # optional
+export SCALR_CLIENT_VERBOSE=true # Print API calls/responses to stdout, optional, default=false
+```
+
+Then just instaniate your client: 
+```ruby
+scalr = Scalr.new
+# or
+dash = Dashboard.new
+```
+
 
 Caveats
 -------

data/lib/rscalr.rb

@@ -7,4 +7,7 @@ require 'rscalr/model/log'
 require 'rscalr/model/log_list'
 require 'rscalr/model/role'
 require 'rscalr/model/script'
+require 'rscalr/model/script_log'
+require 'rscalr/model/script_execution'
 require 'rscalr/model/server'
+require 'rscalr/model/server_log'

data/lib/rscalr/api/scalr.rb

@@ -16,8 +16,13 @@ class Scalr
   $DEFAULT_VERSION = '2.3.0'
   $DEFAULT_AUTH_VERSION = '3'
   
-  def initialize(config)
-    @config = config
+  def initialize(config=nil)
+    if (config.nil?)
+      @config = load_config_from_environment
+    else
+      @config = config
+    end
+    
     @config[:version] = $DEFAULT_VERSION if @config[:version].nil?
     @config[:auth_version] = $DEFAULT_AUTH_VERSION if @config[:auth_version].nil?
   end
@@ -164,7 +169,7 @@ class Scalr
     params[:Prefix] = prefix unless prefix.nil?
     params[:ImageID] = image_id unless image_id.nil?
 
-	execute_api_call('RolesList', params)
+	  execute_api_call('RolesList', params)
   end
   
   def scripts_list
@@ -253,6 +258,18 @@ class Scalr
   
   #=============== Helper methods ==================================
   
+  # Loads config hash based on environment variables
+  def load_config_from_environment
+    config = {}
+    config[:key_id] = ENV['SCALR_API_KEY'] unless ENV['SCALR_API_KEY'].nil?
+    config[:key_secret] = ENV['SCALR_API_SECRET'] unless ENV['SCALR_API_SECRET'].nil?
+    config[:env_id] = ENV['SCALR_ENV_ID'] unless ENV['SCALR_ENV_ID'].nil?
+    config[:version] = ENV['SCALR_API_VERSION'] unless ENV['SCALR_API_VERSION'].nil?
+    config[:auth_version] = ENV['SCALR_API_AUTH_VERSION'] unless ENV['SCALR_API_AUTH_VERSION'].nil?
+    config[:verbose] = true if (ENV['SCALR_CLIENT_VERBOSE'] == "true" || ENV['SCALR_CLIENT_VERBOSE'] == "1")
+    config
+  end
+  
   # Generates request signature based on config, action, timestamp
   def generate_sig(action, timestamp)
     message = action + ':' + @config[:key_id] + ':' + timestamp
@@ -297,6 +314,8 @@ class Scalr
   	  result = build_error_response(ex.message, params[:Signature])
   	end
 
+	  $stdout.puts(result.pretty_print) if @config[:verbose]
+
     result
   end
   
@@ -362,7 +381,9 @@ class ScalrResponse < REXML::Document
   
   # Convenience method to output a repsonse to a stream in a human readable format
   def pretty_print(dest=$stdout)
-    write(dest, 1)
+    formatter = REXML::Formatters::Pretty.new
+    formatter.compact = true
+    formatter.write(root,dest)
   end
 end
 

data/lib/rscalr/model/dashboard.rb

@@ -1,12 +1,12 @@
 class Dashboard
 
-  def initialize config 
+  def initialize(config=nil)
     if config.is_a?(Scalr)
       @client = config
-    elsif config.is_a?(Hash) 
+    elsif config.nil? || config.is_a?(Hash) 
       @client = Scalr.new(config)
     else
-      raise 'Dashboard may only be initialized with a config Hash or Scalr object'
+      raise 'Dashboard may only be initialized with a config Hash, Scalr object, or nil (load config from environment)'
     end
     
     @env_id = @client.env_id
@@ -19,6 +19,17 @@ class Dashboard
     @farms[name]
   end
   
+  def get_farm_by_id(farm_id)
+    if @farms.nil?
+      load_farms
+    end
+    @farms.each { |name,farm|
+      return farm if farm.id == farm_id
+    }
+    
+    nil
+  end
+  
   def load_farms
     @farms = {}
     
@@ -98,4 +109,57 @@ class Dashboard
     
     @environments
   end
+  
+  # Blocks up to timeout seconds waiting on log response(s) of script execution. Returns true iff 
+  # script executed successfully (returned) exit_value on all servers.
+  def verify_script_success(script_execution, exit_value=0, timeout_sec=60)
+    return false unless script_execution.success?
+    
+    sleep_time = 5
+    
+    start_time = Time.now.to_i
+    
+    # 1. get list of servers that this execution should run on
+    farm = get_farm_by_id(script_execution.farm_id)
+    if !script_execution.server_id.nil? 
+      server = farm.get_server(script_execution.server_id)
+      script_execution.add_server(server.server_id)
+    elsif !script_execution.farm_role_id.nil?
+      role_servers = farm.get_servers_for_role_id(script_execution.farm_role_id) 
+      role_servers.each { |server|
+        script_execution.add_server(server.server_id)
+      }
+    else
+      farm_servers = farm.get_all_servers
+      farm_servers.each { |server|
+        script_execution.add_server(server.server_id)
+      }
+    end
+        
+    # 2. Call logs list and match results to server IDs
+    success = false
+    finished = false
+    begin
+      start = 0
+      begin
+        loglist = farm.load_script_logs(script_execution.server_id, script_execution.event_id, start, 20)
+        total_records = loglist.total_records
+    
+        loglist.each { |log|
+          script_execution.set_server_result(log)
+          start += 1
+        }
+      end while start < total_records
+    
+      # 3. If not all servers have responses logged, repeat Step 2 until done or timeout_sec seconds have expired
+      success = true
+      finished = true
+      script_execution.server_results.each { |server_id, result|
+        success &&= (!result.nil? && result.exec_exit_code == exit_value)
+        finished &&= !result.nil?
+      }
+    end while !finished && (Time.now.to_i - start_time) < (timeout_sec + sleep_time) && sleep(sleep_time)
+    
+    success
+  end
 end

data/lib/rscalr/model/farm.rb

@@ -12,8 +12,40 @@ class Farm
     @farm_roles[name]
   end
   
+  def get_server(name)
+    if @farm_servers.nil?
+      load_details
+    end
+    @farm_servers[name]
+  end
+  
+  def get_servers_for_role_id(farm_role_id)
+    if @farm_roles.nil?
+      load_details
+    end
+    result = []
+    @farm_roles.each { |name,role|
+      result = role.servers.dup if role.farm_role_id == farm_role_id
+    }
+    result
+  end
+  
+  def get_all_servers
+    if @farm_roles.nil?
+      load_details
+    end
+    result = []
+    @farm_roles.each { |name,role|
+      role.servers.each { |server|
+        result << server
+      }
+    }
+    result
+  end
+  
   def load_details 
     @farm_roles = {}
+    @farm_servers = {}
     
     scalr_response = @client.farm_get_details @id
     scalr_response.root.each_element('FarmRoleSet/Item') { |row| 
@@ -21,9 +53,9 @@ class Farm
       
       row.each_element { |prop| 
         if "ID" == prop.name
-          role.farm_role_id = prop.text
+          role.farm_role_id = prop.text.to_i
         elsif "RoleID" == prop.name
-          role.role_id = prop.text
+          role.role_id = prop.text.to_i
         elsif "Name" == prop.name
           role.name = prop.text
         elsif "ServerSet" == prop.name
@@ -32,21 +64,22 @@ class Farm
             server.role = role
             
             server_element.each_element { |server_prop| 
-              if "ServerID" == prop.name
-                server.server_id = prop.text
-              elsif "ExternalIP" == prop.name
-                server.external_ip = prop.text
-              elsif "InternalIP" == prop.name
-                server.external_ip = prop.text
-              elsif "Status" == prop.name
-                server.status = prop.text
-              elsif "Index" == prop.name
-                server.index = prop.text.to_i
-              elsif "Uptime" == prop.name
-                server.uptime = prop.text.to_f
+              if "ServerID" == server_prop.name
+                server.server_id = server_prop.text
+              elsif "ExternalIP" == server_prop.name
+                server.external_ip = server_prop.text
+              elsif "InternalIP" == server_prop.name
+                server.external_ip = server_prop.text
+              elsif "Status" == server_prop.name
+                server.status = server_prop.text
+              elsif "Index" == server_prop.name
+                server.index = server_prop.text.to_i
+              elsif "Uptime" == server_prop.name
+                server.uptime = server_prop.text.to_f
               end
             }
             role.servers << server
+            @farm_servers[server.server_id] = server
           }
         end
       }
@@ -71,7 +104,7 @@ class Farm
         loglist.limit = element.text.to_i
       elsif "LogSet" == element.name
         element.each_element do |item|
-          log = Log.new
+          log = ServerLog.new
 
           item.each_element do |prop| 
             if "ServerID" == prop.name
@@ -83,7 +116,48 @@ class Farm
             elsif "Timestamp" == prop.name
               log.timestamp = prop.text.to_i
             elsif "Source" == prop.name
-              server.source = prop.text
+              log.source = prop.text
+            end
+          end
+          loglist << log
+        end
+      end
+    end
+    
+    loglist
+  end
+  
+  # Loads script execution logs for the farm, or a particular server in the farm, optionally relating to a particular script execution.
+  def load_script_logs(server_id=nil, event_id=nil, start=nil, limit=nil)
+    scalr_response = @client.scripting_logs_list(@id, server_id, event_id, start, limit)
+    loglist = LogList.new
+    
+    scalr_response.root.each_element do |element|
+      if "TotalRecords" == element.name
+        loglist.total_records = element.text.to_i
+      elsif "StartFrom" == element.name
+        loglist.start = element.text.to_i
+      elsif "RecordsLimit" == element.name
+        loglist.limit = element.text.to_i
+      elsif "LogSet" == element.name
+        element.each_element do |item|
+          log = ScriptLog.new
+
+          item.each_element do |prop| 
+            if "ServerID" == prop.name
+              log.server_id = prop.text
+            elsif "Message" == prop.name
+              log.message = prop.text
+            elsif "ScriptName" == prop.name
+              log.script_name = prop.text
+            elsif "Timestamp" == prop.name
+              log.timestamp = prop.text.to_i
+            elsif "ExecTime" == prop.name
+              log.exec_time = prop.text.to_i
+            elsif "ExecExitCode" == prop.name
+              log.exec_exit_code = prop.text.to_i
+            elsif "Event" == prop.name
+              log.event = prop.text
             end
           end
           loglist << log

data/lib/rscalr/model/log.rb

@@ -1,7 +1,7 @@
 class Log
-  attr_accessor :server_id, :message, :severity, :timestamp, :source
+  attr_accessor :server_id, :message, :timestamp
   
   def to_s
-    "{ type: \"log\", server_id: \"#{@server_id}\", message: \"#{@message}\", severity: #{@severity}, timestamp: #{@timestamp}, source: \"#{@source}\" }"
+    "{ type: \"log\", server_id: \"#{@server_id}\", message: \"#{@message}\", timestamp: #{@timestamp} }"
   end
 end

data/lib/rscalr/model/log_list.rb

@@ -10,6 +10,12 @@ class LogList
     @logs << log if log.is_a? Log
   end
   
+  def each 
+    @logs.each { |log|
+      yield log  
+    }
+  end
+  
   def to_s
     "{ type: \"loglist\", total_records: #{@total_records}, start: \"#{@message}\", limit: #{@severity}, logs: [ #{@logs.each do |log| log.to_s + ',' end} ] }"
   end

data/lib/rscalr/model/script.rb

@@ -9,7 +9,8 @@ class Script
   
   def execute(farm_id, timeout=30, async=:no_async, farm_role_id=nil, server_id=nil, revision=nil, config_vars=nil)
     set_revision(revision) # Side effect!
-    @client.script_execute farm_id, @id, timeout, async, farm_role_id, server_id, @revision, config_vars
+    api_response = @client.script_execute farm_id, @id, timeout, async, farm_role_id, server_id, @revision, config_vars
+    parse_script_execution_response(api_response, farm_id, farm_role_id, server_id)
   end
   
   def load_details
@@ -57,6 +58,23 @@ class Script
     end
   end
   
+  def parse_script_execution_response(api_response, farm_id, farm_role_id=nil, server_id=nil)
+    if api_response.success? 
+      result = nil
+      event_id = nil
+      api_response.root.each_element { |field| 
+        if "TransactionID" == field.name
+          event_id = field.text
+        elsif "Result" == field.name
+          result = field.text.to_i
+        end
+      }
+      ScriptExecution.new(@id, result, event_id, farm_id, farm_role_id, server_id)
+    elsif
+      ScriptExecution.new(@id, 0, nil, farm_id)
+    end
+  end
+  
   def to_s
     "{ type: \"script\", id: #{@id}, name: \"#{@name}\" }"
   end

data/lib/rscalr/model/script_execution.rb

@@ -0,0 +1,45 @@
+class ScriptExecution
+  attr_reader :script_id, :result, :event_id, :farm_id, :farm_role_id, :server_id, :server_results
+  
+  def initialize(script_id, result, event_id, farm_id, farm_role_id=nil, server_id=nil)
+    @script_id = script_id
+    @result = result
+    @result = 0 if @result != 1
+    @event_id = event_id
+    @farm_id = farm_id
+    @farm_role_id = farm_role_id
+    @server_id = server_id
+    
+    # instance field to store execution results
+    @server_results = {}
+  end
+  
+  def success?
+    @result == 1
+  end
+  
+  def add_server(server_id)
+    @server_results[server_id] = nil
+  end
+  
+  def set_server_result(log)
+    @server_results[log.server_id] = log if @server_results.has_key?(log.server_id)
+  end
+  
+  def to_s
+    "{ type: \"script_execution\", script_id: #{@script_id}, result: #{@result}, event_id: \"#{@event_id}\"}"
+  end
+end
+
+class ScriptExecutionServerResult
+  attr_accessor :script_id, :server_id, :log
+  
+  def initialize(script_id, server_id)
+    @script_id = script_id
+    @server_id = server_id
+  end
+  
+  def to_s
+    "{ type: \"script_execution_server_result\", script_id: #{@script_id}, server_id: \"#{@server_id}\", result: #{@log} }"
+  end
+end

data/lib/rscalr/model/script_log.rb

@@ -0,0 +1,7 @@
+class ScriptLog < Log
+  attr_accessor :script_name, :exec_time, :exec_exit_code, :event
+  
+  def to_s
+    "{ type: \"script_log\", server_id: \"#{@server_id}\", script_name: \"#{@script_name}\", message: \"#{@message}\", timestamp: #{@timestamp}, exec_exit_code: #{@exec_exit_code} }"
+  end
+end

data/lib/rscalr/model/server_log.rb

@@ -0,0 +1,7 @@
+class ServerLog < Log
+  attr_accessor :severity, :source
+  
+  def to_s
+    "{ type: \"server_log\", server_id: \"#{@server_id}\", message: \"#{@message}\", timestamp: #{@timestamp}, severity: #{@severity}, source: \"#{@source}\" }"
+  end
+end

data/lib/rscalr/version.rb

@@ -1,3 +1,3 @@
 module Rscalr
-  VERSION = "0.0.12"
+  VERSION = "0.0.15"
 end

data/test_integration/test_obj_logs.rb

@@ -22,9 +22,7 @@ class TestObjLogs < Test::Unit::TestCase
     
     loglist = farm.load_logs
     
-    assert_not_nil(loglist, "Log list could not be loaded")
-    assert_equal(0, loglist.total_records, "Test farm 1 should not have any logs associated with it")
-    
+    assert_not_nil(loglist, "Log list could not be loaded")    
   end
   
 end

metadata

@@ -1,25 +1,28 @@
---- !ruby/object:Gem::Specification
+--- !ruby/object:Gem::Specification 
 name: rscalr
-version: !ruby/object:Gem::Version
-  version: 0.0.12
+version: !ruby/object:Gem::Version 
   prerelease: 
+  version: 0.0.15
 platform: ruby
-authors:
+authors: 
 - Nathan Smith
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-11 00:00:00.000000000 -07:00
-default_executable: 
+
+date: 2013-03-14 00:00:00 Z
 dependencies: []
-description: Rscalr is a Ruby implementation of the Scalr API, written to interface
-  cleanly with Chef and other internal release management tasks.
-email:
+
+description: Rscalr is a Ruby implementation of the Scalr API, written to interface cleanly with Chef and other internal release management tasks.
+email: 
 - nate@branchout.com
 executables: []
+
 extensions: []
+
 extra_rdoc_files: []
-files:
+
+files: 
 - .gitignore
 - README.md
 - lib/rscalr.rb
@@ -32,7 +35,10 @@ files:
 - lib/rscalr/model/log_list.rb
 - lib/rscalr/model/role.rb
 - lib/rscalr/model/script.rb
+- lib/rscalr/model/script_execution.rb
+- lib/rscalr/model/script_log.rb
 - lib/rscalr/model/server.rb
+- lib/rscalr/model/server_log.rb
 - lib/rscalr/version.rb
 - rscalr.gemspec
 - test/test_env_id.rb
@@ -40,32 +46,34 @@ files:
 - test_integration/test_client_farms.rb
 - test_integration/test_obj_environments.rb
 - test_integration/test_obj_logs.rb
-has_rdoc: true
 homepage: 
 licenses: []
+
 post_install_message: 
 rdoc_options: []
-require_paths:
+
+require_paths: 
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement
+required_ruby_version: !ruby/object:Gem::Requirement 
   none: false
-  requirements:
-  - - ! '>='
-    - !ruby/object:Gem::Version
-      version: '0'
-required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
-  requirements:
-  - - ! '>='
-    - !ruby/object:Gem::Version
-      version: '0'
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
 requirements: []
+
 rubyforge_project: 
-rubygems_version: 1.6.2
+rubygems_version: 1.8.25
 signing_key: 
 specification_version: 3
 summary: Ruby implementation of the Scalr API
-test_files:
+test_files: 
 - test/test_env_id.rb
 - test/test_sig.rb
 - test_integration/test_client_farms.rb