rest_connection 0.0.1

data/examples/set_deployment_template_href.rb

@@ -0,0 +1,14 @@
+require 'rubygems'
+require 'rest_connection'
+require 'trollop'
+
+opts = Trollop::options do
+  opt :deployment, "deployment nickname", :type => :string, :required => true
+  opt :template, "server template href to set for all servers", :type => :string, :required => true
+end
+
+deployment = Deployment.find_by_nickname_speed(opts[:deployment]).first
+
+deployment.servers.each do |s|
+  s.set_template(opts[:template])
+end

data/lib/rest_connection.rb

@@ -0,0 +1,208 @@
+#    This file is part of RestConnection 
+#
+#    RestConnection is free software: you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation, either version 3 of the License, or
+#    (at your option) any later version.
+#
+#    RestConnection is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with RestConnection.  If not, see <http://www.gnu.org/licenses/>.
+
+require 'net/https'
+require 'rubygems'
+require 'json'
+require 'yaml'
+require 'cgi'
+require 'rest_connection/rightscale/rightscale_api_base'
+require 'rest_connection/rightscale/rightscale_api_resources'
+require 'logger'
+
+module RestConnection
+  class Connection
+    # Settings is a hash of options for customizing the connection.
+    # settings.merge! {
+    # :common_headers => { "X_CUSTOM_HEADER" => "BLAH" },
+    # :api_url =>
+    # :user =>
+    # :pass =>
+    attr_accessor :settings
+
+    # RestConnection api settings configuration file:
+    # Settings are loaded from a yaml configuration file in users home directory.
+    # Copy the example config from the gemhome/config/rest_api_config.yaml.sample to ~/.rest_connection/rest_api_config.yaml
+    # OR to /etc/rest_connection/rest_api_config.yaml
+    #
+    def initialize(config_yaml = File.join(File.expand_path("~"), ".rest_connection", "rest_api_config.yaml"))
+      @@logger = nil
+      etc_config = File.join("#{File::SEPARATOR}etc", "rest_connection", "rest_api_config.yaml")
+      if File.exists?(config_yaml)
+        @settings = YAML::load(IO.read(config_yaml))
+      elsif File.exists?(etc_config)
+        @settings = YAML::load(IO.read(etc_config))
+      else
+        logger("\nWARNING:  you must setup config file rest_api_config.yaml in #{config_yaml} or #{etc_config}")
+        logger("WARNING:  see GEM_HOME/rest_connection/config/rest_api_config.yaml for example config")
+        @settings = {}
+      end
+    end
+
+    # Main HTTP connection loop. Common settings are set here, then we yield(BASE_URI, OPTIONAL_HEADERS) to other methods for each type of HTTP request: GET, PUT, POST, DELETE
+    # 
+    # The block must return a Net::HTTP Request. You have a chance to taylor the request inside the block that you pass by modifying the url and headers.
+    #
+    # rest_connect do |base_uri, headers|
+    #   headers.merge! {:my_header => "blah"}
+    #   Net::HTTP::Get.new(base_uri, headers)
+    # end
+    #   
+    def rest_connect(&block)
+      uri = URI.parse(@settings[:api_url])
+      http = Net::HTTP.new(uri.host, uri.port)
+      if uri.scheme == 'https'
+        http.use_ssl = true 
+        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+      end
+      headers = @settings[:common_headers]
+      http.start do |http|
+        req = yield(uri, headers)
+        req.basic_auth(@settings[:user], @settings[:pass]) if @settings[:user]
+        logger("#{req.method}: #{req.path}")
+        logger("\trequest body: #{req.body}") if req.body
+        response, body = http.request(req)
+        handle_response(response)
+      end
+    end
+
+    # connection.get("/root/login", :test_header => "x", :test_header2 => "y")
+    # href = "/api/base_new" if this begins with a slash then the url will be used as absolute path.
+    # href = "servers" this will be concat'd on to the api_url from the settings
+    # additional_parameters = Hash or String of parameters to pass to HTTP::Get
+    def get(href, additional_parameters = "")
+      rest_connect do |base_uri,headers|
+        href = "#{base_uri}/#{href}" unless begins_with_slash(href)
+        new_path = URI.escape(href + '.js?' + requestify(additional_parameters))
+        Net::HTTP::Get.new(new_path, headers)
+      end
+    end
+    
+    # connection.post(server_url + "/start")
+    #
+    # href = "/api/base_new" if this begins with a slash then the url will be used as absolute path.
+    # href = "servers" this will be concat'd on to the api_url from the settings
+    # additional_parameters = Hash or String of parameters to pass to HTTP::Post
+    def post(href, additional_parameters = {})
+      rest_connect do |base_uri, headers|
+        href = "#{base_uri}/#{href}" unless begins_with_slash(href)
+        res = Net::HTTP::Post.new(href , headers)
+        unless additional_parameters.empty?
+          res.set_content_type('application/json')
+          res.body = additional_parameters.to_json
+        end
+        #res.set_form_data(additional_parameters, '&')
+        res
+      end
+    end
+
+    # connection.put(server_url + "/start")
+    #
+    # href = "/api/base" if this begins with a slash then the url will be used as absolute path.
+    # href = "servers" this will be concat'd on to the api_url from the settings
+    # additional_parameters = Hash or String of parameters to pass to HTTP::Put
+    def put(href, additional_parameters = {})
+      rest_connect do |base_uri, headers|
+        href = "#{base_uri}/#{href}" unless begins_with_slash(href)
+        new_path = URI.escape(href)
+        req = Net::HTTP::Put.new(new_path, headers) 
+        req.set_content_type('application/json')
+        req.body = additional_parameters.to_json
+        req
+      end
+    end
+
+    # connection.delete(server_url)
+    #
+    # href = "/api/base_new" if this begins with a slash then the url will be used as absolute path.
+    # href = "servers" this will be concat'd on to the api_url from the settings
+    # additional_parameters = Hash or String of parameters to pass to HTTP::Delete
+    def delete(href, additional_parameters = {})
+      rest_connect do |base_uri, headers|
+        href = "#{base_uri}/#{href}" unless begins_with_slash(href)
+        new_path = URI.escape(href)
+        req = Net::HTTP::Delete.new(href, headers)
+        req.set_content_type('application/json')
+        req.body = additional_parameters.to_json
+        req
+      end
+    end
+
+    # handle_response
+    # res = HTTP response 
+    #
+    # decoding and post processing goes here. This is where you may need some customization if you want to handle the response differently (or not at all!).  Luckily it's easy to modify based on this handler.
+    def handle_response(res)
+      if res.code.to_i == 201
+        return res['Location']
+      elsif [200,203,204].detect { |d| d == res.code.to_i }
+        if res.body
+          begin
+            return JSON.load(res.body)
+          rescue => e
+            return res
+          end
+        else
+          return res
+        end
+      else 
+        raise "invalid response HTTP code: #{res.code.to_i}, #{res.code}, #{res.body}"
+      end
+    end
+
+    def begins_with_slash(href)
+      href =~ /^\//
+    end
+
+    def logger(message)
+      init_message = "Initializing Logging using "
+      if @@logger.nil?
+        if @settings[:log_file]
+          @@logger = Logger.new(@settings[:log_file])
+          init_message += @settings[:log_file]
+        elsif ENV['REST_CONNECTION_LOG']
+          @@logger = Logger.new(ENV['REST_CONNECTION_LOG'])
+          init_message += ENV['REST_CONNECTION_LOG']
+        else @settings[:log_file]
+          @@logger = Logger.new(STDOUT)
+          init_message += "STDOUT"
+        end
+        STDOUT.puts init_message
+      end
+
+      @@logger.info(message)
+    end
+
+    # used by requestify to build parameters strings
+    def name_with_prefix(prefix, name)
+      prefix ? "#{prefix}[#{name}]" : name.to_s
+    end
+
+    # recursive method builds CGI escaped strings from Hashes, Arrays and strings of parameters.
+    def requestify(parameters, prefix=nil)
+      if Hash === parameters
+        return nil if parameters.empty?
+        parameters.map { |k,v| requestify(v, name_with_prefix(prefix, k)) }.join("&")
+      elsif Array === parameters
+        parameters.map { |v| requestify(v, name_with_prefix(prefix, "")) }.join("&")
+      elsif prefix.nil?
+        parameters
+      else
+        "#{CGI.escape(prefix)}=#{CGI.escape(parameters.to_s)}"
+      end
+    end
+
+  end
+end

