kstor 0.4.2 → 0.5.0

data/lib/kstor/log.rb

@@ -1,56 +1,105 @@
 # frozen_string_literal: true
 
-require 'journald/logger'
-
 module KStor
   # Central logging to systemd-journald.
   module Log
     class << self
+      # Log an exception.
+      #
+      # @param exc [Exception] exception to log.
       def exception(exc)
         logger.exception(exc)
       end
 
+      # Log a debug message.
+      #
+      # @param msg [String] message
       def debug(msg)
         logger.debug(msg)
       end
 
+      # Log an informative message.
+      #
+      # @param msg [String] message
       def info(msg)
         logger.info(msg)
       end
 
+      # Log a notice message.
+      #
+      # @param msg [String] message
       def notice(msg)
         logger.notice(msg)
       end
 
+      # Log a warning.
+      #
+      # @param msg [String] message
       def warn(msg)
         logger.warn(msg)
       end
 
+      # Log an error message.
+      #
+      # @param msg [String] message
       def error(msg)
         logger.error(msg)
       end
 
+      # Log a critical error message.
+      #
+      # @param msg [String] message
       def critical(msg)
         logger.critical(msg)
       end
 
+      # Log an alert message.
+      #
+      # @param msg [String] message
       def alert(msg)
         logger.alert(msg)
       end
 
+      # Log an emergency message.
+      #
+      # @param msg [String] message
       def emergency(msg)
         logger.emergency(msg)
       end
 
+      # Set reporting level.
       def reporting_level=(lvl)
-        logger.min_priority = lvl
+        lvl = level_str_to_int(lvl) if lvl.respond_to?(:to_str)
+
+        if logger.respond_to?(:min_priority)
+          logger.min_priority = lvl
+        else
+          logger.level = lvl
+        end
       end
 
       private
 
+      def level_str_to_int(value)
+        case value
+        when /^debug$/i then const_get(:DEBUG)
+        when /^info$/i then const_get(:INFO)
+        when /^warn$/i then const_get(:WARN)
+        when /^error$/i then const_get(:ERROR)
+        else
+          raise "Unknown log level #{value.inspect}"
+        end
+      end
+
       def logger
-        @logger ||= Journald::Logger.new('kstor')
+        @logger ||= create_logger
       end
     end
   end
 end
+
+if ENV['INIT_IS_SYSTEMD']
+  require 'kstor/log/systemd_logger'
+else
+  require 'kstor/log/simple_logger'
+end

data/lib/kstor/message/base.rb

