rest_connection 0.0.23 → 0.1.0

data/lib/rest_connection/rightscale/mc_image.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/>.
+
+#
+# You must have Beta v1.5 API access to use these internal API calls.
+#
+class McImage
+  include RightScale::Api::Gateway
+  extend RightScale::Api::GatewayExtend
+
+  def resource_plural_name
+    "images"
+  end
+
+  def resource_singular_name
+    "image"
+  end
+
+  def self.resource_plural_name
+    "images"
+  end
+
+  def self.resource_singular_name
+    "image"
+  end
+
+  def self.parse_args(cloud_id)
+    "clouds/#{cloud_id}/"
+  end
+end

data/lib/rest_connection/rightscale/mc_instance.rb

@@ -0,0 +1,170 @@
+#    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/>.
+
+#
+# You must have Beta v1.5 API access to use these internal API calls.
+#
+class McInstance
+  include RightScale::Api::Gateway
+  extend RightScale::Api::GatewayExtend
+  include RightScale::Api::McTaggable
+  extend RightScale::Api::McTaggableExtend
+  include RightScale::Api::McInput
+  attr_accessor :monitoring_metrics
+
+  def resource_plural_name
+    "instances"
+  end
+
+  def resource_singular_name
+    "instance"
+  end
+
+  def self.resource_plural_name
+    "instances"
+  end
+
+  def self.resource_singular_name
+    "instance"
+  end
+
+  def self.parse_args(cloud_id)
+    "clouds/#{cloud_id}/"
+  end
+
+  def show
+    inst_href = URI.parse(self.href)
+    @params.merge! connection.get(inst_href.path, 'view' => "full")
+  end
+
+  def save
+    update
+  end
+
+  def map_security_groups(to, sg_ary)
+    sg_ary.map { |hsh| hsh["href"] }
+  end
+
+  def map_user_data(to, user_data)
+    user_data
+  end
+
+  def update
+    fields = [{"attr" => :datacenter,                                       "api" => :datacenter_href},
+              {"attr" => :image,                                            "api" => :image_href},
+              {"attr" => :instance_type,                                    "api" => :instance_type_href},
+              {                                                             "api" => :kernel_image_href},
+              {"attr" => :multi_cloud_image,                                "api" => :multi_cloud_image_href},
+              {                                                             "api" => :ramdisk_image_href},
+              {"attr" => :security_groups,    "fn" => :map_security_groups, "api" => :security_group_hrefs},
+              {"attr" => :server_template,                                  "api" => :server_template_href},
+              {"attr" => :ssh_key,                                          "api" => :ssh_key_href},
+              {"attr" => :user_data,          "fn" => :map_user_data,       "api" => :user_data}]
+
+    opts = {"instance" => {}}
+    instance = opts["instance"]
+    to = "api"
+    from = "attr"
+    fields.each { |hsh|
+      next unless hsh[from]
+      val = self[hsh[from]]
+      if hsh["fn"]
+        instance[hsh[to].to_s] = __send__(hsh["fn"], to, val) unless val.nil? || val.empty?
+      else
+        instance[hsh[to].to_s] = val unless val.nil? || val.empty?
+      end
+    }
+    inst_href = URI.parse(self.href)
+    connection.put(inst_href.path, opts)
+  end
+
+  def launch
+    inst_href = URI.parse(self.href)
+    connection.post(inst_href.path + '/launch')
+  end
+
+  def terminate
+    inst_href = URI.parse(self.href)
+    connection.post(inst_href.path + '/terminate')
+  end
+
+  def multi_update(input_ary)
+    inst_href = URI.parse(self.href)
+    connection.put(inst_href.path + '/inputs/multi_update', {'inputs' => input_ary})
+  end
+
+  def transform_inputs(sym, parameters)
+    ret = nil
+    if parameters.is_a?(Array) and sym == :to_h
+      ret = {}
+      parameters.each { |hash| ret[hash['name']] = hash['value'] }
+    elsif parameters.is_a?(Hash) and sym == :to_a
+      ret = []
+      parameters.each { |key,val| ret << {'name' => key, 'value' => val} }
+    end
+    ret
+  end
+
+  def translate_href(old_href)
+    href = old_href.dup
+    href.gsub!(/ec2_/,'')
+    href.gsub!(/\/acct\/[0-9]*/,'')
+    return href
+  end
+
+  def run_executable(executable, opts=nil)
+    run_options = Hash.new
+    if executable.is_a?(Executable)
+      if executable.recipe?
+        run_options[:recipe_name] = executable.recipe
+      else
+        run_options[:right_script_href] = translate_href(executable.right_script.href)
+      end
+    elsif executable.is_a?(RightScript)
+      run_options[:right_script_href] = translate_href(executable.href)
+    else
+      raise "Invalid class passed to run_executable, needs Executable or RightScript, was:#{executable.class}"
+    end
+
+    inst_href = URI.parse(self.href)
+    run_options[:inputs] = transform_inputs(:to_a, opts) unless opts.nil?
+    location = connection.post(inst_href.path + '/run_executable', run_options)
+    Task.new('href' => location)
+  end
+
+  def fetch_monitoring_metrics
+    @monitoring_metrics = []
+    return @monitoring_metrics if self.state != "operational"
+    connection.get(URI.parse(self.href).path + '/monitoring_metrics').each { |mm|
+      @monitoring_metrics << MonitoringMetric.new(mm)
+    }
+    @monitoring_metrics
+  end
+
+  def get_sketchy_data(params)
+    metric = fetch_monitoring_metrics.detect { |mm| mm.plugin == params['plugin_name'] and mm.view == params['plugin_type'] }
+    raise "Metric not found!" unless metric
+    metric.data(params['start'], params['end'])
+  end
+
+  def get_data(params)
+    get_sketchy_data(params)
+  end
+
+  def reboot
+    self.show
+    connection.post(URI.parse(self.href).path + '/reboot')
+  end
+end