data/lib/rest_connection/mechanize_connection.rb

@@ -0,0 +1,43 @@
+require 'mechanize'
+require 'logger'
+require 'uri'
+
+module MechanizeConnection
+  module Connection
+
+    # creates/returns global mechanize agent
+    def agent
+      @@agent ||= WWW::Mechanize.new do |a|
+        a.log = Logger.new(STDOUT)
+        a.log.level = Logger::INFO
+      end
+    end
+
+    # creates/returns global mechanize agent
+    def self.agent
+      @@agent ||= WWW::Mechanize.new do |a|
+        a.log = Logger.new(STDOUT)
+        a.log.level = Logger::INFO
+      end
+    end
+
+    # login to rightscale dashboard /sessions/new using rest connection user and pass
+    def wind_monkey
+      base_url = URI.parse(connection.settings[:api_url])
+      base_url.path = "/"
+      if agent.cookie_jar.empty?(base_url)
+        agent.user_agent_alias = 'Mac Safari'
+        # Login
+        base_url = URI.parse(connection.settings[:api_url])
+        agent.user_agent_alias = 'Mac Safari'
+        # Login
+        base_url.path = "/sessions/new"
+        login_page = agent.get(base_url)
+        login_form = login_page.forms.first
+        login_form.email = connection.settings[:user]
+        login_form.password = connection.settings[:pass]
+        agent.submit(login_form, login_form.buttons.first)
+      end
+    end
+  end
+end

