helm 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: de942658d9f770530a4b5ef00b7481cc03dbf4e3
+  data.tar.gz: 7418c354fc2f5122d2e8f86d56d05f6123a26811
+SHA512:
+  metadata.gz: d5611ba2985c413ea5b0964ff9b36243ee061b1627a076c54362770ea0b94874a1b81e86c1ef4eec40e51b7c7e98d262b8534efbcc65c0529b7f0a40f77dacbe
+  data.tar.gz: 73550c907b1a97555e299981057ba0eb4c21987bf0765ef8cffa210ca3c7ec9f416a3460c05e9868449300168edb196e3d0b7fc1fbffe899a8b5473089c963c6

data/bin/helm

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+require 'helm/cli'
+
+Helm.load_commands
+Helm::CLI::Main.start(ARGV)

data/lib/helm.rb

@@ -0,0 +1,60 @@
+require 'valise'
+require 'sequel'
+require 'logger'
+require 'helm/application'
+require 'helm/cli'
+require 'helm/server-command'
+
+module Helm
+  class << self
+    def logger
+      @logger ||= Logger.new($stderr).tap do |logger|
+        logger.level = Logger::ERROR
+      end
+    end
+
+    def databases
+      @databases ||= Hash.new do |hash, conn_string|
+        hash[conn_string] = Sequel::connect(conn_string, :logger => logger).tap do |db|
+          db.extension(:pretty_table)
+        end
+      end
+    end
+
+    def log_at(level)
+      begin
+        old_level, logger.level = logger.level, level
+        yield
+      ensure
+        logger.level = old_level
+      end
+    end
+
+    def check_db(db_string, directory)
+      require 'sequel/extensions/migration'
+
+      unless Sequel::Migrator.is_current?(databases[db_string], directory)
+        warn "Your servers database is out of date. You should run #$0 db update."
+      end
+    end
+
+    def valise
+      @valise ||= Valise.define do
+        ro from_here(%w{.. default_configuration}, up_to("lib"))
+      end
+    end
+
+    def commands_valise
+      @commands_valise ||= valise.sub_set("commands")
+    end
+
+    def load_commands
+      commands_valise.glob("*.rb") do |file|
+        require file.full_path
+      end
+      ServerCommand.valid_commands.each do |command_class|
+        CLI::Main.define_from(command_class.new)
+      end
+    end
+  end
+end

data/lib/helm/application.rb

@@ -0,0 +1,163 @@
+require 'helm/command-runner'
+require 'helm/queries/server'
+
+module Helm
+  module Commands
+    class Command
+      def initialize(app_config, options)
+        @app_config = app_config
+        @options = options
+      end
+      attr_accessor :app_config, :options
+
+      def if_option(name)
+        if options.has_key?(name.to_s)
+          yield(options[name])
+        end
+      end
+    end
+
+    module Main
+      class Defined < Command
+        def initialize(app_config, options, config)
+          @config = config
+          super(app_config, options)
+        end
+        attr_reader :config
+
+        def execute
+          config.query_options = options || {}
+
+          query = Helm::Queries::Server.new(app_config.connstring)
+          if_option(:client){|client| query.client = client }
+          if_option(:role){|role| query.role = role }
+          if_option(:name){|name| query.name = name }
+          if_option(:platform){|platform| query.platform = platform }
+
+          runner = Helm::CommandRunner.new(query, config)
+          runner.run
+        end
+      end
+    end
+
+    module Database
+      class Migrate < Command
+        def initialize(app_config, options)
+          @directory = "migrations"
+          super
+        end
+        attr_accessor :db_string, :directory
+
+        def execute
+          require 'sequel/extensions/migration'
+
+          Helm.log_at(Logger::DEBUG) do
+            Sequel::Migrator.run(Helm.databases[app_config.connstring], directory)
+          end
+        end
+      end
+    end
+
+    module Servers
+      class Add < Command
+        def initialize(app_config, options, source_io)
+          @source_io = source_io
+          super(app_config, options)
+        end
+
+        def execute
+          require 'yaml'
+          require 'helm/persisters/server'
+          serverlist = Array(YAML.load(source_io.read))
+
+          store = Helm::Persisters::Server.new(app_config.connstring)
+
+          defaults = {:client => options[:client]}
+
+          serverlist.each do |server|
+            store.insert_or_update(defaults.merge(server))
+          end
+        end
+      end
+
+      class List < Command
+        def execute
+          require 'helm/queries/server'
+          Helm::Queries::Server.new(app_config.connstring).print
+        end
+      end
+
+      class Edit < Command
+        def edit_tempfile(file)
+          require 'io/console'
+
+          edit_shell = Caliph::Shell.new
+          edit_shell.output_stream = File.new("/dev/null", "a")
+          edit_shell.run(ENV['EDITOR'] || app_config.editor, file.path) do |cmd|
+            cmd.redirect_stdin(IO.console.path)
+            cmd.redirect_stdout(IO.console.path)
+          end
+        ensure
+          edit_shell.output_stream.close
+        end
+
+        def server_query
+          query = Helm::Queries::Server.new(app_config.connstring)
+
+          if_option(:id){|server_id| query.server_id = server_id }
+          if_option(:client){|client| query.client = client }
+          if_option(:role){|role| query.role = role }
+          if_option(:name){|name| query.name = name }
+          if_option(:platform){|platform| query.platform = platform }
+
+          query
+        end
+
+        def put_server_record_in_file(query, file)
+          server = query.first
+          server_hash = server.to_hash
+
+          server_id = server_hash.delete(:server_id)
+
+          file.write("# Edit this file to update the server\n")
+          file.write(server_hash.to_yaml)
+          file.close
+
+          return server_id
+        end
+
+        def save_server_record_to_database(server_id, file)
+          file.open
+          new_hash = YAML.load(file.read).merge(:server_id => server_id)
+
+          store = Helm::Persisters::Server.new(app_config.connstring)
+          store.insert_or_update(new_hash)
+        end
+
+        def execute
+          require 'yaml'
+          require 'helm/persisters/server'
+
+          query = server_query
+
+          unless query.to_a.length == 1
+            puts "#{query.to_a.length} servers match #{query.constraint.inspect}"
+            exit 1
+          end
+
+          begin
+            file = Tempfile.new('server', app_config.tempdir)
+
+            server_id = put_server_record_in_file(query, file)
+
+            edit_tempfile(file)
+
+            save_server_record_to_database(server_id, file)
+          ensure
+            file.unlink if file
+          end
+        end
+      end
+    end
+  end
+end

