collins_shell 0.2.14

data/lib/collins_shell/provision.rb

@@ -0,0 +1,152 @@
+require 'collins_shell/thor'
+require 'collins_shell/util'
+require 'thor'
+require 'thor/group'
+require 'terminal-table'
+
+module CollinsShell
+
+  class Provision < Thor
+    include ThorHelper
+    include CollinsShell::Util
+
+    desc 'list', 'list available provisioning profiles'
+    use_collins_options
+    def list
+      table = Terminal::Table.new
+      table.title = set_color("Provisioning Profiles", :bold, :magenta)
+      table << [
+        "Profile", "Label", "Prefix", "Pool", split("Primary Role"), split("Secondary Role"),
+        split("Suffix Allowed?"), split("Requires Primary Role?"),
+        split("Requires Secondary Role?"), split("Requires Pool?")
+      ]
+      table << :separator
+      data = call_collins get_collins_client, '/api/provision/profiles' do |client|
+        profs = client.provisioning_profiles
+        last = profs.size - 1
+        profs.each_with_index do |profile, idx|
+          table << [
+            profile.profile, split(profile.label), profile.prefix, optional_string(profile.pool),
+            optional_string(profile.primary_role), optional_string(profile.secondary_role),
+            centered(profile.suffix_allowed?), centered(profile.requires_primary_role?),
+            centered(profile.requires_secondary_role?), centered(profile.requires_pool?)
+          ]
+          if idx != last && too_wide? then
+            table << :separator
+          end
+        end
+      end
+      puts table
+    end
+
+    desc 'host TAG PROFILE CONTACT', 'provision host with asset tag TAG as PROFILE, and then contact CONTACT'
+    long_desc <<-D
+      Provision the host specified by the TAG argument as a PROFILE.
+
+      PROFILE must be one of the profiles found by doing a `collins-shell provision list`
+
+      CONTACT should be your hipchat username, or the username part of your email address.
+
+      This task may take up to 90 seconds to return.
+    D
+    use_collins_options
+    method_option :activate, :type => :boolean, :desc => 'Activate a server', :hide => true
+    method_option :confirm, :type => :boolean, :default => :true, :desc => 'Require confirmation. Defaults to true'
+    method_option :exec, :type => :string, :desc => 'Execute a command using the data from this asset. Use {{hostname}}, {{ipmi.password}}, etc for substitution'
+    method_option :pool, :type => :string, :desc => 'Pool for host'
+    method_option :primary_role, :type => :string, :desc => 'Primary role for host'
+    method_option :secondary_role, :type => :string, :desc => 'Secondary role for host'
+    method_option :suffix, :type => :string, :desc => 'Suffix to use for hostname'
+    method_option :verify, :type => :boolean, :default => :true, :desc => 'Verify arguments locally first'
+    def host tag, profile, contact
+      verify_profile(profile) if options.verify
+      config = get_collins_config
+      if config[:timeout] < 180 then
+        cclient = get_collins_client :timeout => 180
+      else
+        cclient = get_collins_client
+      end
+      asset = asset_get tag, options
+      if options.confirm then
+        printer = CollinsShell::AssetPrinter.new asset, self, :detailed => false
+        puts printer
+        require_yes "You are about to provision asset #{tag} as a #{profile}. ARE YOU SURE?", :red
+      end
+      progress_printer = Thread.new {
+        loop {
+          print "."
+          sleep(1)
+        }
+      }
+      status = call_collins cclient, "provision host" do |client|
+        say_status("starting", "Provisioning has started", :white)
+        client.provision tag, profile, contact, :activate => options.activate,
+                                                :pool => options.pool,
+                                                :primary_role => options.primary_role,
+                                                :secondary_role => options.secondary_role,
+                                                :suffix => options.suffix
+      end
+      progress_printer.terminate
+      puts()
+      if status then
+        say_success("Successfully provisioned asset")
+        asset = asset_get tag, options
+        printer = CollinsShell::AssetPrinter.new asset, self, :detailed => false
+        puts printer
+        asset_exec asset, options.exec, options.confirm
+      else
+        say_error("Failed to provision asset")
+      end
+    end
+
+    no_tasks do
+      def too_wide?
+        terminal_width < 150
+      end
+
+      def split value
+        if too_wide? then
+          value.split(' ').join("\n")
+        else
+          value
+        end
+      end
+
+      def verify_value pname, name, user_specified, profile_exists, profile_requires, profile_provides
+        if user_specified then
+          require_that(!profile_exists, "#{name} is not user configurable for '#{pname}'")
+        else
+          require_that(!profile_requires || profile_provides, "#{name} is required for '#{pname}'")
+        end
+      end
+
+      def verify_profile pname
+        profiles = call_collins get_collins_client, '/api/provision/profiles' do |client|
+          client.provisioning_profiles
+        end
+        profile = profiles.select{|p| p.profile.downcase == pname.to_s.downcase}.first
+        require_non_empty(profile, "No such profile '#{pname}', try collins-shell provision list")
+        if options.suffix? then
+          require_that(profile.suffix_allowed?, "Suffix not allowed for '#{pname}'")
+        end
+        verify_value pname, "Pool", options.pool?, profile.pool?, profile.requires_pool?, profile.pool
+        verify_value pname, "Secondary role", options.secondary_role?, profile.secondary_role?, profile.requires_secondary_role?, profile.secondary_role
+        verify_value pname, "Primary role", options.primary_role?, profile.primary_role?, profile.requires_primary_role?, profile.primary_role
+      end
+
+      def centered value
+        {:alignment => :center, :value => value}
+      end
+
+      def optional_string value, default = 'Configurable'
+        if value.nil? || value.empty? then
+          default
+        else
+          value
+        end
+      end # optional_string
+    end
+
+  end
+
+end