data/lib/rest_connection/rightscale/deployment.rb

@@ -0,0 +1,36 @@
+#    This file is part of RestConnection 
+#
+#    RestConnection is free software: you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation, either version 3 of the License, or
+#    (at your option) any later version.
+#
+#    RestConnection is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with RestConnection.  If not, see <http://www.gnu.org/licenses/>.
+
+class Deployment < RightScale::Api::Base
+  def set_input(name, value)
+    deploy_href = URI.parse(self.href)
+    connection.put(deploy_href.path, :deployment => {:parameters => {name => value} })
+  end
+
+  def servers_no_reload
+    server_list = []
+    @params['servers'].each do |s|
+      server_list << Server.new(s)
+    end
+    return server_list
+  end
+
+  def servers
+    # this populates extra information about the servers
+    servers_no_reload.each do |s|
+      s.reload
+    end
+  end
+end

data/lib/rest_connection/rightscale/executable.rb

@@ -0,0 +1,49 @@
+class Executable < RightScale::Api::Base
+
+  # executable can be EITHER a right_script or recipe
+  # executable example params format:
+  # can have recipes AND right_scripts
+  # @params =
+  #    { :recipe =>
+  #      :position => 12,
+  #      :apply => "operational",
+  #      :right_script => { "href" => "http://blah", 
+  #                         "name" => "blah" 
+  #                         ...
+  #      }
+
+  def recipe?
+    if self["recipe"].nil? && right_script['href']
+      return false
+    end
+    true
+  end
+
+  def right_script?
+    if self["recipe"].nil? && right_script['href']
+      return true
+    end
+    false
+  end
+
+  def name
+    if right_script?
+      return right_script.name
+    else
+      return recipe
+    end
+  end
+
+  def href
+    if right_script? 
+      return right_script.href
+    else
+      #recipes do not have hrefs, only names
+      return recipe
+    end
+  end
+
+  def right_script
+    RightScript.new(@params['right_script'])
+  end
+end

data/lib/rest_connection/rightscale/instance.rb

@@ -0,0 +1,43 @@
+#    This file is part of RestConnection 
+#
+#    RestConnection is free software: you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation, either version 3 of the License, or
+#    (at your option) any later version.
+#
+#    RestConnection is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with RestConnection.  If not, see <http://www.gnu.org/licenses/>.
+
+# This is an instance facing api and can only be used with
+# an authentication URL normally found in the instance's userdata called
+# RS_API_URL
+class Instance < RightScale::Api::Base
+  #def create_ebs_volume_from_snap(snap_aws_id)
+  #  connection.post('create_ebs_volume.js', :aws_id => snap_aws_id )
+  #end 
+
+  def attach_ebs_volume(params)
+    connection.put('attach_ebs_volume.js', params)
+  end
+
+  def create_ebs_snapshot(params)
+    connection.post('create_ebs_snapshot.js', params)
+  end
+
+  def detach_ebs_volume(params)
+    connection.put('detach_ebs_volume.js', params)
+  end
+
+  def delete_ebs_volume(params)
+    connection.delete('delete_ebs_volume.js', params)
+  end
+
+  def create_ebs_volume(params)
+    connection.post('create_ebs_volume.js', params)
+  end
+end

