skytap-yf 0.2.3

data/lib/skytap/commands/http.rb

@@ -0,0 +1,196 @@
+require 'skytap/requester'
+
+module Skytap
+  module Commands
+    class HttpBase < Base
+      self.ask_interactively = false
+
+      class << self
+        # This is a factory that is called on subclasses.
+        def make_for(command_class, spec={})
+          command_name = self.command_name
+          Class.new(self).tap do |klass|
+            klass.parent = command_class
+            klass.singleton_class.send(:define_method, :command_name) { command_name }
+            klass.spec = spec || {}
+          end
+        end
+      end
+
+      def requester
+        base_url = global_options[:'base-url'] or raise Skytap::Error.new 'Must provide base-url option'
+        http_format = global_options[:'http-format'] or raise Skytap::Error.new 'Must provide http-format option'
+        verify_certs = global_options.has_key?(:'verify-certs') ? global_options[:'verify-certs'] : true
+
+        @requester ||= Requester.new(logger, username, api_token, base_url, http_format, verify_certs)
+      end
+
+      def root_path
+        "/#{resource.pluralize}"
+      end
+
+      def resource_path(id)
+        "#{root_path}/#{id}"
+      end
+
+      def resource
+        parent.command_name
+      end
+
+      def encode_body(params)
+        return unless params.present?
+
+        case format = global_options[:'http-format']
+        when 'json'
+          JSON.dump(params)
+        when 'xml'
+          params.to_xml(:root => resource)
+        else
+          raise "Unknown http-format: #{format.inspect}"
+        end
+      end
+
+      def request(method, path, options={})
+        response = requester.request(method, path, options_for_request)
+        success = response.code.start_with?('2')
+
+        logger.info "Code: #{response.code} #{response.message}".color(success ? :green : :red).bright
+        logger.puts response.pretty_body
+        response.tap do |resp|
+          resp.singleton_class.instance_eval do
+            define_method(:payload) do
+              return unless body.present?
+
+              case self['Content-Type']
+              when /json/i
+                JSON.load(body)
+              when /xml/i
+                parsed = Hash.from_xml(body)
+                # Strip out the root name.
+                if parsed.is_a?(Hash)
+                  parsed.values.first
+                else
+                  parsed
+                end
+              else
+                body
+              end
+            end
+          end
+        end
+      end
+
+      def options_for_request
+        {:raise => false}.tap do |options|
+          if ask_interactively
+            options[:body] = encode_body(composed_params)
+          else
+            options[:params] = composed_params
+          end
+        end
+      end
+
+      def expected_args
+        ActiveSupport::OrderedHash.new.tap do |expected|
+          if parent_resources = parent.spec['parent_resources']
+            example_path = join_paths(*parent_resources.collect {|r| [r.pluralize, "#{r.singularize.upcase}-ID"]}.flatten)
+            expected['parent_path'] = "path of parent #{'resource'.pluralize(parent_resources.length)}, in the form #{example_path}"
+          end
+        end
+      end
+
+      def parent_path
+        if expected_args['parent_path']
+          index = expected_args.keys.index('parent_path')
+          path = args[index].dup
+        end
+      end
+
+      def path
+        path = parent_path || ''
+        if expected_args['id']
+          index = expected_args.keys.index('id')
+          id = args[index]
+          join_paths(path, resource_path(id))
+        else
+          join_paths(path, root_path)
+        end
+      end
+
+      def join_paths(*parts)
+        '/' + parts.collect{|p| p.split('/')}.flatten.reject(&:blank?).join('/')
+      end
+
+      def get(*args)    ; request('GET', *args) ; end
+      def post(*args)   ; request('POST', *args) ; end
+      def put(*args)    ; request('PUT', *args) ; end
+      def delete(*args) ; request('DELETE', *args) ; end
+    end
+
+
+    class Show < HttpBase
+      def expected_args
+        super.merge('id' => "ID or URL of #{resource} to show")
+      end
+
+      def self.default_description
+        "Show specified #{parent.command_name.gsub('_', ' ')}"
+      end
+
+      def run!
+        get(path)
+      end
+    end
+
+    class Index < HttpBase
+      def self.default_description
+        "Show all #{parent.command_name.pluralize.gsub('_', ' ')} to which you have access"
+      end
+
+      def run!
+        get(path)
+      end
+    end
+
+    class Create < HttpBase
+      self.ask_interactively = true
+
+      def self.default_description
+        "Create #{parent.command_name.gsub('_', ' ')}"
+      end
+
+      def run!
+        post(path)
+      end
+    end
+
+    class Destroy < HttpBase
+      def expected_args
+        super.merge('id' => "ID or URL of #{resource} to delete")
+      end
+
+      def self.default_description
+        "Delete specified #{parent.command_name.gsub('_', ' ')}"
+      end
+
+      def run!
+        delete(path)
+      end
+    end
+
+    class Update < HttpBase
+      def expected_args
+        super.merge('id' => "ID or URL of #{resource} to update")
+      end
+      self.ask_interactively = true
+
+      def self.default_description
+        "Update attributes of specified #{parent.command_name.gsub('_', ' ')}"
+      end
+
+      def run!
+        put(path)
+      end
+    end
+  end
+end