data/lib/helm/cli.rb

@@ -0,0 +1,75 @@
+require 'helm'
+require 'thor'
+
+module Helm
+  Config = Struct.new(:connstring, :editor, :tempdir)
+
+  def self.config
+    Config.new("sqlite://servers.sql", "vim", ".")
+  end
+
+  module CLI
+    class DB < Thor
+      include Commands::Database
+
+      desc "update", "Update the servers database schema"
+      def update
+        Migrate.new(Helm.config, options).execute
+      end
+    end
+
+    class Server < Thor
+      include Commands::Servers
+
+      desc "add", "Add a list of servers described in YAML from STDIN"
+      option :client, :banner => "Client name"
+      def add
+        Add.new(Helm.config, options, $stdin).execute
+      end
+
+      desc "list", "List servers that Helm knows about"
+      def list
+        puts List.new(Helm.config, options).execute
+      end
+
+      desc "edit", "Edit the details of particular servers"
+      method_option :id
+      def edit
+        Edit.new(Helm.config, options).execute
+      end
+    end
+
+    class Main < Thor
+      desc "db SUBCOMMAND", "server database maintenance tasks"
+      subcommand "db", DB
+
+      desc "server SUBCOMMAND", "server listing tasks"
+      subcommand "server", Server
+
+      class_option :client
+      class_option :name
+      class_option :role
+
+      class << self
+        def define_from(command_config)
+          desc command_config.name.to_s, command_config.description
+          command_config.scope_options.each do |name|
+            option name, :required => true
+          end
+
+          define_method command_config.name do |*args|
+            command = Commands::Main::Defined.new(Helm.config, options, command_config)
+            command.execute(*args)
+          end
+        end
+      end
+
+      def help(task = nil, subcommand=false)
+        super
+
+        shell.say "Commands are loaded from:"
+        shell.say Helm.commands_valise.to_s
+      end
+    end
+  end
+end

data/lib/helm/command-runner.rb

@@ -0,0 +1,56 @@
+require 'caliph'
+
+module Helm
+  class CommandRunner
+    CommandExecution = Struct.new(:server, :result)
+
+    def initialize(server_query, command_definition)
+      @server_query, @command_definition = server_query, command_definition
+      @completed = []
+      @ran_any = false
+    end
+
+    attr_accessor :server_query, :command_definition, :shell
+
+    def shell
+      @shell ||= Caliph::Shell.new
+    end
+
+    def run
+      start_run
+      catch :fail do
+        configured_query.each do |server|
+          result = run_one(command_definition.command(server))
+          execution = CommandExecution.new(server, result)
+          collect(execution)
+        end
+      end
+      finish_run
+    end
+
+    def configured_query
+      command_definition.configure_query(server_query)
+      server_query
+    end
+
+    def run_one(single)
+      @ran_any = true
+      shell.execute(single)
+    end
+
+    def start_run
+      @ran_any = false
+    end
+
+    def finish_run
+      warn "No servers found for #{server_query}!" unless @ran_any
+      command_definition.all_results(@completed)
+      return true
+    end
+
+    def collect(execution)
+      @completed << execution
+      command_definition.each_result(execution)
+    end
+  end
+end

