right_link 5.9.0

data/lib/clouds/metadata_tree_climber.rb

@@ -0,0 +1,144 @@
+#
+# Copyright (c) 2010-11 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 File.normalize_path(File.join(File.dirname(__FILE__), 'metadata_tree_climber'))
+
+module RightScale
+
+  # Provides rules for building a standard metadata tree from raw data and
+  # expanding multi-line leaf values into arrays. Details of querying raw
+  # metadata are external to this class.
+  class MetadataTreeClimber
+
+    attr_accessor :root_path, :tree_class, :child_name_delimiter
+
+    # Initializer.
+    #
+    # === Parameters
+    # options[:tree_class](Class):: Hash-like class to use when building
+    #  metadata tree (defaults to Hash)
+    def initialize(options = {})
+      # parameters
+      raise ArgumentError.new("options[:root_path] is required") unless @root_path = options[:root_path]
+      raise ArgumentError.new("options[:user_metadata_root_path] is required") unless @user_metadata_root_path = options[:user_metadata_root_path]
+      @tree_class = options[:tree_class] || Hash
+      @child_name_delimiter = options[:child_name_delimiter] || "\n"
+
+      # callbacks (optional)
+      @branch_key_override = options[:branch_key_override]
+      @child_names_override = options[:child_names_override]
+      @create_leaf_override = options[:create_leaf_override]
+      @has_children_override = options[:has_children_override]
+      @leaf_key_override = options[:leaf_key_override]
+    end
+
+    # Determines if the given path represents a parent branch. This information
+    # can be empirically determined from the path by the appearance of a
+    # trailing forward slash using the HTTP convention (even if metadata source
+    # is not an HTTP connection) except for the root which must be tested
+    # specially.
+    #
+    # === Parameters
+    # path(String):: path to metadata
+    # query_result(String):: raw data queried using path
+    #
+    # === Return
+    # result(Boolean):: true if branch, false if leaf
+    def has_children?(path, query_result)
+      return @has_children_override.call(self, path, query_result) if @has_children_override
+      # default behavior for user metadata is flat; currently no known use cases of hierarchical user metadata.
+      return (@user_metadata_root_path != @root_path) && ('/' == path[-1..-1] || path == @root_path)
+    end
+
+    # Determines if the given raw value contains branch/leaf names and returns
+    # them as pair of Hash-like objects of keys with nil values.
+    #
+    # === Parameters
+    # path(String):: path to metadata
+    # query_result(String):: raw data queried using path
+    #
+    # === Returns
+    # result(Array):: array of child (leaf or branch) names or empty
+    def child_names(path, query_result)
+      return @child_names_override.call(self, path, query_result) if @child_names_override
+      child_names = []
+      sub_values = query_result.gsub("\r\n", "\n").split(@child_name_delimiter)
+      sub_values.each do |sub_value|
+        sub_value.strip!
+        (child_names << sub_value) unless sub_value.empty?
+      end
+      return child_names
+    end
+
+    # Creates a new empty tree node based on the class specified in options.
+    #
+    # === Returns
+    # result(Hash):: new Hash-like node
+    def create_branch
+      @tree_class.new
+    end
+
+    # Creates a new leaf using the given information (from which leaf type can
+    # be inferred, etc.).
+    #
+    # === Parameters
+    # path(String):: path to metadata
+    # data(String):: raw data queried using path
+    #
+    def create_leaf(path, data)
+      return @create_leaf_override.call(self, data) if @create_leaf_override
+      return data.to_s.strip
+    end
+
+    # Looks for equals anywhere in the sub-value or trailing forward slash at
+    # the end of the sub-value.
+    #
+    # === Parameters
+    # branch_name(String):: branch name
+    #
+    # === Returns
+    # key(String):: branch key or nil
+    def branch_key(branch_name)
+      return @branch_key_override.call(self, branch_name) if (branch_name && @branch_key_override)
+
+      # replace any equals and subsequent text with forward slash and chomp any
+      # trailing slash. note that chomp! returns nil if character (i.e. slash)
+      # is not found at end.
+      return branch_name.gsub(/=.*$/, '/').gsub('-', '_').chomp!('/')
+    end
+
+    # Leaf name is used as key by default.
+    #
+    # === Parameters
+    # leaf_name(String):: leaf name
+    #
+    # === Returns
+    # key(String):: leaf key or nil
+    def leaf_key(leaf_name)
+      return @leaf_key_override.call(self, leaf_name) if @leaf_key_override
+      # replace '-' and '/' with '_' so that metadata keys are Mash friendly
+      return leaf_name.gsub('-', '_')
+    end
+
+  end
+
+end

