rscalr 0.0.1

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+coverage
+InstalledFiles
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+
+# YARD artifacts
+.yardoc
+_yardoc
+doc/

data/README.md

@@ -0,0 +1,4 @@
+rscalr
+======
+
+Ruby Scalr API implementation

data/lib/rscalr.rb

@@ -0,0 +1,7 @@
+require 'rscalr/api/scalr'
+require 'rscalr/model/dashboard'
+require 'rscalr/model/farm'
+require 'rscalr/model/farm_role'
+require 'rscalr/model/role'
+require 'rscalr/model/script'
+require 'rscalr/model/server'

data/lib/rscalr/api/scalr.rb

@@ -0,0 +1,150 @@
+require 'openssl'
+require 'net/http'
+require 'cgi'
+require 'rexml/document'
+
+class Scalr
+  attr_accessor :config
+  
+  # Default versions
+  $DEFAULT_VERSION = '2.3.0'
+  $DEFAULT_AUTH_VERSION = '3'
+  
+  def initialize(config)
+    @config = config
+    @config[:version] = $DEFAULT_VERSION if @config[:version].nil?
+    @config[:auth_version] = $DEFAULT_AUTH_VERSION if @config[:auth_version].nil?
+  end
+  
+  def generate_sig(action, timestamp)
+    message = action + ':' + @config[:key_id] + ':' + timestamp
+    hexdigest = OpenSSL::HMAC.hexdigest('sha256', @config[:key_secret], message)
+    [[hexdigest].pack("H*")].pack("m0")
+  end
+  
+  def execute_api_call(action, action_params=nil)
+  
+    begin
+  	  params = { :Action => action, :TimeStamp => Time.now.strftime("%Y-%m-%dT%H:%M:%SZ") }
+	    params.merge!(action_params) unless action_params.nil?
+		
+  	  params[:Signature] = generate_sig(action, params[:TimeStamp])
+  	  params[:Version] = @config[:version]
+  	  params[:AuthVersion] = @config[:auth_version]
+  	  params[:KeyID] = @config[:key_id]
+			
+  	  uri = URI("https://api.scalr.net/?" + hash_to_querystring(params))
+	
+	    response = Net::HTTP.start(uri.host, uri.port, :use_ssl => true) do |http|
+  	    request = Net::HTTP::Get.new uri.request_uri
+  	    http.request request # Net::HTTPResponse object
+  	  end
+	  
+  	  case response
+  	  when Net::HTTPSuccess then
+          result = ScalrResponse.new response.body
+  	  else
+  	    result = build_error_response(response)
+  	  end
+	  
+  	rescue => ex
+  	  result = build_error_response(ex.message)
+  	end
+
+    result
+  end
+  
+  def build_error_response(message)
+    result = ScalrResponse.new "<?xml version='1.0?>"
+    result.add_element("Error")
+    ele = REXML::Element.new "TransactionID"
+    ele.text = generate_sig(message, Time.now.strftime("%Y-%m-%dT%H:%M:%SZ"))
+    result.root.elements << ele
+    ele = REXML::Element.new "Message"
+    ele.text = message
+    result.root.elements << ele
+
+	result
+  end
+  
+  def hash_to_querystring(h)
+    h.map{|k,v| "#{k.to_s}=#{CGI::escape(v.to_s)}"}.join('&')
+  end
+  
+  
+  #=================== API Section ===================================
+  
+  def farms_list
+    execute_api_call('FarmsList')
+  end
+  
+  def scripts_list
+    execute_api_call('ScriptsList')
+  end
+  
+  def farm_get_details(farm_id)
+    execute_api_call('FarmGetDetails', { :FarmID => farm_id })
+  end
+  
+  def script_execute(farm_id, script_id, timeout=30, async=:no_async, farm_role_id=nil, server_id=nil, revsion=nil, config_vars=nil)
+    async_int = 0 
+    async_int = 1 if async == :async
+    
+    params = { :FarmID => farm_id, :ScriptID => script_id, :Timeout => timeout, :Async => async_int }
+    params[:FarmRoleID] = farm_role_id unless farm_role_id.nil?
+    params[:ServerID] = server_id unless server_id.nil?
+    params[:Revision] = revsion unless revsion.nil?
+    if config_vars != nil 
+      config_vars.each {|key, value| 
+        params["ConfigVariables[#{CGI::escape(key)}]"] = value
+      }
+    end
+    
+    execute_api_call('ScriptExecute', params)
+  end
+  
+  def script_get_details(script_id)
+    execute_api_call('ScriptGetDetails', { :ScriptID => script_id })
+  end
+  
+  def farm_role_parameters_list(farm_role_id)
+    execute_api_call('FarmRoleParametersList', { :FarmRoleID => farm_role_id })
+  end
+  
+  def farm_role_update_parameter_value(farm_role_id, param_name, param_value)
+    execute_api_call('FarmRoleUpdateParameterValue', { :FarmRoleID => farm_role_id, :ParamName => param_name, :ParamValue => param_value })
+  end
+
+  def scripting_logs_list(farm_id, server_id=nil, start=nil, limit=nil)
+    params = { :FarmID => farm_id }
+    params[:ServerID] = server_id unless server_id.nil?
+    params[:StartFrom] = start unless start.nil?
+    params[:RecordsLimit] = limit unless limit.nil?
+    
+    execute_api_call('ScriptingLogsList', params)
+  end
+end
+
+class ScalrResponse < REXML::Document
+  
+  def initialize http_response_body=nil
+    if http_response_body.nil?
+      super
+    else
+      super http_response_body
+    end
+  end
+    
+  def success?
+    root.name != 'Error'
+  end
+  
+  def error_message
+    if success?
+      nil
+    else
+      root.elements['Message'].text
+    end
+  end
+end
+

