pantry 0.0.0 → 0.1.0

data/lib/pantry/command_handler.rb

@@ -0,0 +1,53 @@
+module Pantry
+
+  # Manages and processes commands as requested from the Client or the Server.
+  # Given a mapping of available commands, maps the incoming message to the appropriate
+  # command handler and returns the response. Returns nil if no command found.
+  class CommandHandler
+
+    def initialize(server_or_client, commands_to_register = [])
+      @handlers = {}
+      @server_or_client = server_or_client
+
+      commands_to_register.each do |command_class|
+        add_command(command_class)
+      end
+    end
+
+    # Install a Command class as a message handler for this process.
+    # The Message's +type+ for this kind of message is simply the name of the class
+    # without any scope information. E.g. Echo not Pantry::Command::Echo.
+    def add_command(command_class)
+      @handlers[command_class.message_type] = build_command_proc(command_class)
+    end
+
+    # Does this CommandHandler know how to handle the given command?
+    def can_handle?(message)
+      !@handlers[message.type].nil?
+    end
+
+    # Given a message, figure out which handler should be triggered and get things rolling
+    def process(message)
+      if handler = @handlers[message.type]
+        Pantry.logger.debug("[#{@server_or_client.identity}] Running handler on #{message.inspect}")
+        handler.call(message)
+      else
+        Pantry.logger.warn(
+          "[#{@server_or_client.identity}] No known handler for message type #{message.type}"
+        )
+        nil
+      end
+    end
+
+    protected
+
+    def build_command_proc(command_class)
+      proc do |message|
+        command_obj = command_class.new
+        command_obj.server_or_client = @server_or_client
+        command_obj.perform(message)
+      end
+    end
+  end
+
+end

data/lib/pantry/command_line.rb

@@ -0,0 +1,115 @@
+module Pantry
+
+  class CommandLine
+
+    # The top-level set of CLI options and flags Pantry respects
+    BASE_OPTIONS = proc {
+      banner "Usage: #{File.basename($0)} [options] [command [command options]]"
+      option "-h", "--host HOSTNAME", String, "Hostname of the Server to connect to"
+      option "--curve-key-file FILE", String, "Name of the file in .pantry holding Curve keys.",
+        "Specifying this option will turn on Curve encryption."
+
+      option "-a", "--application APPLICATION", String, "Filter Clients by a specific APPLICATION"
+      option "-e", "--environment ENVIRONMENT", String, "Filter Clients by a specific ENVIRONMENT"
+      option "-r", "--roles ROLE1,ROLE2",       Array,  "Filter Clients by given ROLES"
+      option "-v", "--verbose", "Verbose output (INFO)"
+      option "-d", "--debug",   "Even more Verbose output (DEBUG)"
+      option "-V", "--version", "Print out Pantry's version"
+    }
+
+    def initialize(command_line)
+      @command_line   = command_line
+      @known_commands = {}
+
+      @commands = find_all_cli_enabled_commands
+    end
+
+    # Parse the full command line. Returns a hash containing the options found
+    # as well as what is still left on the command line.
+    # If the command line is empty, will default to --help.
+    #
+    # Returns [nil, nil] if help was requested or there was a problem.
+    def parse!
+      @command_line = merge_command_line_with_defaults(@command_line)
+      parser = build_parser(@commands)
+
+      begin
+        if @command_line.empty?
+          @command_line << "--help"
+        end
+
+        @parsed_options = parser.parse!(@command_line)
+
+        if @parsed_options['help']
+          # Help printed already
+          return [nil, nil]
+        end
+
+        [@parsed_options, @command_line]
+      rescue => ex
+        puts ex, ""
+        puts parser.help
+        [nil, nil]
+      end
+    end
+
+    # Returns details of the command found during parsing.
+    # Returns a hash with the keys +banner+ and +class+,
+    # or returns nil if no matching command was found
+    def triggered_command
+      [
+        @commands[@parsed_options.command_found],
+        @parsed_options[@parsed_options.command_found]
+      ]
+    end
+
+    protected
+
+    def find_all_cli_enabled_commands
+      commands = {}
+      Pantry.all_commands.each do |command_class|
+        if command_class.command_name
+          # Hmm duplicated from OptParsePlus
+          base_command_name = command_class.command_name.split(/\s/).first
+          commands[base_command_name] = {
+            banner: command_class.command_name,
+            class:  command_class
+          }
+        end
+      end
+
+      commands
+    end
+
+    def merge_command_line_with_defaults(command_line)
+      [read_defaults_file, command_line].flatten
+    end
+
+    def read_defaults_file
+      dot_pantry_config = Pantry.root.join("config")
+
+      if File.exist?(dot_pantry_config)
+        # ARGV is an array of the command line seperated by white-space.
+        # Make sure what we read from .pantry returns the same
+        File.readlines(dot_pantry_config).map { |line|
+          line.strip.split(/\s/)
+        }.flatten
+      else
+        []
+      end
+    end
+
+    def build_parser(cli_commands)
+      parser = OptParsePlus.new
+      parser.add_options(&BASE_OPTIONS)
+
+      cli_commands.each do |base_command_name, command_info|
+        parser.add_command(command_info[:banner], &command_info[:class].command_config)
+      end
+
+      parser
+    end
+
+  end
+
+end