data/lib/clouds/metadata_writer.rb

@@ -0,0 +1,155 @@
+#
+# Copyright (c) 2010 by RightScale Inc., all rights reserved
+#
+# Write given user data to files in /var/spool/ec2 in text, shell and ruby 
+# script formats
+
+module RightScale
+
+  # Base implementation for a metadata writer. By default writes a raw
+  # metadata format.
+  class MetadataWriter
+    DEFAULT_FILE_MODE = 0640
+
+    attr_accessor :file_extension, :file_name_prefix, :output_dir_path
+
+    # Initializer
+    #
+    # === Parameters
+    # options[:file_extension](String):: output file extension
+    # options[:file_name_prefix](String):: output file name sans extension
+    # options[:output_dir_path](String):: output directory, defaults to RS spool dir
+    # options[:read_override](Proc(reader, subpath):: read override or nil
+    # options[:write_override](Proc(writer, metadata subpath):: write override or nil
+    #
+    # === Return
+    # always true
+    def initialize(options)
+      raise ArgumentError.new("options[:file_name_prefix] is required") unless @file_name_prefix = options[:file_name_prefix]
+      raise ArgumentError.new("options[:output_dir_path] is required") unless @output_dir_path = options[:output_dir_path]
+      @file_extension = options[:file_extension] || '.raw'
+      @read_override = options[:read_override]
+      @write_override = options[:write_override]
+    end
+
+    # Reads metadata from file.
+    #
+    # === Parameters
+    # subpath(Array|String):: subpath or nil
+    #
+    # === Return
+    # result(String):: contents of generated file
+    def read(subpath = nil)
+      return @read_override.call(self, subpath) if @read_override
+      return read_file(subpath)
+    end
+
+    # Writes given metadata to file.
+    #
+    # === Parameters
+    # metadata(Hash):: Hash-like metadata
+    # subpath(Array|String):: subpath if deeper than root or nil
+    #
+    # === Return
+    # always true
+    def write(metadata, subpath = nil)
+      return @write_override.call(self, metadata, subpath) if @write_override
+      return write_file(metadata, subpath)
+    end
+
+    # Escapes double-quotes (and literal backslashes since they are escape
+    # characters) in the given string.
+    def self.escape_double_quotes(value)
+      return value.gsub(/\\|"/) { |c| "\\#{c}" }
+    end
+
+    # Escapes single-quotes (and literal backslashes since they are escape
+    # characters) in the given string.
+    def self.escape_single_quotes(value)
+      return value.gsub(/\\|'/) { |c| "\\#{c}" }
+    end
+
+    # Determines the first line of text (or the only line) for the given value.
+    #
+    # === Parameters
+    # value(Object):: any value
+    #
+    # === Return
+    # result(String):: first line or empty
+    def self.first_line_of(value)
+      # flatten any value which supports it
+      value = value.flatten if value.respond_to?(:flatten)
+
+      # note that the active_support gem redefines String.first from being the
+      # same as .lines.first to returning the .first(n=1) characters.
+      if value.respond_to?(:lines)
+        value = value.lines.first
+      elsif value.respond_to?(:first)
+        value = value.first
+      end
+      return value.to_s.strip
+    end
+
+    protected
+
+    # Full path of generated file.
+    #
+    # === Parameters
+    # file_name(String):: output file name without extension
+    # subpath(Array|String):: subpath if deeper than root or nil
+    #
+    # === Return
+    # result(String):: full path of generated file
+    def full_path(file_name, subpath = nil)
+      if subpath
+        # legacy ec2 support omits file extension and creates a parent dir
+        # using file name prefix; this is the default behavior.
+        subpath = subpath.join('-') if subpath.kind_of?(Array)
+        subpath = subpath.gsub(/[\/\\]+/, '-').gsub(/^-+|-+$/, '')
+        return File.normalize_path(File.join(@output_dir_path, file_name, subpath)) unless subpath.empty?
+      end
+
+      return File.normalize_path(File.join(@output_dir_path, "#{file_name}#{@file_extension}"))
+    end
+
+    # Creates the parent directory for the full path of generated file.
+    #
+    # === Parameters
+    # file_name(String):: output file name without extension
+    # subpath(Array|String):: subpath if deeper than root or nil
+    #
+    # === Return
+    # result(String):: full path of generated file
+    def create_full_path(file_name, subpath = nil)
+      path = full_path(file_name, subpath)
+      FileUtils.mkdir_p(File.dirname(path))
+      path
+    end
+
+    # Reads metadata from file.
+    #
+    # === Parameters
+    # subpath(Array|String):: subpath if deeper than root or nil
+    #
+    # === Return
+    # result(String):: contents of generated file or empty
+    def read_file(subpath)
+      path = full_path(@file_name_prefix, subpath)
+      return File.file?(path) ? File.read(path) : ''
+    end
+
+    # Writes given metadata to file.
+    #
+    # === Parameters
+    # metadata(Hash):: Hash-like metadata to write
+    # subpath(Array|String):: subpath if deeper than root or nil
+    #
+    # === Return
+    # always true
+    def write_file(metadata, subpath)
+      File.open(create_full_path(@file_name_prefix, subpath), "w", DEFAULT_FILE_MODE) { |f| f.write(metadata.to_s) }
+    end
+
+  end  # MetadataWriter
+
+end  # RightScale

data/lib/clouds/metadata_writers/dictionary_metadata_writer.rb

@@ -0,0 +1,72 @@
+#
+# Copyright (c) 2010 by RightScale Inc., all rights reserved
+#
+# Write given user data to files in /var/spool/ec2 in text, shell and ruby 
+# script formats
+
+module RightScale
+
+  module MetadataWriters
+
+    # Dictionary (key=value pairs) writer.
+    class DictionaryMetadataWriter < MetadataWriter
+
+      # Initializer.
+      #
+      # === Parameters
+      # options[:file_extension](String):: dotted extension for dictionary files or nil
+      def initialize(options)
+        # defaults
+        options = options.dup
+        options[:file_extension] ||= '.dict'
+
+        # super
+        super(options)
+      end
+
+      protected
+
+      # Read a dictionary file on disk and parse into key/value pairs.
+      #
+      # === Parameters
+      # subpath(Array|String):: subpath or nil
+      #
+      # === Return
+      # result(Hash):: dictionary of metadata
+      def read_file(subpath = nil)
+        result = {}
+        path = full_path(@file_name_prefix, subpath)
+        contents = File.file?(path) ? File.read(path) : ''
+        contents.each do |line|
+          match = line.chomp.match(/^(.+)=(.*)$/)
+          result[match[1]] = match[2]
+        end
+        result
+      end
+
+      # Write given metadata to a dictionary file.
+      #
+      # === Parameters
+      # metadata(Hash):: Hash-like metadata to write
+      # subpath(Array|String):: subpath or nil
+      #
+      # === Return
+      # always true
+      def write_file(metadata, subpath = nil)
+        return super(metadata, subpath) unless metadata.respond_to?(:has_key?)
+        File.open(create_full_path(@file_name_prefix, subpath), "w", DEFAULT_FILE_MODE) do |f|
+          metadata.each do |k, v|
+            # ensure value is a single line by truncation since most
+            # dictionary format parsers expect literal chars on a single line.
+            v = self.class.first_line_of(v)
+            f.puts "#{k}=#{v}"
+          end
+        end
+        true
+      end
+
+    end  # DictionaryMetadataWriter
+
+  end  # MetadataWriters
+
+end  # RightScale

data/lib/clouds/metadata_writers/ruby_metadata_writer.rb

@@ -0,0 +1,76 @@
+#
+# Copyright (c) 2010 by RightScale Inc., all rights reserved
+#
+# Write given user data to files in /var/spool/ec2 in text, shell and ruby 
+# script formats
+
+module RightScale
+
+  module MetadataWriters
+
+    # Ruby script writer
+    class RubyMetadataWriter < MetadataWriter
+
+      attr_accessor :generation_command
+
+      # Initializer.
+      #
+      # === Parameters
+      # options[:file_extension](String):: dotted extension for ruby files or nil
+      def initialize(options)
+        # defaults
+        options = options.dup
+        options[:file_extension] ||= '.rb'
+
+        # super
+        super(options)
+
+        # local options.
+        @generation_command = options[:generation_command]
+      end
+
+      protected
+
+      RUBY_HEADER = ['# Warning: this file has been auto-generated',
+                     '# any modifications can be overwritten']
+
+      # Write given metadata to a ruby file.
+      #
+      # === Parameters
+      # file_name_prefix(String):: name prefix for generated file
+      # metadata(Hash):: Hash-like metadata to write
+      # subpath(Array|String):: subpath or nil
+      #
+      # === Return
+      # always true
+      def write_file(metadata, subpath)
+        return super(metadata, subpath) unless metadata.respond_to?(:has_key?)
+
+        # write the cached file variant if the code-generation command line was passed.
+        env_file_name = @generation_command ? "#{@file_name_prefix}-cache" : @file_name_prefix
+        env_file_path = create_full_path(env_file_name, subpath)
+        File.open(env_file_path, "w", DEFAULT_FILE_MODE) do |f|
+          f.puts RUBY_HEADER
+          metadata.each do |k, v|
+            # escape backslashes and single quotes.
+            v = self.class.escape_single_quotes(v)
+            f.puts "ENV['#{k}']='#{v}'"
+          end
+        end
+ 
+        # write the generation command, if given.
+        if @generation_command
+          File.open(create_full_path(@file_name_prefix, subpath), "w", DEFAULT_FILE_MODE) do |f|
+            f.puts RUBY_HEADER
+            f.puts "raise 'ERROR: unable to fetch metadata' unless system(\"#{@generation_command}\")"
+            f.puts "require '#{env_file_path}'"
+          end
+        end
+        true
+      end
+
+    end  # RubyMetadataWriter
+
+  end  # MetadataWriters
+
+end  # RightScale

data/lib/clouds/metadata_writers/shell_metadata_writer.rb

@@ -0,0 +1,121 @@
+#
+# Copyright (c) 2010 by RightScale Inc., all rights reserved
+#
+# Write given user data to files in /var/spool/ec2 in text, shell and ruby 
+# script formats
+
+module RightScale
+
+  module MetadataWriters
+
+    # Shell script writer.
+    class ShellMetadataWriter < MetadataWriter
+
+      attr_accessor :generation_command
+
+      # Initializer.
+      #
+      # === Parameters
+      # options[:file_extension](String):: dotted extension for shell files or nil
+      def initialize(options)
+        # defaults
+        options = options.dup
+        default_file_extension = RightScale::Platform.windows? ? '.bat' : '.sh'
+        options[:file_extension] ||= default_file_extension
+        @generation_command = options[:generation_command]
+
+        # super
+        super(options)
+      end
+
+      protected
+
+      if RightScale::Platform.windows?
+
+        WINDOWS_SHELL_HEADER = ['@echo off',
+                                'rem # Warning: this file has been auto-generated',
+                                'rem # any modifications can be overwritten']
+
+        # Write given metadata to a bash file.
+        #
+        # === Parameters
+        # metadata(Hash):: Hash-like metadata to write
+        # subpath(Array|String):: subpath or nil
+        #
+        # === Return
+        # always true
+        def write_file(metadata, subpath)
+          return super(metadata, subpath) unless metadata.respond_to?(:has_key?)
+
+          # write the cached file variant if the code-generation command line was passed.
+          env_file_name = @generation_command ? "#{@file_name_prefix}-cache" : @file_name_prefix
+          env_file_path = create_full_path(env_file_name, subpath)
+          File.open(env_file_path, "w", DEFAULT_FILE_MODE) do |f|
+            f.puts(WINDOWS_SHELL_HEADER)
+            metadata.each do |k, v|
+              # ensure value is a single line (multiple lines could be interpreted
+              # as subsequent commands) by truncation since windows shell doesn't
+              # have escape characters.
+              v = self.class.first_line_of(v)
+              f.puts "set #{k}=#{v}"
+            end
+          end
+
+          # write the generation command, if given.
+          if @generation_command
+            File.open(create_full_path(@file_name_prefix, subpath), "w", DEFAULT_FILE_MODE) do |f|
+              f.puts(WINDOWS_SHELL_HEADER)
+              f.puts(@generation_command)
+              f.puts("call \"#{env_file_path}\"")
+            end
+          end
+          true
+        end
+
+      else  # not windows
+
+        LINUX_SHELL_HEADER = ['#!/bin/bash',
+                              '# Warning: this file has been auto-generated',
+                              '# any modifications can be overwritten']
+
+        # Write given metadata to a bash file.
+        #
+        # === Parameters
+        # metadata(Hash):: Hash-like metadata to write
+        # subpath(Array|String):: subpath or nil
+        #
+        # === Return
+        # always true
+        def write_file( metadata, subpath)
+          return super(metadata, subpath) unless metadata.respond_to?(:has_key?)
+
+          # write the cached file variant if the code-generation command line was passed.
+          env_file_name = @generation_command ? "#{@file_name_prefix}-cache" : @file_name_prefix
+          env_file_path = create_full_path(env_file_name, subpath)
+          File.open(env_file_path, "w", DEFAULT_FILE_MODE) do |f|
+            f.puts(LINUX_SHELL_HEADER)
+            metadata.each do |k, v|
+              # escape backslashes and double quotes.
+              v = self.class.escape_double_quotes(v)
+              f.puts "export #{k}=\"#{v}\""
+            end
+          end
+
+          # write the generation command, if given.
+          if @generation_command
+            File.open(create_full_path(@file_name_prefix, subpath), "w", DEFAULT_FILE_MODE) do |f|
+              f.puts(LINUX_SHELL_HEADER)
+              f.puts(@generation_command)
+              f.puts(". #{env_file_path}")
+            end
+          end
+          true
+        end
+
+      end  # if windows
+
+    end  # ShellMetadataWriter
+
+  end  # MetadataWriters
+
+end  # RightScale

data/lib/clouds/register_clouds.rb

@@ -0,0 +1,34 @@
+#
+# 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 File.normalize_path(File.join(File.dirname(__FILE__), '..', 'clouds'))
+
+begin
+  base_clouds_dir_path = File.join(File.dirname(__FILE__), 'clouds')
+
+  # dynamically register all clouds using the script name as cloud name.
+  pattern = File.join(base_clouds_dir_path, '*.rb')
+  Dir[pattern].each do |cloud_script_path|
+    cloud_name = File.basename(cloud_script_path, '.rb')
+    RightScale::CloudFactory.instance.register(cloud_name, cloud_script_path)
+  end
+end

data/lib/clouds.rb

@@ -0,0 +1,32 @@
+#
+# 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.
+
+CLOUDS_BASE_DIR = File.join(File.dirname(__FILE__), 'clouds')
+
+require File.normalize_path(File.join(CLOUDS_BASE_DIR, 'cloud'))
+require File.normalize_path(File.join(CLOUDS_BASE_DIR, 'cloud_factory'))
+require File.normalize_path(File.join(CLOUDS_BASE_DIR, 'cloud_utilities'))
+require File.normalize_path(File.join(CLOUDS_BASE_DIR, 'metadata_formatter'))
+require File.normalize_path(File.join(CLOUDS_BASE_DIR, 'metadata_provider'))
+require File.normalize_path(File.join(CLOUDS_BASE_DIR, 'metadata_source'))
+require File.normalize_path(File.join(CLOUDS_BASE_DIR, 'metadata_tree_climber'))
+require File.normalize_path(File.join(CLOUDS_BASE_DIR, 'metadata_writer'))