data/lib/rscalr/model/dashboard.rb

@@ -0,0 +1,69 @@
+require 'rscalr/model/farm'
+require 'rscalr/model/script'
+
+class Dashboard
+  
+  def initialize client
+    @client = client
+  end
+  
+  def get_farm(name)
+    if @farms.nil?
+      load_farms
+    end
+    @farms[name]
+  end
+  
+  def load_farms
+    @farms = {} if @farms == nil
+    
+    scalr_response = @client.farms_list
+    scalr_response.root.each_element('FarmSet/Item') { |row| 
+      farm = Farm.new @client
+      
+      row.each_element { |prop| 
+        if "ID" == prop.name
+          farm.id = prop.text
+        elsif "Name" == prop.name
+          farm.name = prop.text
+        elsif "Status" == prop.name
+          farm.status = prop.text
+        end
+      }
+      @farms[farm.name] = farm
+    }
+    
+    @farms
+  end
+  
+  def get_script(name)
+    if @scripts.nil?
+      load_scripts
+    end
+    @scripts[name]
+  end
+  
+  def load_scripts
+    @scripts = {}
+    
+    scalr_response = @client.scripts_list
+    scalr_response.root.each_element('ScriptSet/Item') { |row| 
+      script = Script.new @client
+      
+      row.each_element { |prop| 
+        if "ID" == prop.name
+          script.id = prop.text
+        elsif "Name" == prop.name
+          script.name = prop.text
+        elsif "Description" == prop.name
+          script.description = prop.text
+        elsif "LatestRevision" == prop.name
+          script.latest_revision = prop.text.to_i
+        end
+      }
+      @scripts[script.name] = script
+    }
+    
+    @scripts
+  end
+end

data/lib/rscalr/model/farm.rb

@@ -0,0 +1,64 @@
+class Farm
+  attr_accessor :id, :name, :status
+    
+  def initialize client
+    @client = client
+  end
+  
+  def get_role(name)
+    if @farm_roles.nil?
+      load_details
+    end
+    @farm_roles[name]
+  end
+  
+  def load_details 
+    @farm_roles = {}
+    
+    scalr_response = @client.farm_get_details @id
+    scalr_response.root.each_element('FarmRoleSet/Item') { |row| 
+      role = FarmRole.new 
+      
+      row.each_element { |prop| 
+        if "ID" == prop.name
+          role.farm_role_id = prop.text
+        elsif "RoleID" == prop.name
+          role.role_id = prop.text
+        elsif "Name" == prop.name
+          role.name = prop.text
+        elsif "ServerSet" == prop.name
+          prop.each_element { |server_element| 
+            server = Server.new
+            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
+              end
+            }
+            role.servers << server
+          }
+        end
+      }
+      
+      @farm_roles[role.name] = role
+    }
+    
+    @farm_roles
+  end
+  
+  def to_s
+    "{ type: \"farm\", id: #{@id}, name: \"#{@name}\", status: #{@status} }"
+  end
+end
+

data/lib/rscalr/model/farm_role.rb

@@ -0,0 +1,14 @@
+require 'rscalr/model/role'
+
+class FarmRole < Role
+  attr_accessor :farm_role_id, :servers
+  
+  def initialize
+    @servers = []
+  end
+  
+  def to_s
+    "{ type: \"farm_role\", farm_role_id: #{@farm_role_id}, role_id: #{@role_id}, name: \"#{@name}\", num_servers: #{@servers.size} }"
+  end
+  
+end

