skytap-yf 0.2.3

data/lib/skytap/api_schema.rb

@@ -0,0 +1,11 @@
+module Skytap
+  module ApiSchema
+    SCHEMA_FILE = File.join(File.dirname(__FILE__), '..', '..', 'api_schema.yaml')
+    def get
+      return @info unless @info.nil?
+
+      @info = YAML.load_file(SCHEMA_FILE)
+    end
+    module_function :get
+  end
+end

data/lib/skytap/command_line.rb

@@ -0,0 +1,145 @@
+require 'skytap/skytaprc'
+
+module Skytap
+  class CommandLine
+    ALLOWED_GLOBAL_OPTIONS = {
+      # Flags
+      :'base-url' => { :default => 'https://cloud.skytap.com' },
+      :'username' => { :desc => 'Skytap username' },
+      :'api-token' => { :desc => 'Skytap API token, found on "My Account" page', :hide_default_value => true },
+      :'http-format' => { :default => 'json', :in => ['json', 'xml'], :desc => 'HTTP request and response format' },
+      :'log-level' => { :default => 'info', :in => ['quiet', 'info', 'verbose'], :desc => 'Output verbosity' },
+      :'params-file' => { :desc => 'File whose contents to send as request params, read according to http-format' },
+      :'param' => { :desc => 'Request parameters in form --param=key1:value1 --param=key2:value2', :default => [], :multiple => true },
+
+      # Switches
+      :'help' => { :desc => 'Show help message for command', :switch => true },
+      :'version' => { :desc => 'Show CLI version', :switch => true },
+      :'colorize' => { :default => true, :desc => 'Colorize output?', :switch => true, :negatable => true },
+      :'verify-certs' => { :default => true, :desc => 'Verify HTTPS certificates?', :switch => true, :negatable => true },
+      :'ask' => { :default => true, :desc => 'Ask for params interactively?', :switch => true, :negatable => true }
+    }
+
+
+    def self.parse(argv=ARGV)
+      global = read_global_options
+      command_opts = {}
+      args = []
+      argv.each do |arg|
+        if arg =~ /^[^-]/
+          args << arg
+        # Switches
+        elsif arg =~ /^\-\-(no-)?([^=]+)$/
+          negated, name = $1, $2.to_sym
+          val = !negated
+          if global.has_key?(name)
+            global[name] = val
+          else
+            command_opts[name] = val
+          end
+        # Flags
+        elsif arg =~ /^\-\-(.+?)=(.+)$/
+          name, val = $1.to_sym, $2
+
+          if global.has_key?(name)
+            multiple = ALLOWED_GLOBAL_OPTIONS[name].try(:[], :multiple)
+            if multiple
+              if global[name].present?
+                global[name] << val
+              else
+                global[name] = [val]
+              end
+            else
+              global[name] = val
+            end
+          else
+            command_opts[name] = val
+          end
+        elsif arg =~ /^\-([A-Za-z0-9]+)$/
+          raise Skytap::Error.new 'Single-dash flags not supported. Use --flag form.'
+        else
+          raise "Unrecognized command-line arg: #{arg.inspect}"
+        end
+      end
+
+      # To simplify client handling, treat a first arg of "help" as --help.
+      if args.first == 'help'
+        args.shift
+        global[:help] = true
+      end
+
+      [args, global, command_opts]
+    end
+
+    def self.read_global_options
+      global_options.inject({}) do |acc, (k, option)|
+        acc[k] = option.val
+        acc
+      end
+    end
+
+    def self.global_options
+      return @global_options if @global_options
+
+      rc = SkytapRC.load
+      @global_options = ALLOWED_GLOBAL_OPTIONS.inject({}) do |acc, (k, opts)|
+        opts[:default] = rc[k] if rc.has_key?(k)
+        acc[k] = Option.new(k, opts)
+        acc
+      end
+    end
+  end
+
+  class Option
+    attr_reader :name, :desc, :default
+
+    def initialize(name, options = {})
+      @name = name.to_s
+      @options = options.symbolize_keys
+      @desc = @options[:desc]
+      @default = @options[:default]
+    end
+
+    def show_default?
+      !@options[:hide_default_value]
+    end
+
+    def switch?
+      @options[:switch]
+    end
+
+    def negatable?
+      switch? && @options[:negatable]
+    end
+
+    def val
+      if @set
+        @val
+      else
+        default
+      end
+    end
+
+    def val=(v)
+      @set = true
+      if switch?
+        @val = !!v
+      else
+        @val = v
+      end
+    end
+
+    def signature
+      if switch?
+        negation = '[no-]' if negatable?
+        "--#{negation}#{name}"
+      else
+        "--#{name}=#{name.upcase}"
+      end
+    end
+
+    def choices
+      @options[:in]
+    end
+  end
+end

data/lib/skytap/commands/base.rb

