right_link 5.9.0

data/lib/clouds/cloud_factory.rb

@@ -0,0 +1,250 @@
+#
+# Copyright (c) 2011 RightScale Inc
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+
+module RightScale
+
+  # Singleton for registering and instantiating clouds.
+  class CloudFactory
+
+    include RightSupport::Ruby::EasySingleton
+
+    # the unknown cloud is used to automatically detect current instance's cloud
+    UNKNOWN_CLOUD_NAME = :unknown
+
+    # exceptions
+    class UnknownCloud < Exception; end
+
+    # Registry method for a dynamic metadata type.
+    #
+    # === Parameters
+    # cloud_names(Array|String):: name of one or more clouds (which may include DEFAULT_CLOUD) that use the given type
+    # cloud_script_path(String):: path to script used to describe cloud on creation
+    #
+    # === Return
+    # always true
+    def register(cloud_names, cloud_script_path)
+      # relies on each to split on newlines for strings and otherwise do each for collections.
+      cloud_script_path = File.normalize_path(cloud_script_path)
+      cloud_names.each { |cloud_name| registered_type(cloud_name, cloud_script_path) }
+      true
+    end
+
+    # Resets the global cloud registry (to ensure a clean reload of cloud names).
+    #
+    # === Return
+    # result(Hash):: Hash of cloud names to script paths before reset
+    def reset_registry
+      result = @names_to_script_paths
+      @names_to_script_paths = nil
+      result
+    end
+
+    # Gets the path to the script describing a cloud.
+    #
+    # === Parameters
+    # cloud_name(String):: a registered_type cloud name
+    #
+    # === Return
+    # cloud_script_path(String):: path to script used to describe cloud on creation
+    #
+    # === Raise
+    # UnknownCloud:: on error
+    def registered_script_path(cloud_name)
+      cloud_script_path = registered_type(cloud_name)
+      raise UnknownCloud.new("Unknown cloud: #{cloud_name}") unless cloud_script_path
+      return cloud_script_path
+    end
+
+    # Factory method for dynamic metadata types.
+    #
+    # === Parameters
+    # cloud(String):: a registered_type cloud name
+    # options(Hash):: options for creation
+    #
+    # === Return
+    # result(Object):: new instance of registered_type metadata type
+    #
+    # === Raise
+    # UnknownCloud:: on error
+    def create(cloud_name, options)
+      raise ArgumentError.new("cloud_name is required") if cloud_name.to_s.empty?
+      raise ArgumentError.new("options[:logger] is required") unless logger = options[:logger]
+      raise UnknownCloud.new("No cloud definitions available.") unless @names_to_script_paths
+      cloud_name = cloud_name.to_sym
+      cloud_name = default_cloud_name if UNKNOWN_CLOUD_NAME == cloud_name
+      if UNKNOWN_CLOUD_NAME == cloud_name
+        # persist default cloud name after successful detection.
+        cloud = detect_cloud(options)
+        raise UnknownCloud.new("Unable to determine a default cloud") unless cloud
+        default_cloud_name(cloud.name)
+        return cloud
+      end
+      cloud_script_path = registered_script_path(cloud_name)
+      options = options.dup
+      options[:name] ||= cloud_name.to_s
+      options[:script_path] = cloud_script_path
+      cloud = Cloud.new(options)
+      text = File.read(cloud_script_path)
+      cloud.instance_eval(text)
+      cloud.abbreviation(cloud_name) unless cloud.abbreviation
+      extend_cloud_by_scripts(cloud, logger)
+
+      # finalize defaults only after all cloud definitions have been evaluated
+      # by the new cloud object.
+      cloud.finalize_default_options
+      return cloud
+    end
+
+    # Setter/getter for the default cloud name. This currently relies on a
+    # 'cloud file' which must be present in an expected RightScale location.
+    #
+    # === Parameters
+    # value(String|Token):: default cloud name or nil
+    #
+    # === Return
+    # result(String):: default cloud name or nil
+    def default_cloud_name(value = nil)
+      cloud_file_path = RightScale::AgentConfig.cloud_file_path
+      if value
+        parent_dir = File.dirname(cloud_file_path)
+        FileUtils.mkdir_p(parent_dir) unless File.directory?(parent_dir)
+        File.open(cloud_file_path, "w") { |f| f.write(value.to_s) }
+      else
+        value = File.read(cloud_file_path).strip if File.file?(cloud_file_path)
+      end
+      value.to_s.empty? ? UNKNOWN_CLOUD_NAME : value
+    end
+
+    # Attempts to detect the current instance's cloud by instantiating the
+    # various known clouds and running their detection methods.
+    # 
+    # === Parameters
+    # options(Hash):: options for creation or empty
+    #
+    # === Return
+    # cloud(Cloud):: detected cloud or nil
+    def detect_cloud(options)
+      @names_to_script_paths.each_key do |cloud_name|
+        begin
+          cloud = create(cloud_name, options)
+          return cloud if cloud.is_current_cloud?
+        rescue Exception
+          # ignore failures and proceed to detecting next cloud, if any.
+        end
+      end
+      nil
+    end
+
+    # Normalizes a cloud name to ensure all variants are resolvable.
+    #
+    # === Parameters
+    # cloud_name(String):: cloud name
+    #
+    # === Return
+    # result(String):: normalized cloud name
+    def self.normalize_cloud_name(cloud_name)
+      return cloud_name.to_s.strip.downcase
+    end
+
+    protected
+
+    # Getter/setter for cloud types registered clouds.
+    #
+    # === Parameters
+    # name(String):: name of cloud
+    # script_path(String):: path to script to evaluate when creating cloud
+    #
+    # === Return
+    # result(Hash):: hash in form {:name => <name>, :script_path => <script_path>} or nil
+    def registered_type(cloud_name, cloud_script_path = nil)
+      raise ArgumentError.new("cloud_name is required") unless cloud_name
+      key = self.class.normalize_cloud_name(cloud_name).to_sym
+      @names_to_script_paths ||= {}
+      @names_to_script_paths[key] ||= cloud_script_path
+    end
+
+    # Supports runtime extension of the cloud object by external scripts which
+    # are associated with instance methods. These scripts can also override the
+    # predefined methods (e.g. write_metadata) to further customize a cloud's
+    # behavior on a given instance. It may also be better to run some complex
+    # operation in a child process instead of in the process which is loading
+    # the cloud object.
+    #
+    # === Parameters
+    # @param [String] cloud as a registered_type or UNKNOWN_CLOUD_NAME
+    # @param [Logger] logger
+    def extend_cloud_by_scripts(cloud, logger)
+      # search for script directories based first on any clouds which were
+      # extended by the cloud and then by the exact cloud name.
+      cloud_name = cloud.name.to_s
+      cloud_aliases = cloud.extended_clouds + [cloud_name]
+
+      search_paths = []
+      cloud_aliases.each do |cloud_alias|
+        # first add default search path for cloud name.
+        search_path = File.join(RightScale::Platform.filesystem.private_bin_dir, cloud_alias)
+        if File.directory?(search_path)
+          search_paths << search_path
+          logger.debug("Added #{search_path.inspect} to search path for extension scripts.")
+        else
+          logger.debug("Optional extension script dir #{search_path.inspect} does not exist.")
+        end
+
+        # custom paths are last in order to supercede any preceeding extensions.
+        cloud.extension_script_base_paths.each do |base_path|
+          search_path = File.join(base_path, cloud_alias)
+          if File.directory?(search_path)
+            search_paths << search_path
+            logger.debug("Added #{search_path.inspect} to search path for extension scripts.")
+          else
+            logger.debug("Optional extension script dir #{search_path.inspect} does not exist.")
+          end
+        end
+      end
+
+      # inject any scripts discovered in script paths as instance methods which
+      # return the result of calling the external script.
+      search_paths.each do |search_path|
+        search_path = File.normalize_path(search_path)
+        Dir.glob(File.join(search_path, "*")).each do |script_path|
+          script_ext = File.extname(script_path)
+          script_name = File.basename(script_path, script_ext)
+
+          # ignore any script names which contain strange characters (like
+          # semicolon) for security reasons.
+          if script_name =~ /^[_A-Za-z][_A-Za-z0-9]*$/
+            logger.debug("Extending #{cloud_name} from #{script_path.inspect}")
+            eval_me = <<EOF
+def #{script_name}(*arguments)
+  return execute_script(\"#{script_path}\", *arguments)
+end
+EOF
+            cloud.instance_eval(eval_me)
+          end
+        end
+      end
+    end
+
+  end  # CloudFactory
+
+end  # RightScale

data/lib/clouds/cloud_utilities.rb

@@ -0,0 +1,244 @@
+#
+# Copyright (c) 2011 RightScale Inc
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+require 'open-uri'
+require 'socket'
+
+module RightScale
+
+  class CloudUtilities
+
+    IP_ADDRESS_REGEX = /^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/
+
+    DEFAULT_WHATS_MY_IP_HOST_NAME = 'eip-us-east.rightscale.com'
+    DEFAULT_WHATS_MY_IP_TIMEOUT = 10 * 60
+    DEFAULT_WHATS_MY_IP_RETRY_DELAY = 5
+
+    # Does an interface have the given mac address?
+    #
+    # === Parameters
+    # ohai(Mash):: ohai state
+    # mac(String):: MAC address to find
+    #
+    # === Return
+    # (Boolean):: true if there is an interface with the given mac address
+    def self.has_mac?(ohai, mac)
+      !!ohai[:network][:interfaces].values.detect { |iface| !iface[:arp].nil? && iface[:arp].value?(mac) }
+    end
+
+    # Attempt to connect to the given address on the given port as a quick verification
+    # that the metadata service is available.
+    #
+    # === Parameters
+    # addr(String):: address of the metadata service
+    # port(Number):: port of the metadata service
+    # timeout(Number)::Optional - time to wait for a response
+    #
+    # === Return
+    # connected(Boolean):: true if a connection could be made, false otherwise
+    def self.can_contact_metadata_server?(addr, port, timeout=2)
+      t = Socket.new(Socket::Constants::AF_INET, Socket::Constants::SOCK_STREAM, 0)
+      saddr = Socket.pack_sockaddr_in(port, addr)
+      connected = false
+
+      begin
+        t.connect_nonblock(saddr)
+      rescue Errno::EINPROGRESS
+        r, w, e = IO::select(nil, [t], nil, timeout)
+        if !w.nil?
+          connected = true
+        else
+          begin
+            t.connect_nonblock(saddr)
+          rescue Errno::EISCONN
+            t.close
+            connected = true
+          rescue SystemCallError
+          end
+        end
+      rescue SystemCallError
+      end
+
+      connected
+    end
+
+    # Finds the first ip address for a given interface in the ohai mash
+    #
+    # === Parameters
+    # ohai(Mash):: ohai state
+    # interface(Symbol):: symbol of the interface (:eth0, :eth1, ...)
+    #
+    # === Return
+    # address(String|nil):: ip address associated with the given interface, nil if interface could not be found
+    def self.ip_for_interface(ohai, interface)
+      address = nil
+      if ohai[:network] != nil &&
+         ohai[:network][:interfaces] != nil &&
+         ohai[:network][:interfaces][interface] != nil &&
+         ohai[:network][:interfaces][interface][:addresses] != nil
+
+        addresses = ohai[:network][:interfaces][interface][:addresses].find { |key, item| item['family'] == 'inet' }
+        address = addresses.first unless addresses.nil?
+      end
+
+      address
+    end
+
+    # Finds the first ip address that matches a given connection type (private|public)
+    #
+    # === Parameters
+    # ohai(Mash):: ohai state
+    # connection_type(Symbol):: either 'public' or 'private'
+    #
+    # === Return
+    # address(String|nil):: ip address associated with the given interface, nil if interface could not be found
+    def self.ip_for_windows_interface(ohai, connection_type)
+      address = nil
+
+      # find the right interface
+      if ohai[:network] != nil &&
+         ohai[:network][:interfaces] != nil
+        interface = ohai[:network][:interfaces].values.find do |item|
+          !(item.nil? || item[:instance].nil?) && item[:instance][:net_connection_id] == connection_type
+        end
+
+        # grab the ip if there is one
+        if interface != nil &&
+           interface["configuration"] != nil &&
+           interface["configuration"]["ip_address"] != nil
+          address = interface["configuration"]["ip_address"].first
+        end
+      end
+
+      address
+    end
+
+    # Splits data on the given splitter character and merges to the given hash.
+    #
+    # === Parameters
+    # data(String):: raw data
+    # splitter(String):: splitter character
+    # hash(Hash):: hash to merge
+    # name_value_delimiter(String):: name/value delimiter (defaults to '=')
+    #
+    # === Return
+    # hash(Hash):: merged hash result
+    def self.split_metadata(data, splitter, hash, name_value_delimiter = '=')
+      data.split(splitter).each do |pair|
+        name, value = pair.split(name_value_delimiter, 2)
+        hash[name.strip] = value.strip if name && value
+      end
+      hash
+    end
+
+    # Queries a whats-my-ip service for the public IP address of this instance.
+    # can query either for an expected IP or for any IP which is voted by majority
+    # (or unanimously). this is no guarantee that an instance actually has a public
+    # IP individually assigned to it as a private cloud instance will still appear
+    # to have it's router's public IP as it's own address.
+    #
+    # === Parameters
+    # options[:expected_ip](String):: expected IP address or nil (no DNS names)
+    # options[:unanimous][TrueClass|FalseClass]:: true if vote must be unanimous, false for simple majority of all responders
+    # options[:host_name](String):: host name for whats-my-ip query or DEFAULT_WHATS_MY_IP_HOST_NAME
+    # options[:logger](Logger):: logger or defaults to null logger
+    # options[:timeout][Fixnum]:: timeout in seconds or DEFAULT_WHATS_MY_IP_TIMEOUT
+    # options[:retry_delay][Fixnum]:: retry delay in seconds or DEFAULT_WHATS_MY_IP_RETRY_DELAY
+    #
+    # === Return
+    # public_ip(String):: the consensus public IP for this instance or nil
+    def self.query_whats_my_ip(options={})
+      expected_ip = options[:expected_ip]
+      raise ArgumentError.new("expected_ip is invalid") if expected_ip && !(expected_ip =~ IP_ADDRESS_REGEX)
+      unanimous = options[:unanimous] || false
+      host_name = options[:host_name] || DEFAULT_WHATS_MY_IP_HOST_NAME
+      logger = options[:logger] || Logger.new(::RightScale::Platform::Shell::NULL_OUTPUT_NAME)
+      timeout = options[:timeout] || DEFAULT_WHATS_MY_IP_TIMEOUT
+      retry_delay = options[:retry_delay] || DEFAULT_WHATS_MY_IP_RETRY_DELAY
+
+      if expected_ip
+        logger.info("Waiting for IP=#{expected_ip}")
+      else
+        logger.info("Waiting for any IP to converge.")
+      end
+
+      # attempt to dig some hosts.
+      hosts = `dig +short #{host_name}`.strip.split
+      if hosts.empty?
+        logger.info("No hosts to poll for IP from #{host_name}.")
+      else
+        # a little randomization avoids hitting the same hosts from each
+        # instance since there is no guarantee that the hosts are returned in
+        # random order.
+        hosts = hosts.sort { (rand(2) * 2) - 1 }
+        if logger.debug?
+          message = ["Using these hosts to check the IP:"]
+          hosts.each { |host| message << "  #{host}" }
+          message << "-------------------------"
+          logger.debug(message.join("\n"))
+        end
+
+        unanimity = hosts.count
+        required_votes = unanimous ? unanimity : (1 + unanimity / 2)
+        logger.info("Required votes = #{required_votes}/#{unanimity}")
+        end_time = Time.now + timeout
+        loop do
+          reported_ips_to_voters = {}
+          address_to_hosts = {}
+          hosts.each do |host|
+            address = `curl --max-time 1 -S -s http://#{host}/ip/mine`.strip
+            logger.debug("Host=#{host} reports IP=#{address}")
+            address_to_hosts[address] ||= []
+            address_to_hosts[address] << host
+            if expected_ip
+              vote = (address_to_hosts[expected_ip] || []).count
+              popular_address = expected_ip
+            else
+              popular_address = nil
+              vote = 0
+              address_to_hosts.each do |address, hosts|
+                if hosts.count > vote
+                  vote = hosts.count
+                  popular_address = address
+                end
+              end
+            end
+            if vote >= required_votes
+              logger.info("IP=#{popular_address} has the required vote count of #{required_votes}.")
+              return popular_address
+            end
+          end
+
+          # go around again, if possible.
+          now_time = Time.now
+          break if now_time >= end_time
+          retry_delay = [retry_delay, end_time - now_time].min.to_i
+          logger.debug("Sleeping for #{retry_delay} seconds...")
+          sleep retry_delay
+          retry_delay = [retry_delay * 2, 60].min  # a little backoff helps when launching thousands
+        end
+        logger.info("Never got the required vote count of #{required_votes}/#{unanimity} after #{timeout} seconds; public IP did not converge.")
+        return nil
+      end
+    end
+  end
+end

data/lib/clouds/clouds/azure.rb

@@ -0,0 +1,106 @@
+#
+# Copyright (c) 2012 RightScale Inc
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+# Location for injected certificate
+CERT_FILE = '/var/lib/waagent/Certificates.pem'
+
+# Windows changes the ST=CA portion of our issuer name to S=CA at some point.
+ISSUER_STATE_KEY = platform.windows? ? 'S' : 'ST'
+
+# dependencies.
+metadata_source 'metadata_sources/certificate_metadata_source'
+metadata_writers 'metadata_writers/dictionary_metadata_writer',
+                 'metadata_writers/ruby_metadata_writer',
+                 'metadata_writers/shell_metadata_writer'
+
+# set abbreviation for non-RS env var generation
+abbreviation :waz
+
+# Parses azure user metadata into a hash.
+#
+# === Parameters
+# tree_climber(MetadataTreeClimber):: tree climber
+# data(String):: raw data
+#
+# === Return
+# result(Hash):: Hash-like leaf value
+def create_user_metadata_leaf(tree_climber, data)
+  result = tree_climber.create_branch
+  ::RightScale::CloudUtilities.split_metadata(data.strip, '&', result)
+  result
+end
+
+# defaults.
+default_option([:metadata_source, :user_metadata_cert_store], platform.windows? ? "cert:/LocalMachine/My" : CERT_FILE)
+default_option([:metadata_source, :user_metadata_cert_issuer], "O=RightScale, C=US, #{ISSUER_STATE_KEY}=CA, CN=RightScale User Data")
+
+default_option([:user_metadata, :metadata_tree_climber, :create_leaf_override], method(:create_user_metadata_leaf))
+
+def wait_for_instance_ready
+  if platform.linux?
+    STDOUT.puts "Waiting for instance to appear ready."
+    until File.exist?(CERT_FILE) && File.mtime(CERT_FILE).to_f > platform.shell.booted_at.to_f do
+      sleep(1)
+    end
+    STDOUT.puts "Instance appears ready."
+  end
+end
+
+# Determines if the current instance is running on azure.
+#
+# === Return
+# true if running on azure
+def is_current_cloud?
+  # FIX: the presence of the user data cert isn't sufficient criteria to
+  # determine whether this is an azure instance. is there a mac address we can
+  # check against? in the meantime, just say no.
+  false
+end
+
+# Updates the given node with azure details.
+#
+# === Return
+# always true
+def update_details
+  details = {}
+  if ohai = @options[:ohai_node]
+    # FIX: there is currently no instance-facing API (i.e. an API which does not
+    # require management credentials) to provide the instance's public IP address
+    # so a workaround is required until the instance-facing API is available.
+    if public_ip = ::RightScale::CloudUtilities.query_whats_my_ip(:logger=>logger)
+      details[:public_ip] = public_ip
+    end
+    if platform.windows?
+      interface_names = ['Local Area Connection', # Windows Server 2008 R2
+                         'Ethernet']              # Windows Server 2012+ (?)
+      interface_names.each do |interface_name|
+        if ip = ::RightScale::CloudUtilities.ip_for_windows_interface(ohai, interface_name)
+          details[:private_ip] = ip
+          break
+        end
+      end
+    else
+      details[:private_ip] = ::RightScale::CloudUtilities.ip_for_interface(ohai, :eth0)
+    end
+  end
+  return details
+end