data/lib/collins_shell/state.rb

@@ -0,0 +1,98 @@
+require 'collins_shell/thor'
+require 'collins_shell/util'
+require 'thor'
+require 'thor/group'
+
+module CollinsShell
+
+  class State < Thor
+    include ThorHelper
+    include CollinsShell::Util
+    namespace :state
+
+    def self.banner task, namespace = true, subcommand = false
+      "#{basename} #{task.formatted_usage(self, true, subcommand).gsub(':',' ')}"
+    end
+
+    desc 'create', 'Create a new state'
+    use_collins_options
+    method_option :name, :type => :string, :required => true, :desc => 'Name of state. Must be all caps and unique. Can contain numbers, letters and underscores.'
+    method_option :label, :type => :string, :required => true, :desc => 'A friendly (short) description of the state to use in visual labels. Usually just a camel case version of the name, possibly with spaces.'
+    method_option :description, :type => :string, :required => true, :desc => 'A longer description of the state'
+    method_option :status, :type => :string, :required => false, :desc => 'Optional status to bind the state to'
+    def create
+      name = options.name.upcase
+      label = options.label
+      desc = options.description
+      status = options.status
+      call_collins get_collins_client, "state_create!" do |client|
+        if client.state_create!(name, label, desc, status) then
+          say_success "Successfully created state '#{name}'"
+        else
+          say_error "Failed creating state '#{name}'"
+        end
+      end
+    end
+
+    desc 'delete STATE', 'Delete a state'
+    use_collins_options
+    def delete state
+      call_collins get_collins_client, "state_delete!" do |client|
+        if client.state_delete!(state) then
+          say_success "Successfully deleted state '#{state}'"
+        else
+          say_error "Failed deleting state '#{state}'"
+        end
+      end
+    end
+
+    desc 'get STATE', 'Get a state by name'
+    use_collins_options
+    def get state
+      call_collins get_collins_client, "state_get" do |client|
+        header = [["Name", "Label", "Status", "Description"]]
+        state = client.state_get(state)
+        table = header + [[state.name, state.label, (state.status.name || ""), state.description]]
+        print_table table
+      end
+    end
+
+    desc 'list', 'list states that are available'
+    use_collins_options
+    def list
+      call_collins get_collins_client, "state_get_all" do |client|
+        header = [["Name", "Label", "Status", "Description"]]
+        states = header + client.state_get_all.map do |state|
+          [state.name, state.label, (state.status.name || ""), state.description]
+        end
+        print_table states
+      end
+    end
+
+    desc 'update STATE', 'Update the name, label, description or status binding of a state'
+    use_collins_options
+    method_option :name, :type => :string, :required => false, :desc => 'New name of state. Must be all caps and unique. Can contains numbers, letters, and underscores.'
+    method_option :label, :type => :string, :required => false, :desc => 'A friendly (short) description of the state to use in visual labels. Usually just a camel case version of the name, possibly with spaces.'
+    method_option :description, :type => :string, :required => false, :desc => 'A longer description of the state'
+    method_option :status, :type => :string, :required => false, :desc => 'Optional status to bind the state to'
+    def update state
+      name = options.name.upcase if options.name?
+      label = options.label if options.label?
+      desc = options.description if options.description?
+      status = options.status if options.status?
+      call_collins get_collins_client, "state_update!" do |client|
+        opts = {
+          :name => name, :label => label, :status => status,
+          :description => desc
+        }
+        if client.state_update!(state, opts) then
+          say_success "Successfully updated state '#{state}'"
+        else
+          say_error "Failed creating state '#{state}'"
+        end
+      end
+    end
+
+  end
+
+end

