pantry 0.0.0 → 0.1.0

data/lib/pantry/communication/server.rb

@@ -0,0 +1,97 @@
+module Pantry
+  module Communication
+
+    # The communication layer of a Pantry::Server
+    # This class manages all of the ZeroMQ sockets and underlying
+    # communication systems, handling the sending and receiving of messages.
+    class Server
+      include Celluloid
+
+      #
+      # +listener+ must respond to the #receive_message method
+      def initialize(listener)
+        @listener           = listener
+        @response_wait_list = Communication::WaitList.new
+      end
+
+      # Start up the networking layer, opening up sockets and getting
+      # ready for client communication.
+      def run
+        @security = Communication::Security.new_server
+        @security.link_to(self)
+
+        @publish_socket = Communication::PublishSocket.new_link(
+          Pantry.config.server_host,
+          Pantry.config.pub_sub_port,
+          @security
+        )
+        @publish_socket.open
+
+        @receive_socket = Communication::ReceiveSocket.new_link(
+          Pantry.config.server_host,
+          Pantry.config.receive_port,
+          @security
+        )
+        @receive_socket.add_listener(self)
+        @receive_socket.open
+
+        @file_service = Communication::FileService.new_link(
+          Pantry.config.server_host,
+          Pantry.config.file_service_port,
+          @security
+        )
+        @file_service.start_server
+      end
+
+      # Ask Security to generate a new set of credentials as necessary
+      # for a new Client to connect to this Server
+      def create_client
+        @security.create_client
+      end
+
+      # Send a request to all clients, expecting a result. Returns a Future
+      # which can be queried later for the client response.
+      def send_request(message)
+        @response_wait_list.wait_for(message).tap do
+          publish_message(message)
+        end
+      end
+
+      # Send a message to all connected subscribers without modifying the package.
+      # Used when handling requests meant for other clients (say from the CLI). The source
+      # is untouched so the Client(s) handling know how to respond.
+      def forward_message(message)
+        message.forwarded!
+        publish_message(message)
+      end
+
+      # Send a message to all clients who match the given filter.
+      def publish_message(message)
+        message.from ||= @listener
+        @publish_socket.send_message(message)
+      end
+
+      # Listener callback from ReceiveSocket. See if we need to match this response
+      # with a previous request or if it's a new message entirely.
+      def handle_message(message)
+        if message.forwarded?
+          forward_message(message)
+        elsif @response_wait_list.waiting_for?(message)
+          @response_wait_list.received(message)
+        else
+          @listener.receive_message(message)
+        end
+      end
+
+      def receive_file(file_size, file_checksum)
+        @file_service.receive_file(file_size, file_checksum)
+      end
+
+      def send_file(file_path, receiver_uuid, file_uuid)
+        @file_service.send_file(file_path, receiver_uuid, file_uuid)
+      end
+
+    end
+
+  end
+end

data/lib/pantry/communication/subscribe_socket.rb

@@ -0,0 +1,33 @@
+module Pantry
+  module Communication
+
+    # The SubscribeSocket manages the Subscription side of the Pub/Sub channel,
+    # using a 0MQ PUB socket. This socket can subscribe to any number of streams
+    # depending on the filtering given. Messages received by this socket are passed
+    # to the configured listener as Messages.
+    class SubscribeSocket < ReadingSocket
+
+      def initialize(host, port, security)
+        super
+        @filter = ClientFilter.new
+      end
+
+      def filter_on(client_filter)
+        @filter = client_filter
+      end
+
+      def build_socket
+        Celluloid::ZMQ::SubSocket.new
+      end
+
+      def open_socket(socket)
+        socket.connect("tcp://#{host}:#{port}")
+
+        @filter.streams.each do |stream|
+          socket.subscribe(stream)
+        end
+      end
+
+    end
+  end
+end

data/lib/pantry/communication/wait_list.rb