data/lib/skytap/commands/root.rb

@@ -0,0 +1,79 @@
+module Skytap
+  module Commands
+    class Root < Base
+      self.container = true
+
+      def self.go!(logger, args, global_options, command_options, programmatic_context=false, &invoker)
+        new(logger, args, global_options, command_options, programmatic_context, &invoker).invoke
+      end
+
+      def self.banner_prefix
+        'skytap'
+      end
+
+      def self.command_name
+        nil
+      end
+
+      def self.populate_with(specification={})
+        self.subcommands = specification.sort.collect do |resource, spec|
+          Base.make_from(resource, spec).tap do |klass|
+            klass.parent = self
+          end
+        end
+      end
+
+      def run!
+        help!
+      end
+
+      def help_with_initial_setup!
+        if SkytapRC.exists? || !solicit_user_input?
+          help_without_initial_setup!
+        else
+          logger.puts <<-"EOF"
+Do you want to store your API credentials in a text file for convenience?
+
+If you answer yes, your username and API token will be stored in a .skytaprc
+file in plain text. If you answer no, you must provide your username and API
+token each time you invoke this tool.
+
+          EOF
+          if ask('Store username?', ActiveSupport::OrderedHash['y', true, 'n', false, :default, 'y'])
+            username = ask('Skytap username:') while username.blank?
+          end
+          if ask('Store API token?', ActiveSupport::OrderedHash['y', true, 'n', false, :default, 'y'])
+            logger.puts "\nYour API security token is on the My Account page.\nIf missing, ask your admin to enable API tokens on the Security Policies page."
+            # Allow API token to be blank, in case the user realizes they don't have one.
+            api_token = ask('API token:')
+          end
+
+          logger.puts <<-"EOF"
+
+Do you want to turn on interactive mode?
+
+If so, you will be shown the request parameters available for a command and
+asked if you want to enter any. If you plan to use this tool primarily in
+scripts, you may want to answer no.
+          EOF
+
+          ask_mode = ask('Enable interactive mode?', ActiveSupport::OrderedHash['y', true, 'n', false, :default, 'y'])
+
+          config = global_options.symbolize_keys.merge(:username => username, :'api-token' => api_token, :ask => ask_mode)
+
+          SkytapRC.write(config)
+
+          logger.puts <<-"EOF"
+Config file written to #{SkytapRC::RC_FILE}.
+
+Example commands:
+#{'skytap'.bright} - show all commands
+#{'skytap help configuration'.bright} - show configuration commands
+#{'skytap help vm upload'.bright} - help for VM upload command
+          EOF
+        end
+      end
+      alias_method_chain :help!, :initial_setup
+    end
+  end
+end

data/lib/skytap/commands.rb

@@ -0,0 +1,9 @@
+require 'skytap/commands/base'
+require 'skytap/commands/root'
+require 'skytap/commands/http'
+
+module Skytap
+  module Commands
+    class NotImplementedError < RuntimeError ; end
+  end
+end