data/lib/helm/persister.rb

@@ -0,0 +1,27 @@
+require 'helm'
+
+module Helm
+  class Persister
+    def initialize(db_string)
+      @db = Helm.databases[db_string]
+    end
+    attr_accessor :db
+
+    def slice(hash)
+      Hash[
+        columns.zip(
+          hash.values_at(*columns).zip(
+            hash.values_at(*(columns.map(&:to_s)))
+      ).map{|sym_val, str_val| sym_val || str_val })
+      ]
+    end
+
+    def dataset
+      @db[table_name]
+    end
+
+    def insert_or_update(row)
+      dataset.replace(slice(row))
+    end
+  end
+end

data/lib/helm/persisters/server.rb

@@ -0,0 +1,16 @@
+require 'helm/persister'
+require 'helm/records/server'
+
+module Helm
+  module Persisters
+    class Server < Persister
+      def columns
+        Records::Server.columns
+      end
+
+      def table_name
+        :servers
+      end
+    end
+  end
+end

data/lib/helm/queries/server.rb

@@ -0,0 +1,38 @@
+require 'helm/query'
+require 'helm/records/server'
+
+module Helm
+  module Queries
+    class Server < Query
+      attr_accessor :server_id, :client, :name, :role, :platform, :id_from_platform
+
+      def to_s
+        nil_attrs = constraint_attrs.reject{|attr| constraint_hash.has_key?(attr) }
+        "Servers query: #{constraint_hash.inspect} (not set: #{nil_attrs.inspect})"
+      end
+
+      def inspect
+        "<#{self.class.name}:#{"%0x" % object_id} #{constraint.select_sql rescue "<?sql?>"}>"
+      end
+
+      def constraint_attrs
+        [:server_id, :client, :name, :role, :platform, :id_from_plaform]
+      end
+
+      def constraint_hash
+        @constraint_hash ||= constraint_attrs.each_with_object({}) do |attr, hash|
+          val = instance_variable_get("@#{attr}")
+          hash[attr] = val unless val.nil?
+        end
+      end
+
+      def constraint
+        @constraint ||= @db[:servers].where(constraint_hash)
+      end
+
+      def result_class
+        Records::Server
+      end
+    end
+  end
+end

data/lib/helm/query.rb

@@ -0,0 +1,28 @@
+require 'helm'
+
+module Helm
+  class Query
+    include Enumerable
+
+    def initialize(conn_string)
+      @db = Helm.databases[conn_string]
+    end
+
+    attr_reader :db
+    attr_accessor :result_class
+
+    def constraint
+      @constraint ||= @db
+    end
+
+    def print
+      constraint.print
+    end
+
+    def each
+      constraint.select(*result_class.columns).each do |row|
+        yield result_class.new(row)
+      end
+    end
+  end
+end

data/lib/helm/record.rb

@@ -0,0 +1,72 @@
+module Helm
+  class Record
+    class << self
+      attr_accessor :columns
+
+      def types
+        @types ||= {}
+      end
+
+      def with_columns(*columns)
+        types[columns.sort] || subclass(*columns)
+      end
+
+      def subclass(*columns, &block)
+        klass = Class.new(self, &block)
+        columns = columns.sort
+        klass.columns = columns
+
+        columns.each do |column|
+          klass.column_accessor(column)
+        end
+        types[columns] ||= klass
+      end
+
+      def column_accessor(name)
+        unless instance_methods(false).include?(name)
+          define_method name do
+            @values[name]
+          end
+        end
+
+        write_method = "#{name}="
+        unless instance_methods(false).include?(write_method)
+          define_method write_method do |value|
+            @values[name] = value
+          end
+        end
+      end
+    end
+
+    def [](key)
+      @values[key]
+    end
+
+    def []=(key, value)
+      @values[key] = value
+    end
+
+    def keys
+      @row.keys | @values.keys
+    end
+
+    def initialize(row)
+      @row = row
+      @values = Hash.new do |h, k|
+        @row[k]
+      end
+    end
+
+    def changed
+      @values.keys
+    end
+
+    def to_hash
+      Hash[ keys.map{|key| [key, self[key]]}]
+    end
+
+    def to_yaml
+      to_hash.to_yaml
+    end
+  end
+end

data/lib/helm/records/server.rb