@@ -0,0 +1,45 @@
+module Pantry
+  module Communication
+
+    # The WaitList manages futures for asynchronously waiting for responses
+    # from either the Client or the Server. Given an identity and a message,
+    # WaitList returns a Future that will be filled when the handler in question
+    # receives a message of the same Message type from that identity.
+    class WaitList
+
+      def initialize
+        @futures = Hash.new {|hash, key| hash[key] = []}
+      end
+
+      # Given a +message+ being sent, create a Future for a response to this message.
+      # This keys off of the Message's UUID, which must be kept in tact as it
+      # passes through the system.
+      def wait_for(message)
+        future = Celluloid::Future.new
+        @futures[ message.uuid ] << future
+        future
+      end
+
+      # Is there a future waiting for this response message?
+      def waiting_for?(message)
+        !@futures[ message.uuid ].empty?
+      end
+
+      # Internal to Celluloid::Future, using #signal ends up in a Result object
+      # in which calling #value then calls #value on the saved data which in our
+      # case is Message. We just want the Message so wrap up our messages in this
+      # object to work around this oddity.
+      #
+      # https://github.com/celluloid/celluloid/blob/master/lib/celluloid/future.rb#L89
+      FutureResultWrapper = Struct.new(:value)
+
+      def received(message)
+        if future = @futures[ message.uuid ].shift
+          future.signal(FutureResultWrapper.new(message))
+        end
+      end
+
+    end
+
+  end
+end

data/lib/pantry/communication/writing_socket.rb

@@ -0,0 +1,46 @@
+module Pantry
+  module Communication
+
+    # Base class of all sockets that write messages through ZMQ.
+    # Not meant for direct use, please use one of the subclasses for specific
+    # functionality.
+    class WritingSocket
+      include Celluloid::ZMQ
+
+      attr_reader :host, :port
+
+      def initialize(host, port, security)
+        @host     = host
+        @port     = port
+        @security = security
+      end
+
+      def open
+        @socket = build_socket
+        Communication.configure_socket(@socket)
+        @security.configure_socket(@socket)
+
+        open_socket(@socket)
+      end
+
+      def build_socket
+        raise "Implement the socket setup."
+      end
+
+      def open_socket(socket)
+        raise "Connect / Bind the socket built in #build_socket"
+      end
+
+      def close
+        @socket.close if @socket
+      end
+
+      def send_message(message)
+        @socket.write(
+          SerializeMessage.to_zeromq(message)
+        )
+      end
+
+    end
+  end
+end

data/lib/pantry/config.rb