@@ -0,0 +1,294 @@
+require 'skytap/commands/help'
+
+module Skytap
+  module Commands
+    class Base
+      include Help
+
+      class_attribute :subcommands, :parent, :ask_interactively
+      self.subcommands = []
+
+      attr_accessor :error
+      attr_reader :args, :global_options, :command_options, :logger, :invoker
+
+      def initialize(logger, args, global_options, command_options, programmatic_context=false, &invoker)
+        @logger = logger
+        @args = args
+        @global_options = global_options
+        @command_options = command_options || {}
+        @programmatic_context = programmatic_context
+        @invoker = invoker
+      end
+
+      def programmatic?
+        !!@programmatic_context
+      end
+
+      class << self
+        # A factory that makes a command class from the given resource
+        def make_from(resource, spec={})
+          spec ||= {}
+          Class.new(Base).tap do |klass|
+            klass.instance_eval do
+              self.container = true
+              self.subcommands = [Index, Show, Create, Update, Destroy].reject do |sub|
+                spec['skip_actions'].try(:include?, sub.command_name)
+              end.collect do |sub|
+                sub_spec = spec['actions'].try(:[], sub.command_name)
+                sub.make_for(self, sub_spec)
+              end
+              self.spec = spec
+              alias_method :run!, :help!
+            end
+
+            Skytap::Commands.const_set(resource.classify, klass)
+          end
+        end
+
+        def command_name
+          name.split('::').last.underscore
+        end
+      end
+
+      def invoke
+        if matching_subcommand
+          matching_subcommand.new(logger, args[1..-1], global_options, command_options, @programmatic_context, &invoker).invoke
+        elsif help?
+          help!
+        elsif version?
+          logger.puts "skytap version #{Skytap::VERSION}"
+          exit
+        elsif container && args.present?
+          self.error = "Subcommand '#{args.first}' not found"
+          help!
+          exit(false)
+        else
+          validate_args
+          validate_command_options
+          run!
+        end
+      end
+
+      def expected_args
+        ActiveSupport::OrderedHash.new
+      end
+
+      # Expected command-specific options (not global options)
+      def expected_options
+        {}
+      end
+
+      # Returns an ID string from an URL, path or ID
+      def find_id(arg)
+        arg.to_s =~ /(.*\/)?(.+)$/ && $2
+      end
+
+      def solicit_user_input?
+        global_options[:ask] && !programmatic? && $stdin.tty?
+      end
+
+
+      def ask_param
+        name = ask('Name: '.bright)
+        value = ask('Value: '.bright)
+        [name, value]
+      end
+
+      def ask(question, choices={})
+        return unless solicit_user_input?
+        default = choices.delete(:default)
+        raise "Default choice must be in the choices hash" if default && !choices.has_key?(default)
+        if choices.present?
+          letters = " [#{choices.collect{|l, _| l == default ? l.upcase : l.downcase}.join}]"
+        end
+
+        loop do
+          line = "#{question}#{letters} ".color(:yellow)
+          $stdout.print line
+          $stdout.flush
+
+          answer = $stdin.gets.try(&:strip)
+          if choices.blank?
+            break answer
+          elsif answer.blank? && default
+            break choices[default]
+          elsif choices.has_key?(answer.downcase)
+            break choices[answer.downcase]
+          end
+        end
+      end
+
+      def composed_params
+        noninteractive_params.merge(interactive_params)
+      end
+
+      def file_params
+        file = global_options[:'params-file'] or return {}
+        file = File.expand_path(file)
+        raise 'Params file not found' unless File.exist?(file)
+        case File.basename(file)
+        when /\.json$/i
+          format = 'json'
+        when /\.xml$/i
+          format = 'xml'
+        else
+          format = global_options[:'http-format']
+        end
+
+        body = File.open(file, &:read)
+        deserialized = case format
+                       when 'json'
+                         JSON.load(body)
+                       when 'xml'
+                         parsed = Hash.from_xml(body)
+                         # Strip out the root name.
+                         if parsed.is_a?(Hash)
+                           parsed.values.first
+                         else
+                           parsed
+                         end
+                       else
+                         raise Skytap::Error.new("Unknown format: #{format.inspect}")
+                       end
+      end
+
+      def command_line_params
+        param = global_options[:param]
+        return {} if param.blank?
+        case param
+        when Hash
+          param
+        when String
+          #TODO:NLA This will blow up if param has a weird form.
+          Hash[*param.split(':', 2)]
+        when Array
+          split = param.collect {|v| v.split(':', 2)}.flatten
+          Hash[*split]
+        else
+          param
+        end
+      end
+
+      def noninteractive_params
+        @noninteractive_params ||= file_params.merge(command_line_params)
+      end
+
+      def interactive_params
+        if !solicit_user_input? ||
+          !ask_interactively ||
+          parameters.blank? ||
+          (required_parameters.empty? && noninteractive_params.present?) ||
+          (required_parameters.present? && (required_parameters - noninteractive_params.keys).empty?)
+
+          return {}
+        end
+
+        param_info = Templates::Help.new('command' => self).parameters_table
+        logger.info param_info << "\n"
+
+        params = {}
+        loop do
+          answer = ask('include a param?', ActiveSupport::OrderedHash['y', 'y', 'n', 'n', 'q', 'q', '?', '?', :default, 'n'])
+          case answer.downcase
+          when 'y'
+            k, v = ask_param
+            params[k] = v
+          when 'n'
+            break
+          when 'q'
+            logger.info 'Bye.'
+            exit
+          else
+            logger.puts <<-"EOF"
+y - include an HTTP request parameter
+n - stop adding parameters (default answer)
+q - quit
+? - show this message
+
+            EOF
+          end
+        end
+
+        params
+      end
+
+      def username
+        return @_username if @_username
+        username = global_options[:username]
+        if username.blank?
+          if solicit_user_input?
+            username = ask('Skytap username:') while username.blank?
+          else
+            raise Skytap::Error.new('Must provide --username')
+          end
+        end
+        @_username = username
+      end
+
+      def api_token
+        return @_api_token if @_api_token
+        api_token = global_options[:'api-token']
+        if api_token.blank?
+          if solicit_user_input?
+            api_token = ask('API token:') while api_token.blank?
+          else
+            raise Skytap::Error.new('Must provide --api-token')
+          end
+        end
+        @_api_token = api_token
+      end
+
+      private
+
+
+      def run!
+        raise NotImplementedError.new('Must override #run!')
+      end
+
+      def required_parameters
+        @required_parameters ||= parameters.collect{|p| p.keys.first if p.values.first['required']}.compact
+      end
+
+      #TODO:NLA Need to track somewhere that only the last expected arg may end with *
+      def validate_args
+        unlimited = expected_args.keys.last.try(:end_with?, '*')
+        if unlimited
+          min = expected_args.keys.length
+          if args.length < expected_args.keys.length
+            self.error = "Expected at least #{min} command line #{'argument'.pluralize(min)} but got #{args.length}."
+            help!
+            exit(false)
+          end
+        else
+          expected = expected_args.keys.length
+          unless args.length == expected
+            self.error = "Expected #{expected} command line #{'argument'.pluralize(expected)} but got #{args.length}."
+            help!
+            exit(false)
+          end
+        end
+      end
+
+      def validate_command_options
+        bad = command_options.inject([]) do |acc, (name, value)|
+          if !expected_options[name]
+            acc << "Unknown option '#{name}'."
+          elsif !expected_options[name][:flag_arg] && (value != true && value != false)
+            acc << "'#{name}' option is a switch and cannot be set to a value."
+          end
+          acc
+        end
+        if bad.present?
+          self.error = bad.join(' ')
+          help!
+          exit(false)
+        end
+      end
+
+      def matching_subcommand
+        next_command = args.first
+        subcommands.detect {|k| k.command_name == next_command}
+      end
+    end
+  end
+end

