leap_cli 1.7.4 → 1.8

data/lib/leap_cli/commands/env.rb

@@ -1,76 +0,0 @@
-module LeapCli
-  module Commands
-
-    desc "Manipulate and query environment information."
-    long_desc "The 'environment' node property can be used to isolate sets of nodes into entirely separate environments. "+
-      "A node in one environment will never interact with a node from another environment. "+
-      "Environment pinning works by modifying your ~/.leaprc file and is dependent on the "+
-      "absolute file path of your provider directory (pins don't apply if you move the directory)"
-    command [:env, :e] do |c|
-      c.desc "List the available environments. The pinned environment, if any, will be marked with '*'. Will also set the pin if run with an environment argument."
-      c.arg_name 'ENVIRONMENT', :optional => true
-      c.command :ls do |ls|
-        ls.action do |global_options, options, args|
-          environment = get_env_from_args(args)
-          if environment
-            pin(environment)
-            LeapCli.leapfile.load
-          end
-          print_envs
-        end
-      end
-
-      c.desc 'Pin the environment to ENVIRONMENT. All subsequent commands will only apply to nodes in this environment.'
-      c.arg_name 'ENVIRONMENT'
-      c.command :pin do |pin|
-        pin.action do |global_options,options,args|
-          environment = get_env_from_args(args)
-          if environment
-            pin(environment)
-          else
-            bail! "There is no environment `#{environment}`"
-          end
-        end
-      end
-
-      c.desc "Unpin the environment. All subsequent commands will apply to all nodes."
-      c.command :unpin do |unpin|
-        unpin.action do |global_options, options, args|
-          LeapCli.leapfile.unset('environment')
-          log 0, :saved, "~/.leaprc, removing environment property."
-        end
-      end
-
-      c.default_command :ls
-    end
-
-    protected
-
-    def get_env_from_args(args)
-      environment = args.first
-      if environment == 'default' || (environment && manager.environment_names.include?(environment))
-        return environment
-      else
-        return nil
-      end
-    end
-
-    def pin(environment)
-      LeapCli.leapfile.set('environment', environment)
-      log 0, :saved, "~/.leaprc with environment set to #{environment}."
-    end
-
-    def print_envs
-      envs = ["default"] + manager.environment_names.compact.sort
-      envs.each do |env|
-        if env
-          if LeapCli.leapfile.environment == env
-            puts "* #{env}"
-          else
-            puts "  #{env}"
-          end
-        end
-      end
-    end
-  end
-end

data/lib/leap_cli/commands/facts.rb

@@ -1,100 +0,0 @@
-#
-# Gather facter facts
-#
-
-module LeapCli; module Commands
-
-  desc 'Gather information on nodes.'
-  command :facts do |facts|
-    facts.desc 'Query servers to update facts.json.'
-    facts.long_desc "Queries every node included in FILTER and saves the important information to facts.json"
-    facts.arg_name 'FILTER'
-    facts.command :update do |update|
-      update.action do |global_options,options,args|
-        update_facts(global_options, options, args)
-      end
-    end
-  end
-
-  protected
-
-  def facter_cmd
-    'facter --json ' + Leap::Platform.facts.join(' ')
-  end
-
-  def remove_node_facts(name)
-    if file_exists?(:facts)
-      update_facts_file({name => nil})
-    end
-  end
-
-  def update_node_facts(name, facts)
-    update_facts_file({name => facts})
-  end
-
-  def rename_node_facts(old_name, new_name)
-    if file_exists?(:facts)
-      facts = JSON.parse(read_file(:facts) || {})
-      facts[new_name] = facts[old_name]
-      facts[old_name] = nil
-      update_facts_file(facts, true)
-    end
-  end
-
-  #
-  # if overwrite = true, then ignore existing facts.json.
-  #
-  def update_facts_file(new_facts, overwrite=false)
-    replace_file!(:facts) do |content|
-      if overwrite || content.nil? || content.empty?
-        old_facts = {}
-      else
-        old_facts = manager.facts
-      end
-      facts = old_facts.merge(new_facts)
-      facts.each do |name, value|
-        if value.is_a? String
-          if value == ""
-            value = nil
-          else
-            value = JSON.parse(value) rescue JSON::ParserError
-          end
-        end
-        if value.is_a? Hash
-          value.delete_if {|key,v| v.nil?}
-        end
-        facts[name] = value
-      end
-      facts.delete_if do |name, value|
-        value.nil? || value.empty?
-      end
-      if facts.empty?
-        "{}\n"
-      else
-        JSON.sorted_generate(facts) + "\n"
-      end
-    end
-  end
-
-  private
-
-  def update_facts(global_options, options, args)
-    nodes = manager.filter(args, :local => false, :disabled => false)
-    new_facts = {}
-    ssh_connect(nodes) do |ssh|
-      ssh.leap.run_with_progress(facter_cmd) do |response|
-        node = manager.node(response[:host])
-        if node
-          new_facts[node.name] = response[:data].strip
-        else
-          log :warning, 'Could not find node for hostname %s' % response[:host]
-        end
-      end
-    end
-    # only overwrite the entire facts file if and only if we are gathering facts
-    # for all nodes in all environments.
-    overwrite_existing = args.empty? && LeapCli.leapfile.environment.nil?
-    update_facts_file(new_facts, overwrite_existing)
-  end
-
-end; end