data/lib/skytap/core_ext.rb

@@ -0,0 +1,8 @@
+class Hash
+  def subset(keys)
+    keys = keys.to_set
+    reject do |k, v|
+      !keys.include?(k)
+    end
+  end
+end

data/lib/skytap/error.rb

@@ -0,0 +1,4 @@
+module Skytap
+  class Error < RuntimeError
+  end
+end

data/lib/skytap/help_templates/help.erb

@@ -0,0 +1,52 @@
+<% if error_msg -%>
+<%= error_msg %>
+
+
+<% end -%>
+<% if command.container -%>
+<%= header('SUBCOMMANDS') %>
+<% subcommands.each do |subcommand| -%>
+     <%= subcommand %>
+<% end -%>
+
+<%#TODO:NLA Only display this message if there are any scenarios/plugins. -%>
+     Scenarios and plugins are highlighted in blue.
+<% else -%>
+<%= header('SYNOPSIS') %>
+     <%= command.synopsis %>
+<% end -%>
+<% if command.description -%>
+
+<%= header('DESCRIPTION') %>
+<%= indent(command.class.description) %>
+<% end -%>
+<% if command.expected_args.present? -%>
+
+<%= header('ARGUMENTS') %>
+<% command.expected_args.each do |name, desc| -%>
+     <%= name.upcase %> - <%= desc %>
+<% end -%>
+<% end -%>
+<% if command.expected_options.present? -%>
+
+<%= header('COMMAND OPTIONS') %>
+<% command.expected_options.each do |name, info| -%>
+     <%= info[:flag_arg] ? "--#{name}=#{info[:flag_arg].upcase.gsub('-', '_')}" : "--#{name}" %> - <%= info[:desc] %>
+<% end -%>
+<% end -%>
+
+<%= header('GLOBAL OPTIONS') %>
+<%= global_options_table %>
+<% if command.parameters.present? -%>
+
+<%= header('PARAMETERS') %>
+     You may provide the following request parameters, either interactively
+     with --ask or using --param or --params-file:
+
+<%= parameters_table %>
+<% end -%>
+<% if error_msg -%>
+
+
+<%= error_msg %>
+<% end -%>

data/lib/skytap/ip_address.rb

@@ -0,0 +1,63 @@
+class IpAddress
+  class InvalidIp < RuntimeError; end
+  IP_REGEX = /^(0[0-7]*|0[x][0-9a-f]+|[1-9][0-9]*)\.(0[0-7]*|0[x][0-9a-f]+|[1-9][0-9]*)\.(0[0-7]*|0[x][0-9a-f]+|[1-9][0-9]*)\.(0[0-7]*|0[x][0-9a-f]+|[1-9][0-9]*)$/i
+  MAX_IP4_INT = 2**32 - 1
+
+  class << self
+    def str_to_int(str)
+      raise InvalidIp.new("'#{str}' does not look like an IP") unless str =~ IP_REGEX
+      bytes = [Integer($1), Integer($2), Integer($3), Integer($4)]
+      raise InvalidIp.new("'#{str}' octet exceeds 255") if bytes.any?{|b| b > 255}
+      bytes.zip([24, 16, 8, 0]).collect{|n,shift| n << shift}.inject(&:+)
+    end
+    def int_to_str(i)
+      raise InvalidIp.new("#{i} exceeds maximum IPv4 address") if i > MAX_IP4_INT
+      [24, 16, 8, 0].collect{|shift| (i & (255 << shift)) >> shift}.join('.')
+    end
+  end
+
+  def initialize(str_or_int)
+    if str_or_int.is_a?(String)
+      @i = self.class.str_to_int(str_or_int)
+    elsif str_or_int.is_a?(Integer)
+      raise InvalidIp.new("IP #{str_or_int} is greater than the maximum IPv4 value") if str_or_int > MAX_IP4_INT
+      raise InvalidIp.new("IP value must be non-negative")  if str_or_int < 0
+      @i = str_or_int
+    else
+      raise InvalidIp.new("Don't know how to make an IP out of #{str_or_int}")
+    end
+  end
+
+  def to_i
+    @i
+  end
+
+  def to_s
+    self.class.int_to_str(@i)
+  end
+
+  MAX_IP4 = self.new(MAX_IP4_INT)
+
+  # IpAddress arithmetic ops result in new IP addresses
+  [:+, :-, :&, :|, :<<, :>>].each do |name|
+    define_method(name) do |other|
+      IpAddress.new(@i.send(name, other.to_i))
+    end
+  end
+
+  # IpAddress comparisons just proxy to the .to_i value
+  [:==, :<, :>, :>=, :<=, :<=>].each do |name|
+    define_method(name) do |other|
+      @i.send(name, other.to_i)
+    end
+  end
+
+  def inverse
+    MAX_IP4 - self
+  end
+  alias_method :~, :inverse
+
+  def succ
+    self + 1
+  end
+end