data/lib/rest_connection/rightscale/mc_instance_type.rb

@@ -0,0 +1,47 @@
+#    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/>.
+
+#
+# You must have Beta v1.5 API access to use these internal API calls.
+#
+class McInstanceType
+  include RightScale::Api::Gateway
+  extend RightScale::Api::GatewayExtend
+
+  def resource_plural_name
+    "instance_types"
+  end
+
+  def resource_singular_name
+    "instance_type"
+  end
+
+  def self.resource_plural_name
+    "instance_types"
+  end
+
+  def self.resource_singular_name
+    "instance_type"
+  end
+
+  def self.parse_args(cloud_id)
+    "clouds/#{cloud_id}/"
+  end
+
+  def show
+    inst_href = URI.parse(self.href)
+    @params.merge! connection.get(inst_href.path, 'view' => "default")
+  end
+end

data/lib/rest_connection/rightscale/mc_multi_cloud_image.rb

@@ -0,0 +1,58 @@
+#    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/>.
+
+#
+# You must have Beta v1.5 API access to use these internal API calls.
+#
+class McMultiCloudImage
+  include RightScale::Api::Gateway
+  extend RightScale::Api::GatewayExtend
+  include RightScale::Api::McTaggable
+  extend RightScale::Api::McTaggableExtend
+  attr_reader :settings
+
+  def resource_plural_name
+    "multi_cloud_images"
+  end
+
+  def resource_singular_name
+    "multi_cloud_image"
+  end
+
+  def self.resource_plural_name
+    "multi_cloud_images"
+  end
+
+  def self.resource_singular_name
+    "multi_cloud_image"
+  end
+
+  def self.parse_args(server_template_id=nil)
+    server_template_id ? "server_templates/#{server_template_id}/" : ""
+  end
+
+  def supported_cloud_ids
+    @settings.map { |mcics| mcics.cloud_id }
+  end
+
+  def get_settings
+    @settings = []
+    url = URI.parse(self.href)
+    connection.get(url.path + '/settings').each { |s|
+      @settings << McMultiCloudImageSetting.new(s)
+    }
+    @settings
+  end
+end

data/lib/rest_connection/rightscale/mc_multi_cloud_image_setting.rb