data/lib/skytap/commands/help.rb

@@ -0,0 +1,82 @@
+require 'skytap/templates'
+
+module Skytap
+  module Commands
+    module Help
+
+      module ClassMethods
+        def banner_prefix
+          parent_prefix = parent.try(:banner_prefix)
+          "#{parent_prefix.try(:+, ' ')}#{self.command_name}"
+        end
+
+        def banner
+          b = "#{banner_prefix} - #{short_desc}"
+          if plugin
+            b.color(:cyan)
+          else
+            b
+          end
+        end
+
+        def description
+          spec['description'] || default_description
+        end
+
+        def default_description
+          nil
+        end
+
+        def short_desc
+          description.split("\n\n").first.split("\n").join(' ') if description
+        end
+
+        def subcommand_banners
+          subcommands.inject([]) do |acc, klass|
+            acc << klass.banner unless klass.container
+            acc.concat(klass.subcommand_banners)
+            acc
+          end
+        end
+      end
+
+      def synopsis
+        if self.container
+          command_name = self.class.command_name
+          "skytap #{command_name + ' ' if command_name}<subcommand> <options>"
+        else
+          "#{self.class.banner_prefix} #{expected_args.keys.collect(&:upcase).join(' ') << ' '}<options> - #{self.class.short_desc}"
+        end
+      end
+
+      def help?
+        !!global_options[:help]
+      end
+
+      def help!
+        puts Skytap::Templates::Help.render(self)
+      end
+
+      def version?
+        !!global_options[:version]
+      end
+
+      def parameters
+        spec['params']
+      end
+
+      def description
+        self.class.description
+      end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+        # Indicates whether this class is only a container for subcommands.
+        base.class_attribute :container, :spec, :plugin
+        base.container = false
+        base.plugin = false
+        base.spec = {}
+      end
+    end
+  end
+end