data/lib/leap_cli/commands/inspect.rb

@@ -1,144 +0,0 @@
-module LeapCli; module Commands
-
-  desc 'Prints details about a file. Alternately, the argument FILE can be the name of a node, service or tag.'
-  arg_name 'FILE'
-  command [:inspect, :i] do |c|
-    c.switch 'base', :desc => 'Inspect the FILE from the provider_base (i.e. without local inheritance).', :negatable => false
-    c.action do |global_options,options,args|
-      object = args.first
-      assert! object, 'A file path or node/service/tag name is required'
-      method = inspection_method(object)
-      if method && defined?(method)
-        self.send(method, object, options)
-      else
-        log "Sorry, I don't know how to inspect that."
-      end
-    end
-  end
-
-  private
-
-  FTYPE_MAP = {
-    "PEM certificate"         => :inspect_x509_cert,
-    "PEM RSA private key"     => :inspect_x509_key,
-    "OpenSSH RSA public key"  => :inspect_ssh_pub_key,
-    "PEM certificate request" => :inspect_x509_csr
-  }
-
-  def inspection_method(object)
-    if File.exists?(object)
-      ftype = `file #{object}`.split(':').last.strip
-      log 2, "file is of type '#{ftype}'"
-      if FTYPE_MAP[ftype]
-        FTYPE_MAP[ftype]
-      elsif File.extname(object) == ".json"
-        full_path = File.expand_path(object, Dir.pwd)
-        if path_match?(:node_config, full_path)
-          :inspect_node
-        elsif path_match?(:service_config, full_path)
-          :inspect_service
-        elsif path_match?(:tag_config, full_path)
-          :inspect_tag
-        elsif path_match?(:provider_config, full_path) || path_match?(:provider_env_config, full_path)
-          :inspect_provider
-        elsif path_match?(:common_config, full_path)
-          :inspect_common
-        else
-          nil
-        end
-      end
-    elsif manager.nodes[object]
-      :inspect_node
-    elsif manager.services[object]
-      :inspect_service
-    elsif manager.tags[object]
-      :inspect_tag
-    elsif object == "common"
-      :inspect_common
-    elsif object == "provider"
-      :inspect_provider
-    else
-      nil
-    end
-  end
-
-  #
-  # inspectors
-  #
-
-  def inspect_x509_key(file_path, options)
-    assert_bin! 'openssl'
-    puts assert_run! 'openssl rsa -in %s -text -check' % file_path
-  end
-
-  def inspect_x509_cert(file_path, options)
-    assert_bin! 'openssl'
-    puts assert_run! 'openssl x509 -in %s -text -noout' % file_path
-    log 0, :"SHA256 fingerprint", X509.fingerprint("SHA256", file_path)
-  end
-
-  def inspect_x509_csr(file_path, options)
-    assert_bin! 'openssl'
-    puts assert_run! 'openssl req -text -noout -verify -in %s' % file_path
-  end
-
-  #def inspect_ssh_pub_key(file_path)
-  #end
-
-  def inspect_node(arg, options)
-    inspect_json manager.nodes[name(arg)]
-  end
-
-  def inspect_service(arg, options)
-    if options[:base]
-      inspect_json manager.base_services[name(arg)]
-    else
-      inspect_json manager.services[name(arg)]
-    end
-  end
-
-  def inspect_tag(arg, options)
-    if options[:base]
-      inspect_json manager.base_tags[name(arg)]
-    else
-      inspect_json manager.tags[name(arg)]
-    end
-  end
-
-  def inspect_provider(arg, options)
-    if options[:base]
-      inspect_json manager.base_provider
-    elsif arg =~ /provider\.(.*)\.json/
-      inspect_json manager.env($1).provider
-    else
-      inspect_json manager.provider
-    end
-  end
-
-  def inspect_common(arg, options)
-    if options[:base]
-      inspect_json manager.base_common
-    else
-      inspect_json manager.common
-    end
-  end
-
-  #
-  # helpers
-  #
-
-  def name(arg)
-    File.basename(arg).sub(/\.json$/, '')
-  end
-
-  def inspect_json(config)
-    if config
-      puts JSON.sorted_generate(config)
-    end
-  end
-
-  def path_match?(path_symbol, path)
-    Dir.glob(Path.named_path([path_symbol, '*'])).include?(path)
-  end
-
-end; end

data/lib/leap_cli/commands/list.rb