data/lib/pantry/commands/create_client.rb

@@ -0,0 +1,30 @@
+module Pantry
+  module Commands
+
+    # Ask the server to generate a new set of keys
+    # Prints a yaml file that contains the required keys for a client to properly
+    # conenct and authenticate to the server
+    class CreateClient < Pantry::Command
+      command "client:create" do
+        description "Generate a new public/private encryption keypair for a client."
+      end
+
+      def perform(message)
+        server.create_client
+      end
+
+      def receive_server_response(message)
+        keys = message.body[0]
+        Pantry.ui.say("New Client Credentials")
+        Pantry.ui.say("Store this in the Client's Pantry.root/security/curve/client_keys.yml")
+        Pantry.ui.say(YAML.dump({
+          "server_public_key" => keys[:server_public_key],
+          "public_key" => keys[:public_key],
+          "private_key" => keys[:private_key]
+        }))
+      end
+
+    end
+
+  end
+end

data/lib/pantry/commands/download_directory.rb

@@ -0,0 +1,35 @@
+module Pantry
+  module Commands
+
+    # Download all content inside of the given directory.
+    #
+    # This command expects simple directories with a small number of files that are
+    # themselves small in size, as this command reads every file into memory and sends
+    # that raw content back to the Client. If there are more substantial files to transfer
+    # use #send_file and #receive_file instead.
+    class DownloadDirectory < Pantry::Command
+
+      def initialize(directory = nil)
+        @directory = directory
+      end
+
+      def to_message
+        super.tap do |message|
+          message << @directory.to_s
+        end
+      end
+
+      def perform(message)
+        directory = Pantry.root.join(message.body[0])
+
+        Dir[directory.join("**", "*")].map do |file|
+          next if File.directory?(file)
+          [Pathname.new(file).relative_path_from(directory).to_s,
+           File.read(file)]
+        end.compact
+      end
+
+    end
+
+  end
+end

data/lib/pantry/commands/echo.rb

@@ -0,0 +1,32 @@
+module Pantry
+  module Commands
+
+    # Simple Echo command, returns the body of the Message given.
+    class Echo < Command
+
+      command "echo MESSAGE" do
+        description "Test Client communication with a simple Echo request"
+      end
+
+      def initialize(string_to_echo = "")
+        @string_to_echo = string_to_echo
+      end
+
+      def to_message
+        message = super
+        message << @string_to_echo
+        message
+      end
+
+      def perform(message)
+        message.body[0]
+      end
+
+      def receive_client_response(response)
+        Pantry.ui.say("#{response.from} echo's #{response.body[0].inspect}")
+      end
+
+    end
+
+  end
+end

data/lib/pantry/commands/edit_application.rb