@@ -0,0 +1,223 @@
+# frozen_string_literal: true
+
+module KStor
+  # Units of communication between server and clients.
+  module Message
+    # A user request or response.
+    class Base
+      attr_reader :args
+
+      # Create new message.
+      #
+      # @param args [Hash] message arguments
+      # @param auth [Hash] authentication data
+      # @return [KStor::Message::Base] new message
+      def initialize(args, auth = {})
+        @args = check_args!(args)
+        @auth = check_auth!(auth.compact)
+      end
+
+      # Message type.
+      def type
+        self.class.type
+      end
+
+      # User login
+      def login
+        @auth[:login]
+      end
+
+      # User password
+      def password
+        @auth[:password]
+      end
+
+      # User session ID
+      def session_id
+        @auth[:session_id]
+      end
+
+      # True if this message is a request.
+      def request?
+        self.class.request
+      end
+
+      # True if this message is a response.
+      def response?
+        !request?
+      end
+
+      # True if this message is an error response.
+      def error?
+        response? && type == 'error'
+      end
+
+      # True if this message is a request and has login and password arguments.
+      def login_request?
+        request? && @auth.key?(:login) && @auth.key?(:password)
+      end
+
+      # True if this message is a request and has a session ID.
+      def session_request?
+        request? && @auth.key?(:session_id)
+      end
+
+      # Convert this message to a Hash
+      #
+      # @return [Hash] this message as a Hash.
+      def to_h
+        h = { 'type' => type, 'args' => @args }
+        if login_request?
+          h['login'] = @auth[:login]
+          h['password'] = @auth[:password]
+        elsif session_request? || response?
+          h['session_id'] = @auth[:session_id]
+        end
+
+        h
+      end
+
+      # Hide sensitive information when debugging
+      def inspect
+        if login_request?
+          inspect_login_request
+        elsif session_request? || response?
+          inspect_session_request_or_response
+        else
+          raise 'WTFBBQ?!???1!11!'
+        end
+      end
+
+      # Serialize this message to JSON.
+      #
+      # @return [String] JSON data.
+      def serialize
+        to_h.to_json
+      end
+
+      class << self
+        attr_reader :type
+        attr_reader :request
+        attr_reader :registry
+        attr_reader :arg_names
+
+        # Declare message type and direction (request or response).
+        def message_type(name, request: nil, response: nil)
+          @type = name
+          if (request && response) || (!request && !response)
+            raise 'Is it a request or a response type?!?'
+          end
+
+          @request = !!request
+        end
+
+        # Declare an argument to this message type.
+        def arg(name)
+          @arg_names ||= []
+          @arg_names << name.to_s
+          define_method(name) do
+            @args[name.to_s]
+          end
+        end
+
+        # Create a new message of the given type
+        def for_type(name, args, auth)
+          klass = @registry[name.to_sym]
+          raise "unknown message type #{name.inspect}" unless klass
+
+          klass.new(args, auth)
+        end
+
+        # True if message type "name" is known.
+        def type?(name)
+          @registry.key?(name.to_sym)
+        end
+
+        # List of known types.
+        def types
+          @registry.types
+        end
+
+        # Parse message.
+        def parse(str)
+          data = JSON.parse(str)
+          type = data.delete('type').to_sym
+          args = data.delete('args').transform_keys(&:to_s)
+          auth = data.transform_keys(&:to_sym)
+          for_type(type, args, auth)
+        rescue JSON::ParserError
+          raise UnparsableResponse
+        end
+
+        # Register new message type.
+        def register(klass)
+          @registry ||= {}
+          unless klass.respond_to?(:type) && klass.respond_to?(:request)
+            raise "#{klass} is not a subclass of #{self}"
+          end
+
+          if @registry.key?(klass.type)
+            message_type = subclass.type
+            old_klass = @registry[message_type]
+            raise "duplicate message type #{message_type} in #{klass}, " \
+                  "already defined in #{old_klass}"
+          end
+          @registry[klass.type] = klass
+        end
+      end
+
+      private
+
+      def check_auth!(opts)
+        return opts if response?
+        return opts if opts.key?(:login) && opts.key?(:password)
+        return opts if opts.key?(:session_id)
+
+        raise RequestMissesAuthData
+      end
+
+      def check_args!(raw_args)
+        args = self.class.arg_names.to_h { |name| [name, raw_args[name]] }
+        missing = args.select { |_, v| v.nil? }.keys
+        unless missing.empty?
+          raise MissingMessageArgument.new(missing.inspect, type)
+        end
+
+        args
+      end
+
+      def inspect_login_request
+        base_inspect(
+          ['@login=%<login>s', '@password="******"'],
+          login: @auth[:login].inspect
+        )
+      end
+
+      def inspect_session_request_or_response
+        base_inspect(['@session_id=******'])
+      end
+
+      def base_inspect(fmt_parts, **fmt_args)
+        begin_fmt = ["#<#{self.class}:%<id>x", '@type=%<type>s']
+        end_fmt = ['@args=%<args>s>']
+        fmt = (begin_fmt + fmt_parts + end_fmt).join(' ')
+        args = fmt_args.merge(
+          id: object_id, type: type.inspect, args: @args.inspect
+        )
+        format(fmt, **args)
+      end
+    end
+
+    class << self
+      # Register new message type.
+      def register_all_message_types
+        constants(false).each do |const|
+          klass = const_get(const)
+          next unless klass.respond_to?(:superclass) && klass.superclass == Base
+
+          Base.register(klass)
+        end
+      end
+    end
+  end
+end

data/lib/kstor/message/error.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'kstor/message/base'
+
+module KStor
+  module Message
+    # Error response.
+    class Error < Base
+      message_type :error, response: true
+
+      arg :code
+      arg :message
+    end
+  end
+end

data/lib/kstor/message/group_create.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'kstor/message/base'
+
+module KStor
+  module Message
+    # Request to create a group of users.
+    class GroupCreate < Base
+      message_type :group_create, request: true
+
+      arg :name
+    end
+  end
+end

data/lib/kstor/message/group_created.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'kstor/message/base'
+
+module KStor
+  module Message
+    # Response for group created.
+    class GroupCreated < Base
+      message_type :group_created, response: true
+
+      arg :group_id
+      arg :group_name
+      arg :group_pubk
+    end
+  end
+end