data/lib/skytap/logger.rb

@@ -0,0 +1,52 @@
+module Skytap
+  class Logger
+    attr_accessor :log_level
+
+    def initialize(log_level)
+      @log_level = log_level
+    end
+
+    # The message is logged unconditionally.
+    def puts(msg = '', options = {})
+      do_log(msg, options)
+    end
+
+    # The message is logged unless the --quiet option is present.
+    def info(msg = '', options = {})
+      if log_level == 'info' || log_level == 'verbose'
+        do_log(msg, options)
+      end
+    end
+
+    def debug(msg = '', options = {})
+      if log_level == 'verbose'
+        do_log(msg, options)
+      end
+    end
+
+    def mute!
+      @muted = true
+    end
+
+    def unmute!
+      @muted = false
+    end
+
+    def muted?
+      !!@muted
+    end
+
+
+    private
+
+    def do_log(msg, options = {})
+      return if muted?
+      options = options.symbolize_keys
+      newline = options.has_key?(:newline) ? options[:newline] : true
+      $stdout.flush
+      $stdout.print msg
+      $stdout.puts if newline
+      $stdout.flush
+    end
+  end
+end

data/lib/skytap/plugins/vm_copy_to_region.rb

@@ -0,0 +1,200 @@
+module Skytap
+  module Commands
+    class CopyToRegion < Skytap::Commands::Base
+      CHECK_PERIOD = 20
+
+      self.parent = Vm
+      self.plugin = true
+
+      def self.command_name
+        'copytoregion'
+      end
+
+      def self.description
+        <<-"EOF"
+Copy one or more VMs to a new region
+
+This process involves exporting the VMs to the local filesystem,
+importing them into the new region, then deleting them from the local
+filesystem. Ensure you have sufficient disk space.
+        EOF
+      end
+
+      def expected_args
+        ActiveSupport::OrderedHash[
+          'region', 'Name of target region',
+          'vm_id*', 'One or more IDs of template VMs to copy to the region'
+        ]
+      end
+
+      def expected_options
+        ActiveSupport::OrderedHash[
+          :tmpdir, {:flag_arg => 'TMPDIR', :desc => 'Temporary directory into which to download VMs'},
+        ]
+      end
+
+      attr_reader :copiers
+
+      def run!
+        @copiers = []
+        region = args.shift
+        vm_ids = args.collect {|a| find_id(a)}
+
+        until vm_ids.empty? && concurrency == 0
+          if vm_ids.present?
+            cop = Copier.new(logger, username, api_token, vm_ids.shift, region, command_options[:tmpdir])
+            copiers << cop
+            if (line = cop.status_line).present?
+              logger.info "#{line}\n---"
+            end
+          else
+            sleep CHECK_PERIOD
+            if (lines = status_lines).present?
+              logger.info "#{lines}\n---"
+            end
+          end
+        end
+
+        response.tap do |res|
+          logger.info "#{'Summary:'.bright}\n#{res.payload}" unless res.error?
+        end
+      end
+
+      def status_lines
+        copiers.reject(&:finished?).collect(&:status_line).reject(&:blank?).join("\n")
+      end
+
+
+      private
+
+      def concurrency
+        copiers.select(&:alive?).length
+      end
+
+      def response
+        error = !copiers.any?(&:success?)
+        Response.build(copiers.collect(&:summary).join("\n"), error)
+      end
+    end
+
+    class Copier < Thread
+      attr_reader :logger, :vm_id, :region, :root_dir, :result, :username, :api_token
+
+      def initialize(logger, username, api_token, vm_id, region, root_dir = nil)
+        @logger = logger
+        @username = username
+        @api_token = api_token
+        @vm_id = vm_id
+        @region = region
+        @root_dir = File.expand_path(root_dir || '.')
+
+        warn_if_manual_network
+
+        super do
+          begin
+            run
+          rescue Exception => ex
+            @result = Response.build(ex)
+          end
+        end
+      end
+
+      def run
+        FileUtils.mkdir_p(root_dir)
+
+        #TODO:NLA Set vmdir = File.join(tmpdir, "tmp_vm_#{vm_id}"). Then on success, remove vmdir.
+
+        downloads = Skytap.invoke!(username, api_token, "vm download #{vm_id}", :dir => root_dir) do |downloader|
+          @no_slots_msg = if seconds = downloader.seconds_until_retry
+                            m = Integer(seconds / 60)
+                            "VM #{vm_id}: No export capacity is currently available on Skytap. Will retry ".tap do |msg|
+                              if m < 1
+                                msg << 'soon.'
+                              else
+                                msg << "in #{m} minutes or when more capacity is detected."
+                              end
+                            end.color(:yellow)
+                          end
+          @status_line = downloader.status_lines
+        end
+
+        @no_slots_msg = nil
+
+        vm_dir = File.join(root_dir, "vm_#{vm_id}")
+        unless downloads.include?(vm_dir)
+          raise Skytap::Error.new("Response dir unexpected (was: #{downloads}; expected to contain #{vm_dir})")
+        end
+
+        # Invoke with an array to treat vm_dir as one token, even if it contains spaces.
+        uploads = Skytap.invoke!(username, api_token, ['vm', 'upload', vm_dir], {}, :param => {'region' => region}) do |uploader|
+          @no_slots_msg = if seconds = uploader.seconds_until_retry
+                            m = Integer(seconds / 60)
+                            "VM #{vm_id}: No import capacity is currently available on Skytap. Will retry ".tap do |msg|
+                              if m < 1
+                                msg << 'soon.'
+                              else
+                                msg << "in #{m} minutes or when more capacity is detected."
+                              end
+                              msg
+                            end.color(:yellow)
+                          end
+          @status_line = uploader.status_lines
+        end
+
+        FileUtils.rm_r(vm_dir)
+
+        @result = Response.build(uploads)
+      end
+
+      def finished?
+        @finished.tap do
+          @finished = true if @result
+        end
+      end
+
+      def success?
+        result && !result.error?
+      end
+
+      def status_line
+        payload = result.try(:payload) and return payload
+
+        if @no_slots_msg
+          unless @skip_print
+            @skip_print = true
+            return @no_slots_msg
+          end
+        else
+          @skip_print = false
+        end
+
+        @status_line
+      end
+
+      def summary
+        status_line.tap do |msg|
+          if manual_network?
+            msg << " This template has an automatic network, but the template from which it was copied has a manual network. You may want to change the network settings of the new template by creating a configuration from it, editing the network, and finally creating another template from that configuration."
+          end
+        end
+      end
+
+      def manual_network?
+        @_manual_network ||= begin
+                              vm = Skytap.invoke!(username, api_token, "vm show #{vm_id}")
+                              (iface = vm['interfaces'].try(:first)) && iface['network_type'] == 'manual'
+                            end
+      end
+
+      def warn_if_manual_network
+        if manual_network?
+          msg = 'This VM is attached to a manual network, but the new template will instead contain an automatic network. You may want to change the network settings of the new template by creating a configuration from it, editing the network, and finally creating another template from that configuration.'
+          logger.info "VM #{vm_id}: #{msg.color(:yellow)}\n---"
+        end
+      end
+    end
+
+    Vm.subcommands << CopyToRegion
+  end
+end
+