data/lib/rest_connection/rightscale/right_script.rb

@@ -0,0 +1,42 @@
+#    This file is part of RestConnection 
+#
+#    RestConnection is free software: you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation, either version 3 of the License, or
+#    (at your option) any later version.
+#
+#    RestConnection is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with RestConnection.  If not, see <http://www.gnu.org/licenses/>.
+
+
+class RightScript < RightScale::Api::Base
+  def self.from_yaml(yaml)
+    scripts = []
+    x = YAML.load(yaml)
+    x.keys.each do |script|
+      scripts << self.new('href' => "right_scripts/#{script}", 'name' => x[script].ivars['name'])
+    end
+    scripts  
+  end
+
+  def self.from_instance_info(file = "/var/spool/ec2/rs_cache/info.yml")
+    scripts = []
+    if File.exists?(file)
+      x = YAML.load(IO.read(file))
+    elsif File.exists?(File.join(File.dirname(__FILE__),'info.yml'))
+      x = YAML.load(IO.read(File.join(File.dirname(__FILE__),'info.yml')))
+    else
+      return nil
+    end
+    x.keys.each do |script|
+      scripts << self.new('href' => "right_scripts/#{script}", 'name' => x[script].ivars['name'])
+    end
+    scripts  
+  end
+
+end

data/lib/rest_connection/rightscale/rightscale_api_base.rb

@@ -0,0 +1,120 @@
+#    This file is part of RestConnection 
+#
+#    RestConnection is free software: you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation, either version 3 of the License, or
+#    (at your option) any later version.
+#
+#    RestConnection is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with RestConnection.  If not, see <http://www.gnu.org/licenses/>.
+
+require 'rest_connection/mechanize_connection'
+require 'activesupport'
+
+module RightScale
+  module Api
+    class Base
+      include MechanizeConnection::Connection
+      # The params hash of attributes for direct manipulation
+      attr_accessor :params
+
+      def self.connection()
+        @@connection ||= RestConnection::Connection.new
+      end
+      def connection()
+        @@connection ||= RestConnection::Connection.new
+      end
+
+      def initialize(params = {})
+        @params = params
+      end
+
+      def self.resource_plural_name
+        self.to_s.underscore.pluralize
+      end 
+
+      def self.resource_singluar_name
+        self.to_s.underscore
+      end
+
+      def self.find_all
+        a = Array.new
+        connection.get(self.resource_plural_name).each do |object|
+          a << self.new(object)
+        end
+        return a
+      end
+
+      def self.find_by_nickname(nickname)
+        self.find_all.select do |s| 
+          s.nickname == nickname
+        end
+      end
+
+      def reload
+        uri = URI.parse(self.href)
+        @params ? @params.merge!(connection.get(uri.path)) : @params = connection.get(uri.path)
+      end
+
+      def self.find(href)
+        uri = URI.parse(href)
+        self.new(connection.get(uri.path))
+      end
+
+      def self.find_by_id(id)
+        self.new(connection.get(self.resource_plural_name + "/#{id}"))
+      end
+
+      def self.create(opts)
+        location = connection.post(self.resource_plural_name, self.resource_singluar_name.to_sym => opts)
+        self.new('href' => location)
+      end
+
+# filter is only implemented on some api endpoints
+      def self.find_by_nickname_speed(nickname)
+        self.find_with_filter('nickname' => nickname)
+      end
+
+# filter is only implemented on some api endpoints
+      def self.find_with_filter(filter = {})
+        filter_params = ""
+        filter.each {|key,val| filter_params += "filter[]=#{key}=#{val}&"}
+        a = Array.new
+        connection.get(self.resource_plural_name, filter_params).each do |object|
+          a << self.new(object)
+        end
+        return a
+      end
+
+      def destroy
+        my_href = URI.parse(self.href)
+        connection.delete(my_href.path)
+      end
+
+      # the following two methods are used to access the @params hash in a friendly way
+      def method_missing(method_name, *args)
+        if @params[method_name.to_s]
+          return @params[method_name.to_s] 
+        elsif @params[method_name.to_s.gsub(/_/,'-')]
+          return @params[method_name.to_s.gsub(/_/,'-')]
+        else  
+          raise "called unknown method #{method_name} with #{args.inspect}"
+        end
+      end
+
+      def [](name)
+        if @params[name]
+          return @params[name]
+        else
+          return nil
+        end
+      end
+
+    end
+  end
+end