@@ -0,0 +1,24 @@
+require 'helm/record'
+
+module Helm
+  module Records
+    Server = Record.subclass(
+      :server_id,
+      :platform,
+      :id_from_platform,
+      :name,
+      :client,
+      :private_dns_name,
+      :public_dns_name,
+      :private_ip_address,
+      :public_ip_address,
+      :ssh_key_name,
+      :architecture,
+      :launch_time
+    ) do
+      def name
+        self[:name] || [self[:platform], self[:id_from_platform]].join(":")
+      end
+    end
+  end
+end

data/lib/helm/server-command.rb

@@ -0,0 +1,116 @@
+require 'caliph/command-line-dsl'
+
+module Helm
+  class ServerCommand
+
+    class << self
+      def subclasses
+        @subclasses ||= []
+      end
+
+      def inherited(sub)
+        ServerCommand.subclasses << sub
+      end
+
+      def abstract
+        @abstract = true
+      end
+
+      def abstract?
+        !!@abstract
+      end
+
+      def valid_commands(quietly = false)
+        valid = []
+        ServerCommand.subclasses.each do |sub|
+          next if sub.abstract?
+
+          methods = sub.instance_methods(false)
+
+          unless methods.include?(:name) and methods.include?(:command)
+            unless quietly
+              warn "ServerCommand subclass #{sub.name} isn't abstract and doesn't define :name and :command"
+              a_method = sub.instance_method(methods.first)
+              warn "  (appears to be defined in #{a_method.source_location.first})"
+            end
+            next
+          end
+
+          valid << sub
+        end
+        valid
+      end
+    end
+
+    def valid?
+      true
+    end
+
+    def desc
+      ""
+    end
+    alias description desc
+
+    def required_options
+      []
+    end
+    alias scope_options required_options
+
+    attr_accessor :query_options
+
+    def configure_query(query)
+    end
+
+    def each_result(execution)
+      format_result(execution)
+      if execution.result.exit_code != 0
+        throw :fail
+      end
+    end
+
+    def all_results(results)
+    end
+
+    def format_result(execution)
+      result = execution.result
+      server = execution.server
+
+      puts "#{server.name} (#{server.public_ip_address})"
+      puts "#{result.command.string_format} => #{result.exit_code}"
+      puts result.format_streams
+      puts
+    end
+
+    include Caliph::CommandLineDSL
+
+    def ssh(server, *command, &block)
+      cmd("ssh") do |command|
+        command.options << "-o BatchMode=yes"
+        command.options << "-i " + server.ssh_key_name unless server.ssh_key_name.nil?
+        #command.options << "-l " + server.connect_as unless
+        #server.connect_as.nil?
+        # XXX need to add 'connect_as'
+        #command.options << "-p " + server.port unless server.ssh_port.nil?  ##ok
+        # XXX need to add "ssh_port"
+        command.options << server.public_dns_name || server.public_ip_address
+      end - escaped_command(*command, &block)
+    end
+  end
+
+  module Persistent
+    def each_result(result)
+      format_results(result)
+    end
+  end
+
+  module Picky
+    def all_results(results)
+      if results.any?{|execution| execution.result.exit_code != 0}
+        raise "Command failed!\n  #{
+          results.select{|execution| execution.result.exit_code != 0
+        }.map{|exec| exec.result.inspect}.join("  \n")
+        }"
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,148 @@
+--- !ruby/object:Gem::Specification
+name: helm
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Judson Lester
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-10-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.18'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.18'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 10.1.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 10.1.1
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.3.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.3.5
+- !ruby/object:Gem::Dependency
+  name: sequel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 4.6.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 4.6.0
+- !ruby/object:Gem::Dependency
+  name: caliph
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.3.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.3.1
+- !ruby/object:Gem::Dependency
+  name: valise
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.1.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.1.1
+description: ''
+email:
+- nyarly@gmail.com
+executables:
+- helm
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/helm/records/server.rb
+- lib/helm/persister.rb
+- lib/helm/queries/server.rb
+- lib/helm/record.rb
+- lib/helm/cli.rb
+- lib/helm/persisters/server.rb
+- lib/helm/command-runner.rb
+- lib/helm/server-command.rb
+- lib/helm/query.rb
+- lib/helm/application.rb
+- lib/helm.rb
+- bin/helm
+- spec_help/gem_test_suite.rb
+homepage: http://nyarly.github.com/helm
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options:
+- --inline-source
+- --main
+- doc/README
+- --title
+- helm-0.0.1 Documentation
+require_paths:
+- lib/
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: helm
+rubygems_version: 2.0.14
+signing_key: 
+specification_version: 4
+summary: ''
+test_files:
+- spec_help/gem_test_suite.rb