@@ -1,132 +0,0 @@
-require 'command_line_reporter'
-
-module LeapCli; module Commands
-
-  desc 'List nodes and their classifications'
-  long_desc 'Prints out a listing of nodes, services, or tags. ' +
-            'If present, the FILTER can be a list of names of nodes, services, or tags. ' +
-            'If the name is prefixed with +, this acts like an AND condition. ' +
-            "For example:\n\n" +
-            "`leap list node1 node2` matches all nodes named \"node1\" OR \"node2\"\n\n" +
-            "`leap list openvpn +local` matches all nodes with service \"openvpn\" AND tag \"local\""
-
-  arg_name 'FILTER', :optional => true
-  command [:list,:ls] do |c|
-    c.flag 'print', :desc => 'What attributes to print (optional)'
-    c.switch 'disabled', :desc => 'Include disabled nodes in the list.', :negatable => false
-    c.action do |global_options,options,args|
-      # don't rely on default manager(), because we want to pass custom options to load()
-      manager = LeapCli::Config::Manager.new
-      if global_options[:color]
-        colors = ['cyan', 'white']
-      else
-        colors = [nil, nil]
-      end
-      puts
-      manager.load(:include_disabled => options['disabled'], :continue_on_error => true)
-      if options['print']
-        print_node_properties(manager.filter(args), options['print'])
-      else
-        if args.any?
-          NodeTable.new(manager.filter(args), colors).run
-        else
-          environment = LeapCli.leapfile.environment || '_all_'
-          TagTable.new('SERVICES', manager.env(environment).services, colors).run
-          TagTable.new('TAGS', manager.env(environment).tags, colors).run
-          NodeTable.new(manager.filter(), colors).run
-        end
-      end
-    end
-  end
-
-  private
-
-  def self.print_node_properties(nodes, properties)
-    properties = properties.split(',')
-    max_width = nodes.keys.inject(0) {|max,i| [i.size,max].max}
-    nodes.each_node do |node|
-      value = properties.collect{|prop|
-        prop_value = node[prop]
-        if prop_value.nil?
-          "null"
-        elsif prop_value == ""
-          "empty"
-        elsif prop_value.is_a? LeapCli::Config::Object
-          node[prop].dump_json(:compact) # TODO: add option of getting pre-evaluation values.
-        else
-          prop_value.to_s
-        end
-      }.join(', ')
-      printf("%#{max_width}s  %s\n", node.name, value)
-    end
-    puts
-  end
-
-  class TagTable
-    include CommandLineReporter
-    def initialize(heading, tag_list, colors)
-      @heading = heading
-      @tag_list = tag_list
-      @colors = colors
-    end
-    def run
-      tags = @tag_list.keys.select{|tag| tag !~ /^_/}.sort # sorted list of tags, excluding _partials
-      max_width = [20, (tags+[@heading]).inject(0) {|max,i| [i.size,max].max}].max
-      table :border => false do
-        row :color => @colors[0]  do
-          column @heading, :align => 'right', :width => max_width
-          column "NODES", :width => HighLine::SystemExtensions.terminal_size.first - max_width - 2, :padding => 2
-        end
-        tags.each do |tag|
-          next if @tag_list[tag].node_list.empty?
-          row :color => @colors[1] do
-            column tag
-            column @tag_list[tag].node_list.keys.sort.join(', ')
-          end
-        end
-      end
-      vertical_spacing
-    end
-  end
-
-  #
-  # might be handy: HighLine::SystemExtensions.terminal_size.first
-  #
-  class NodeTable
-    include CommandLineReporter
-    def initialize(node_list, colors)
-      @node_list = node_list
-      @colors = colors
-    end
-    def run
-      rows = @node_list.keys.sort.collect do |node_name|
-        [node_name, @node_list[node_name].services.sort.join(', '), @node_list[node_name].tags.sort.join(', ')]
-      end
-      unless rows.any?
-        puts Paint["no results", :red]
-        puts
-        return
-      end
-      padding = 2
-      max_node_width    = [20, (rows.map{|i|i[0]} + ["NODES"]   ).inject(0) {|max,i| [i.size,max].max}].max
-      max_service_width = (rows.map{|i|i[1]} + ["SERVICES"]).inject(0) {|max,i| [i.size+padding+padding,max].max}
-      max_tag_width     = (rows.map{|i|i[2]} + ["TAGS"]    ).inject(0) {|max,i| [i.size,max].max}
-      table :border => false do
-        row :color => @colors[0]  do
-          column "NODES", :align => 'right', :width => max_node_width
-          column "SERVICES", :width => max_service_width, :padding => 2
-          column "TAGS", :width => max_tag_width
-        end
-        rows.each do |r|
-          row :color => @colors[1] do
-            column r[0]
-            column r[1]
-            column r[2]
-          end
-        end
-      end
-      vertical_spacing
-    end
-  end
-
-end; end