data/lib/rscalr/model/role.rb

@@ -0,0 +1,7 @@
+class Role
+  attr_accessor :role_id, :name
+  
+  def to_s
+    "{ type: \"role\", role_id: #{@role_id}, name: \"#{@name}\" }"
+  end
+end

data/lib/rscalr/model/script.rb

@@ -0,0 +1,88 @@
+require 'time'
+
+class Script
+  attr_accessor :id, :name, :description, :latest_revision, :details
+  
+  def initialize client
+    @client = client
+  end
+  
+  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
+  end
+  
+  def load_details
+    @details = ScriptDetails.new @id
+    scalr_response = @client.script_get_details @id
+    scalr_response.root.each_element('ScriptRevisionSet/Item') { |row| 
+      revision = ScriptRevision.new
+      
+      row.each_element { |prop| 
+        if "Revision" == prop.name
+          revision.revision = prop.text.to_i
+        elsif "Date" == prop.name
+          revision.date = Time.parse(prop.text)
+        elsif "ConfigVariables" == prop.name
+          prop.each_element { |configvar_element| 
+            configvar_element.each_element { |configvar_prop| 
+              if "Name" == prop.name
+                revision.config_variables << prop.text
+              end
+            }
+          }
+        end
+      }
+
+      @details.revisions[revision.revision] = revision
+    }
+    
+    @details
+  end
+  
+  def get_config_variables
+    load_details unless @details != nil
+    @revision = @latest_revision unless @revision != nil
+    puts "Rev: #{@revision} -- Deets: #{@details}"
+    @details.revisions[@revision].config_variables
+  end
+  
+  def set_revision(revision)
+    if revision.nil? || revision >= @latest_revision
+      @revision = @latest_revision
+    elsif revision < 1
+      @revision = 1
+    else
+      @revision = revision
+    end
+  end
+  
+  def to_s
+    "{ type: \"script\", id: #{@id}, name: \"#{@name}\" }"
+  end
+end
+
+class ScriptDetails
+  attr_accessor :id, :revisions
+  
+  def initialize id
+    @id = id
+    @revisions = {}
+  end
+  
+  def to_s
+    "{ type: \"script-details\", script_id: #{@id}, num_revisions: #{@revisions.size}}"
+  end
+end
+
+class ScriptRevision
+  attr_accessor :revision, :date, :config_variables
+  
+  def initialize
+    @config_variables = []
+  end
+  
+  def to_s
+    "{ type: \"script-revision\", revision: #{@revision}, date: \"#{@date}\", vars: \"#{@config_variables}\"}"
+  end
+end

data/lib/rscalr/model/server.rb

@@ -0,0 +1,7 @@
+class Server
+  attr_accessor :server_id, :external_ip, :internal_ip, :status, :index, :uptime, :role
+  
+  def to_s
+    "{ type: \"server\", id: \"#{@server_id}\", external_ip: \"#{@external_ip}\", internal_ip: \"#{@internal_ip}\", role: #{@role} }"
+  end
+end

data/lib/rscalr/version.rb

@@ -0,0 +1,3 @@
+module Rscalr
+  VERSION = "0.0.1"
+end

data/rscalr.gemspec

@@ -0,0 +1,16 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "rscalr/version"
+
+Gem::Specification.new do |s|
+  s.name        = "rscalr"
+  s.version     = Rscalr::VERSION
+  s.authors     = ["Nathan Smith"]
+  s.email       = ["nate@branchout.com"]
+  s.summary     = %q{Ruby implementation of the Scalr API}
+  s.description = %q{Rscalr is a Ruby implementation of the Scalr API, written to interface cleanly with Chef and other internal release management tasks.}
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

metadata

@@ -0,0 +1,58 @@
+--- !ruby/object:Gem::Specification
+name: rscalr
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Nathan Smith
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-02-03 00:00:00.000000000 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:
+- nate@branchout.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- README.md
+- lib/rscalr.rb
+- lib/rscalr/api/scalr.rb
+- lib/rscalr/model/dashboard.rb
+- lib/rscalr/model/farm.rb
+- lib/rscalr/model/farm_role.rb
+- lib/rscalr/model/role.rb
+- lib/rscalr/model/script.rb
+- lib/rscalr/model/server.rb
+- lib/rscalr/version.rb
+- rscalr.gemspec
+homepage: 
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Ruby implementation of the Scalr API
+test_files: []