@@ -0,0 +1,60 @@
+module Pantry
+  module Commands
+
+    # Edit the configuration of the requested Application.
+    #
+    # Application configuration is stored on the Server under
+    # Pantry.root/applications/[app name]/config.yml and is where all
+    # configuration lives for how Pantry manages this application.
+    class EditApplication < Pantry::Command
+
+      command "edit" do
+        description "Edit an application's configuration with the text editor specified in $EDITOR.
+          Requires an Application."
+      end
+
+      def prepare_message(options)
+        @application = options[:application]
+        raise Pantry::MissingOption, 'Missing required option "application"' unless @application
+
+        # Let the EDITOR check run before we do any communication
+        @editor = Pantry::FileEditor.new
+
+        super.tap do |msg|
+          msg << @application
+        end
+      end
+
+      # Read or create a new config file for the given application
+      # and return the contents of this config file, which will always be
+      # a YAML document
+      def perform(message)
+        application = message.body[0]
+
+        config_file = Pantry.root.join("applications", application, "config.yml")
+        FileUtils.mkdir_p(File.dirname(config_file))
+
+        if File.exists?(config_file)
+          [File.read(config_file)]
+        else
+          [{"name" => application}.to_yaml]
+        end
+      end
+
+      def receive_server_response(message)
+        current_config = message.body[0]
+        new_config     = @editor.edit(current_config, :yaml)
+
+        if new_config != current_config
+          send_request!(
+            Pantry::Commands::UpdateApplication.new(
+              @application, new_config
+            ).to_message
+          )
+        end
+      end
+
+    end
+
+  end
+end

data/lib/pantry/commands/register_client.rb

@@ -0,0 +1,38 @@
+module Pantry
+  module Commands
+
+    class RegisterClient < Command
+
+      def initialize(client_info = nil)
+        @client_info = client_info
+      end
+
+      def to_message
+        message = super
+        message << {
+          application: @client_info.application,
+          environment: @client_info.environment,
+          roles:       @client_info.roles
+        }
+        message
+      end
+
+      # Take note that a Client has connected and registered itself
+      # with this Server.
+      def perform(message)
+        details = message.body[0]
+
+        @client_info = Pantry::ClientInfo.new(
+          identity:    message.from,
+          application: details[:application],
+          environment: details[:environment],
+          roles:       details[:roles]
+        )
+
+        self.server.register_client(@client_info)
+      end
+
+    end
+
+  end
+end

data/lib/pantry/commands/status.rb

@@ -0,0 +1,78 @@
+module Pantry
+  module Commands
+
+    class Status < Command
+
+      command "status" do
+        description "List all Clients that match the options"
+      end
+
+      attr_accessor :client_filter
+
+      def prepare_message(options)
+        @client_filter = Pantry::Communication::ClientFilter.new(
+          application: options[:application],
+          environment: options[:environment],
+          roles: options[:roles]
+        )
+        super
+      end
+
+      def to_message
+        message = super
+        message << @client_filter.to_hash
+        message
+      end
+
+      # Return information about all connected Clients that match the given filter
+      def perform(message)
+        @client_filter = Pantry::Communication::ClientFilter.new(**(message.body[0] || {}))
+        self.server.client_registry.all_matching(@client_filter) do |client, record|
+          {
+            identity:        client.identity,
+            application:     client.application,
+            environment:     client.environment,
+            roles:           client.roles,
+            last_checked_in: record.last_checked_in_at
+          }
+        end
+      end
+
+      def receive_server_response(message)
+        output =
+          clients = message.body.map do |client|
+            [
+              time_ago_in_words(client[:last_checked_in]),
+              client[:identity],
+              "|",
+              client[:application],
+              client[:environment],
+              [client[:roles]].flatten.join(",")
+            ].compact.join(" ")
+          end
+
+        Pantry.ui.list(output)
+      end
+
+      protected
+
+      def time_ago_in_words(time)
+        now = DateTime.now.to_time
+        checked_in = DateTime.parse(time).to_time
+
+        seconds_since = (now - checked_in).to_i
+        case seconds_since
+        when 0..(2*60)
+          Pantry.ui.color("A minute ago", :green)
+        when (2*60+1)..(59*60)
+          Pantry.ui.color("#{seconds_since / 60} minutes ago", :green)
+        else
+          hours_since = seconds_since / 60 / 60
+          hours_key = hours_since > 1 ? "hours" : "hour"
+          Pantry.ui.color("#{hours_since} #{hours_key} ago", :red)
+        end
+      end
+    end
+
+  end
+end