data/lib/collins_shell/tag.rb

@@ -0,0 +1,41 @@
+require 'collins_shell/thor'
+require 'collins_shell/util'
+require 'thor'
+require 'thor/group'
+
+module CollinsShell
+
+  class Tag < Thor
+
+    include ThorHelper
+    include CollinsShell::Util
+    namespace :tag
+
+    def self.banner task, namespace = true, subcommand = false
+      "#{basename} #{task.formatted_usage(self, true, subcommand).gsub(':',' ')}"
+    end
+
+    desc 'list', 'list tags that are in use'
+    use_collins_options
+    def list
+      call_collins get_collins_client, "list" do |client|
+        header = [["Name", "Label", "Description"]]
+        tags = header + client.get_all_tags.map do |tag|
+          [tag.name, tag.label, tag.description]
+        end
+        print_table tags
+      end
+    end
+
+    desc 'values TAG', 'list all values for the specified tag'
+    use_collins_options
+    def values tag
+      call_collins get_collins_client, "values" do |client|
+        client.get_tag_values(tag).sort.each do |value|
+          puts(value)
+        end
+      end
+    end
+  end
+
+end

data/lib/collins_shell/thor.rb

@@ -0,0 +1,209 @@
+require 'collins_client'
+require 'highline'
+require 'yaml'
+
+module CollinsShell
+  module ThorHelper
+
+    include Collins::Util
+
+    COLLINS_OPTIONS = {
+      :config => {:type => :string, :desc => 'YAML configuration file'},
+      :debug => {:type => :boolean, :default => false, :desc => 'Debug output'},
+      :host => {:type => :string, :desc => 'Collins host (e.g. http://host:port)'},
+      :password => {:type => :string, :desc => 'Collins password'},
+      :quiet => {:type => :boolean, :default => false, :desc => 'Be quiet when appropriate'},
+      :timeout => {:type => :numeric, :default => 30, :desc => 'Collins client timeout'},
+      :username => {:type => :string, :desc => 'Collins username'}
+    }
+
+    PAGE_OPTIONS = {
+      :page => {:type => :numeric, :default => 0, :desc => 'Page of results set.'},
+      :size => {:type => :numeric, :default => 20, :desc => 'Number of results to return.'},
+      :sort => {:type => :string, :default => 'DESC', :desc => 'Sort direction. ASC or DESC'}
+    }
+
+    def self.included(base)
+      base.extend(ThorHelper)
+    end
+    
+    class << self
+      attr_accessor :password
+    end
+
+    def use_collins_options
+      COLLINS_OPTIONS.each do |name, options|
+        method_option name, options
+      end
+    end
+    def use_page_options default_size = 20
+      PAGE_OPTIONS.each do |name, options|
+        options.update(:default => default_size) if name == :size
+        method_option name, options
+      end
+    end
+    def use_tag_option required = false
+      method_option :tag, :type => :string, :required => required, :desc => 'Tag for asset'
+    end
+    def use_selector_option required = false
+      method_option :selector, :type => :hash, :required => required, :desc => 'Selector to query collins. Takes the form of --selector=key1:val1 key2:val2 etc'
+      method_option :remote, :type => :boolean, :default => false, :desc => 'Search all collins instances, including remote ones'
+    end
+
+    def selector_or_tag
+      if options.selector? then
+        options.selector
+      elsif options.tag? then
+        {:tag => options.tag}
+      else
+        say_error "Either tag or selector must be specified", :exit => true
+      end
+    end
+
+    def require_yes message, color = nil, should_exit = true
+      highline = HighLine.new
+      colored_message = set_color(message, color)
+      answer = ask(colored_message)
+      if answer.downcase.strip !~ /^yes$/ then
+        if should_exit then
+          exit(0)
+        else
+          false
+        end
+      else
+        true
+      end
+    end
+
+    def batch_selector_operation options = {}, &block
+      confirmation_message = options[:confirmation_message]
+      success_message = options[:success_message]
+      error_message = options[:error_message]
+      operation = options[:operation]
+      require_non_empty(confirmation_message, "confirmation_message option not set")
+      require_non_empty(success_message, "success_message not set")
+      require_non_empty(error_message, "error_message not set")
+      require_non_empty(operation, "operation not set")
+      selector = get_selector selector_or_tag, [], nil, options[:remote]
+      call_collins get_collins_client, operation do |client|
+        assets = client.find selector
+        if assets.length > 1 then
+          require_yes confirmation_message.call(assets), :red
+        end
+        assets.each do |asset|
+          if block.call(client, asset) then
+            say_success success_message.call(asset)
+          else
+            say_error error_message.call(asset)
+          end
+        end
+      end
+    end
+
+    def say_error message, options = {}
+      if options[:exception] then
+        say_status("error", "#{message} - #{options[:exception]}", :red)
+        if options[:debug] && options[:debug] then
+          pp options[:exception].backtrace
+        end
+      else
+        say_status("error", message, :red)
+      end
+      if options[:exit].is_a?(TrueClass) then
+        exit(1)
+      elsif not options[:exit].nil? then
+        exit(options[:exit])
+      end
+    end
+
+    def say_success message
+      say_status("success", message, :green)
+    end
+
+    def get_collins_client opts = {}
+      config = get_collins_config.merge(opts).merge(:strict => true)
+      config = ensure_password opts
+      require_valid_collins_config config
+      config[:logger] = get_logger :trace => options.debug, :progname => 'collins-shell'
+      Collins::Client.new config
+    end
+
+    def ensure_password opts = {}
+      me = CollinsShell::ThorHelper
+      if me.password.nil? then
+        me.password = get_password(get_collins_config.merge(opts).merge(:strict => true))
+      end
+      me.password
+    end
+
+    def get_password config
+      if 
+        config[:password] and not
+        config[:password].empty? and
+        config[:password] != "password" then
+        return config
+      end
+      highline = HighLine.new
+      password = highline.ask("Enter your password:  ") { |q| q.echo = "x" }
+      config.update(:password => password)
+    end
+
+    # --username --password --host is highest priority
+    # --config= second highest
+    # ~/.collins.yaml is lowest
+    def get_collins_config
+      def try_config_merge filename, config
+        file_config = collins_config_from_file filename
+        if file_config[:collins] then
+          file_config = file_config[:collins]
+        end
+        config.update(:host => file_config[:host]) unless options.host?
+        config.update(:username => file_config[:username]) unless options.username?
+        config.update(:password => file_config[:password]) unless options.password?
+        if options.timeout == 30 and file_config[:timeout] then
+          config.update(:timeout => file_config[:timeout].to_i)
+        end
+      end
+      config = Hash[
+        :host => options.host,
+        :username => options.username,
+        :password => options.password,
+        :timeout => options.timeout
+      ]
+      if ENV['COLLINS'] then
+        try_config_merge ENV['COLLINS'], config
+      end
+      if options.config? then
+        try_config_merge options.config, config
+      end
+      if File.exists?(File.expand_path("~/.collins.yaml")) then
+        user_config = collins_config_from_file "~/.collins.yaml"
+        if user_config[:collins] then
+          user_config = user_config[:collins]
+        end
+        config.update(:host => user_config[:host]) if config[:host].nil?
+        config.update(:username => user_config[:username]) if config[:username].nil?
+        config.update(:password => user_config[:password]) if config[:password].nil?
+        if config[:timeout] == 30 and user_config[:timeout] then
+          config.update(:timeout => user_config[:timeout].to_i)
+        end
+      end
+      config
+    end
+
+    def collins_config_from_file file
+      symbolize_hash(YAML::load(File.open(File.expand_path(file))))
+    end
+
+    def require_valid_collins_config config
+      begin
+        require_non_empty(config[:host], "collins.host is required")
+        require_non_empty(config[:username], "collins.username is required")
+        require_non_empty(config[:password], "collins.password is required")
+      rescue Exception => e
+        raise CollinsShell::ConfigurationError.new(e.message)
+      end
+    end
+
+  end
+end