data/lib/kstor/message/ping.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'kstor/message/base'
+
+module KStor
+  module Message
+    # Ping server.
+    class Ping < Base
+      message_type :ping, request: true
+
+      arg :payload
+    end
+  end
+end

data/lib/kstor/message/pong.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'kstor/message/base'
+
+module KStor
+  module Message
+    # Ping response.
+    class Pong < Base
+      message_type :pong, response: true
+
+      arg :payload
+    end
+  end
+end

data/lib/kstor/message/secret_create.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'kstor/message/base'
+
+module KStor
+  module Message
+    # Request to create a secret.
+    class SecretCreate < Base
+      message_type :secret_create, request: true
+
+      arg :meta
+      arg :group_ids
+      arg :plaintext
+    end
+  end
+end

data/lib/kstor/message/secret_created.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'kstor/message/base'
+
+module KStor
+  module Message
+    # Response for secret created.
+    class SecretCreated < Base
+      message_type :secret_created, response: true
+
+      arg :secret_id
+    end
+  end
+end

data/lib/kstor/message/secret_delete.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'kstor/message/base'
+
+module KStor
+  module Message
+    # Request to delete a secret.
+    class SecretDelete < Base
+      message_type :secret_delete, request: true
+
+      arg :secret_id
+    end
+  end
+end

data/lib/kstor/message/secret_deleted.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'kstor/message/base'
+
+module KStor
+  module Message
+    # Response for secret deleted.
+    class SecretDeleted < Base
+      message_type :secret_deleted, response: true
+
+      arg :secret_id
+    end
+  end
+end

data/lib/kstor/message/secret_list.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'kstor/message/base'
+
+module KStor
+  module Message
+    # Response for secret search.
+    class SecretList < Base
+      message_type :secret_list, response: true
+
+      arg :secrets
+    end
+  end
+end

data/lib/kstor/message/secret_search.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'kstor/message/base'
+
+module KStor
+  module Message
+    # Request to search secrets.
+    class SecretSearch < Base
+      message_type :secret_search, request: true
+
+      arg :meta
+    end
+  end
+end

data/lib/kstor/message/secret_unlock.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'kstor/message/base'
+
+module KStor
+  module Message
+    # Request to decrypt a secret.
+    class SecretUnlock < Base
+      message_type :secret_unlock, request: true
+
+      arg :secret_id
+    end
+  end
+end

data/lib/kstor/message/secret_update_meta.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'kstor/message/base'
+
+module KStor
+  module Message
+    # Request to update secret metadata.
+    class SecretUpdateMeta < Base
+      message_type :secret_update_meta, request: true
+
+      arg :meta
+      arg :secret_id
+    end
+  end
+end

data/lib/kstor/message/secret_update_value.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'kstor/message/base'
+
+module KStor
+  module Message
+    # Request to update secret value.
+    class SecretUpdateValue < Base
+      message_type :secret_update_value, request: true
+
+      arg :plaintext
+      arg :secret_id
+    end
+  end
+end

data/lib/kstor/message/secret_updated.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'kstor/message/base'
+
+module KStor
+  module Message
+    # Response for secret updated.
+    class SecretUpdated < Base
+      message_type :secret_updated, response: true
+
+      arg :secret_id
+    end
+  end
+end

data/lib/kstor/message/secret_value.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'kstor/message/base'
+
+module KStor
+  module Message
+    # Response for secret unlock.
+    class SecretValue < Base
+      message_type :secret_value, response: true
+
+      arg :id
+      arg :value_author
+      arg :metadata_author
+      arg :metadata
+      arg :plaintext
+      arg :groups
+
+      # Create a new secret-value response.
+      #
+      # @option opts [Integer] :id ID of secret
+      # @option opts [Hash] :value_author info on user that created secret value
+      # @option opts [Hash] :metadata_author info on user that created secret
+      #   metadata
+      # @option opts [Hash] :metadata metadata of this secret
+      # @option opts [String] :plaintext decrypted value of secret
+      # @option opts [Array[Hash]] :groups list of groups that can decrypt this
+      #   secret
+      # @param opts [Hash[Symbol, String]] common request options
+      def initialize(**opts)
+        super(**opts)
+        opts.delete(:group_id)
+      end
+    end
+  end
+end