@@ -0,0 +1,182 @@
+module Pantry
+
+  # Retrieve the current configuration set
+  def self.config
+    @@config ||= Config.new
+  end
+
+  def self.reset_config!
+    @@config = nil
+  end
+
+  # Global configuration values for running all of Pantry.
+  class Config
+    ##
+    # Global Configuration
+    ##
+
+    # Where does Pantry log to?
+    # Can be "stdout", "syslog", or a file system path
+    # Defaults to STDOUT
+    # When using syslog, program name will be "pantry"
+    attr_accessor :log_to
+
+    # After what level are logs dropped and ignored?
+    # Can be any of: "fatal", "error", "warn", "info", "debug"
+    # Each level will include the logs of all levels above it.
+    # Defaults to "info"
+    attr_accessor :log_level
+
+    # If logging to Syslog, set the program-name Pantry will
+    # use when sending logs to syslog.
+    # Defaults to "pantry"
+    attr_accessor :syslog_program_name
+
+    # Location on the file system Pantry will store any persistent data
+    # Default: /var/lib/pantry
+    attr_accessor :root_dir
+
+    ##
+    # Communication Configuration
+    ##
+
+    # Host name of the Pantry Server
+    attr_accessor :server_host
+
+    # Port used for Pub/Sub communication
+    attr_accessor :pub_sub_port
+
+    # Port clients use to send information to the Server
+    attr_accessor :receive_port
+
+    # Port through which files are sent and received
+    attr_accessor :file_service_port
+
+    # How often, in seconds, the client pings the Server
+    attr_accessor :client_heartbeat_interval
+
+    # What type of security will Pantry be employing?
+    # Available types are nil (no security) and "curve" (ZMQ4 Curve security)
+    #
+    # Defaults to nil because curve security has not yet been fully
+    # vetted by the crypto-community
+    attr_accessor :security
+
+    ##
+    # Client Identification
+    ##
+
+    # Unique identification of this Client
+    attr_accessor :client_identity
+
+    # Application this Client serves
+    attr_accessor :client_application
+
+    # Environment of the Application this Client runs
+    attr_accessor :client_environment
+
+    # Roles this Client serves
+    attr_accessor :client_roles
+
+    ##
+    # Testing configuration helpers
+    ##
+
+    # Time in seconds the CLI will wait for a response from the server
+    # By default this is nil, meaning unlimited timeout. Used mainly in tests.
+    attr_accessor :response_timeout
+
+    def initialize
+
+      # Logging defaults
+      @log_level = "info"
+      @syslog_program_name = "pantry"
+
+      # Default connectivity settings
+      @server_host       = "127.0.0.1"
+      @pub_sub_port      = 23001
+      @receive_port      = 23002
+      @file_service_port = 23003
+
+      # Default client heartbeat to every 5 minutes
+      @client_heartbeat_interval = 300
+
+      # Default Client identificiation values
+      @client_identity    = nil
+      @client_application = nil
+      @client_environment = nil
+      @client_roles       = []
+
+    end
+
+    # Given a YAML config file, read in config values
+    def load_file(config_file)
+      configs = SafeYAML.load_file(config_file)
+      load_global_configs(configs)
+      load_networking_configs(configs["networking"])
+      load_client_configs(configs["client"])
+      refresh
+    end
+
+    def refresh
+      apply_configuration
+    end
+
+    protected
+
+    def load_global_configs(configs)
+      @log_to = configs["log_to"]
+
+      if configs["log_level"]
+        @log_level = configs["log_level"]
+      end
+
+      if configs["syslog_program_name"]
+        @syslog_program_name = configs["syslog_program_name"]
+      end
+
+      @root_dir = configs["root_dir"]
+    end
+
+    def load_networking_configs(configs)
+      return unless configs
+
+      if configs["server_host"]
+        @server_host  = configs["server_host"]
+      end
+
+      if configs["pub_sub_port"]
+        @pub_sub_port = configs["pub_sub_port"]
+      end
+
+      if configs["receive_port"]
+        @receive_port = configs["receive_port"]
+      end
+
+      if configs["file_service_port"]
+        @file_service_port = configs["file_service_port"]
+      end
+
+      @security = configs["security"]
+    end
+
+    def load_client_configs(configs)
+      return unless configs
+
+      @client_identity    = configs["identity"]
+      @client_application = configs["application"]
+      @client_environment = configs["environment"]
+      @client_roles       = configs["roles"]
+
+      if configs["heartbeat_interval"]
+        @client_heartbeat_interval = configs["heartbeat_interval"]
+      end
+    end
+
+    def apply_configuration
+      # Reset our logger knowledge so the next call picks up the
+      # new configs
+      Pantry.logger = nil
+    end
+  end
+end

data/lib/pantry/file_editor.rb

@@ -0,0 +1,67 @@
+module Pantry
+
+  # Use EDITOR to edit the contents of a remote file locally
+  # The editor can validate the updated content to be YAML (more to be added as needed)
+  # and will show errors and re-edit the file if validation fails.
+  #
+  # If the user chooses to cancel editing, #edit will return the original
+  # content given to it.
+  #
+  # Usage is simple:
+  #
+  #   editor = FileEditor.new
+  #   updated_content = editor.edit(file_contents, file_type)
+  #
+  class FileEditor
+
+    def initialize
+      @editor = ENV['EDITOR']
+      raise "Please set EDITOR environment variable to a text editor." unless @editor
+    end
+
+    def edit(original_content, file_type)
+      file = create_temp_file(original_content, file_type)
+      new_content = ""
+
+      loop do
+        new_content = edit_file(file)
+
+        is_valid, message = validate_content(new_content, file_type)
+        break if is_valid
+
+        Pantry.ui.say(message)
+        if !Pantry.ui.continue?("Continue editing?")
+          new_content = original_content
+          break
+        end
+      end
+
+      file.unlink
+      new_content
+    end
+
+    protected
+
+    def create_temp_file(file_contents, file_type)
+      tempfile = Tempfile.new(["edit-in-line", ".#{file_type}"])
+      tempfile.write(file_contents)
+      tempfile.close
+      tempfile
+    end
+
+    def edit_file(tempfile)
+      system("#{@editor} #{tempfile.path}")
+      File.read(tempfile.path)
+    end
+
+    def validate_content(content, file_type)
+      begin
+        Psych.parse(content, "config.yml")
+        return true, nil
+      rescue => ex
+        return false, ex.message
+      end
+    end
+  end
+
+end