@@ -0,0 +1,46 @@
+#    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/>.
+
+#
+# You must have Beta v1.5 API access to use these internal API calls.
+#
+class McMultiCloudImageSetting
+  include RightScale::Api::Gateway
+  extend RightScale::Api::GatewayExtend
+
+  def resource_plural_name
+    "settings"
+  end
+
+  def resource_singular_name
+    "setting"
+  end
+
+  def self.resource_plural_name
+    "settings"
+  end
+
+  def self.resource_singular_name
+    "setting"
+  end
+
+  def self.parse_args(multi_cloud_image_id)
+    "multi_cloud_images/#{multi_cloud_image_id}/"
+  end
+
+  def cloud_id
+    self.cloud.split(/\//).last.to_i
+  end
+end

data/lib/rest_connection/rightscale/mc_security_group.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/>.
+
+#
+# You must have Beta v1.5 API access to use these internal API calls.
+#
+class McSecurityGroup
+  include RightScale::Api::Gateway
+  extend RightScale::Api::GatewayExtend
+
+  def resource_plural_name
+    "security_groups"
+  end
+
+  def resource_singular_name
+    "security_group"
+  end
+
+  def self.resource_plural_name
+    "security_groups"
+  end
+
+  def self.resource_singular_name
+    "security_group"
+  end
+
+  def self.parse_args(cloud_id)
+    "clouds/#{cloud_id}/"
+  end
+end

data/lib/rest_connection/rightscale/mc_server.rb

@@ -1,4 +1,4 @@
-#    This file is part of RestConnection 
+#    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
@@ -13,13 +13,16 @@
 #    You should have received a copy of the GNU General Public License
 #    along with RestConnection.  If not, see <http://www.gnu.org/licenses/>.
 
-#    
+#
 # You must have Beta v1.5 API access to use these internal API calls.
-# 
-class McServer
+#
+class McServer < Server
   include RightScale::Api::Gateway
   extend RightScale::Api::GatewayExtend
-  
+  include RightScale::Api::McTaggable
+  extend RightScale::Api::McTaggableExtend
+  attr_accessor :current_instance, :next_instance, :inputs
+
   def resource_plural_name
     "servers"
   end
@@ -35,5 +38,246 @@ class McServer
   def self.resource_singular_name
     "server"
   end
-  
+
+  def self.parse_args(deployment_id=nil)
+    deployment_id ? "deployments/#{deployment_id}/" : ""
+  end
+
+  def launch
+    if actions.include?("launch")
+      t = URI.parse(self.href)
+      connection.post(t.path + '/launch')
+    elsif self.state == "inactive"
+      raise "FATAL: Server is in an unlaunchable state!"
+    else
+      connection.logger("WARNING: was in #{self.state} so skipping launch call")
+    end
+  end
+
+  def terminate
+    if actions.include?("terminate")
+      t = URI.parse(self.href)
+      connection.post(t.path + '/terminate')
+      @current_instance = nil
+#    elsif self.state != "inactive"
+#      raise "FATAL: Server is in an interminable state!"
+    else
+      connection.logger("WARNING: was in #{self.state} so skipping terminate call")
+    end
+  end
+
+  def force_terminate
+    t = URI.parse(self.href)
+    connection.post(t.path + '/terminate')
+    connection.post(t.path + '/terminate')
+    @current_instance = nil
+  end
+
+  def start #start_ebs
+    raise "You shouldn't be here."
+  end
+
+  def stop #stop_ebs
+    raise "You shouldn't be here."
+  end
+
+  def run_executable(executable, opts=nil)
+    raise "Instance isn't running; Can't run executable" unless @current_instance
+    @current_instance.run_executable(executable, opts)
+  end
+
+  def transform_inputs(sym, parameters)
+    ret = nil
+    if parameters.is_a?(Array) and sym == :to_h
+      ret = {}
+      parameters.each { |hash| ret[hash['name']] = hash['value'] }
+    elsif parameters.is_a?(Hash) and sym == :to_a
+      ret = []
+      parameters.each { |key,val| ret << {'name' => key, 'value' => val} }
+    end
+    ret
+  end
+
+  def inputs
+    if @current_instance
+      @current_instance.show
+      return transform_inputs(:to_h, @current_instance.inputs)
+    else
+      @next_instance.show
+      return transform_inputs(:to_h, @next_instance.inputs)
+    end
+  end
+
+  def set_input(name, value)
+    settings unless @next_instance
+    @current_instance.multi_update([{'name' => name, 'value' => value}]) if @current_instance
+    @next_instance.multi_update([{'name' => name, 'value' => value}])
+  end
+
+  def set_current_inputs(hash = {})
+    settings unless @next_instance
+    @current_instance.multi_update(transform_inputs(:to_a, hash)) if @current_instance
+  end
+
+  def set_next_inputs(hash = {})
+    settings unless @next_instance
+    @next_instance.multi_update(transform_inputs(:to_a, hash))
+  end
+
+
+  def settings #show
+    serv_href = URI.parse(self.href)
+    @params = connection.get(serv_href.path, 'view' => 'instance_detail')
+    if self['current_instance']
+      @current_instance = McInstance.new(self['current_instance'])
+      @current_instance.show
+    end
+    @next_instance = McInstance.new(self['next_instance'])
+    @next_instance.show
+    @params
+  end
+
+  def monitoring
+    ret = @current_instance.fetch_monitoring_metrics
+    raise "FATAL: Monitoring not available!" if ret.empty?
+    ret
+  end
+
+  def relaunch
+    self.terminate
+    self.wait_for_state("inactive")
+    self.launch
+  end
+
+  # Attributes taken for granted in API 1.0
+  def server_type
+    "gateway"
+  end
+
+  def server_template_href
+    if @current_instance
+      return @current_instance.server_template
+    end
+    self.settings unless @next_instance
+    return @next_instance.server_template
+  end
+
+  def deployment_href
+    hash_of_links["deployment"]
+  end
+
+  def current_instance_href
+    hash_of_links["current_instance"]
+  end
+
+  def cloud_id
+    settings unless @next_instance
+    cloud_href = @current_instance.hash_of_links["cloud"] if @current_instance
+    cloud_href = @next_instance.hash_of_links["cloud"] unless cloud_href
+    return cloud_href.split("/").last.to_i
+  end
+
+=begin
+  def wait_for_operational_with_dns(state_wait_timeout=1200)
+    timeout = 600
+    wait_for_state("operational", state_wait_timeout)
+    step = 15
+    while(timeout > 0)
+      self.settings
+      break if self.reachable_ip
+      connection.logger "waiting for any IP for #{self.nickname}"
+      sleep step
+      timeout -= step
+    end
+    connection.logger "got IP: #{self.reachable_ip}"
+    raise "FATAL, this server #{self.audit_link} timed out waiting for an IP" if timeout <= 0
+  end
+=end
+
+  def dns_name
+    self.settings
+    if @current_instance
+      return @current_instance.public_ip_addresses.first || @current_instance.public_dns_names.first
+    end
+    nil
+  end
+
+  def private_ip
+    self.settings
+    if @current_instance
+      return @current_instance.private_ip_addresses.first || @current_instance.private_dns_names.first
+    end
+    nil
+  end
+
+  def save
+    update
+  end
+
+  def update
+    @next_instance.update
+    @current_instance.update if @current_instance
+  end
+
+  def reload_as_current
+    settings # Gets all instance (including current) information
+  end
+
+  def reload_as_next
+    settings # Gets all instance (including current) information
+  end
+
+  def get_sketchy_data(params)
+    settings
+    raise "No current instance found!" unless @current_instance
+    @current_instance.get_sketchy_data(params)
+  end
+
+  # Override Taggable mixin so that it sets tags on both next and current instances
+  def current_tags(reload=true)
+    ret = []
+    if @current_instance
+      ret = McTag.search_by_href(self.current_instance_href).first["tags"].map { |h| h["name"] }
+    end
+    ret
+  end
+
+  def add_tags(*args)
+    return false if args.empty?
+    args.uniq!
+    McTag.set(self.href, args)
+    McTag.set(self.current_instance_href, args) if @current_instance
+    self.tags(true)
+  end
+
+  def remove_tags(*args)
+    return false if args.empty?
+    args.uniq!
+    McTag.unset(self.href, args)
+    McTag.unset(self.current_instance_href, args) if @current_instance
+    self.tags(true)
+  end
+
+  def get_tags_by_namespace(namespace)
+    ret = {}
+    tags = {"self" => self.tags(true)}
+    tags["current_instance"] = self.current_tags if @current_instance
+    tags.each { |res,ary|
+      ret[res] ||= {}
+      ary.each { |tag|
+        next unless tag.start_with?("#{namespace}:")
+        key = tag.split("=").first.split(":")[1..-1].join(":")
+        value = tag.split(":")[1..-1].join(":").split("=")[1..-1].join("=")
+        ret[res][key] = value
+      }
+    }
+    return ret
+  end
+
+  def clear_tags(namespace = nil)
+    tags = self.tags(true)
+    tags.deep_merge! self.current_tags if @current_instance
+    tags = tags.select { |tag| tag.start_with?("#{namespace}:") } if namespace
+    self.remove_tags(*tags)
+  end
 end