relp 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 3c892d37fbb5525fd7a3c19f19b81528792c0ab2
+  data.tar.gz: 89bf3ac784ede6f01be3ae2a9d97dc3352ecefd5
+SHA512:
+  metadata.gz: 1bfc8c082854df95a56dfc5cf12c72c8f299e5a8285f127aaec3caf074c7b9777177fd0875b62edc5651698b0744bd51987fe0c527b3a534af160c83b4575e0a
+  data.tar.gz: 5de5ee3efb069ddd01dcf6ca9885a5ae94b4199181d95446eb3fed9387afe2b1f8e06ecf262b6908948a8f49e32591a398eb7e4895533d9cf85e05d97500dca7

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 dhlavac
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,77 @@
+# RELP
+
+This library contains native implementation of [RELP protocol](http://www.rsyslog.com/doc/relp.html) in ruby. At the moment only server-side
+is properly implemented and (to some extent) tested.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'relp'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install relp
+
+## Usage
+
+### Server
+
+To run server just creat instance of `Relp::RelpServer.new(host, port, logger = nil, callback)`
+and than call method run on instance of server e.g. `server.run`
+
+`host` 
+  * This is a required setting.
+  * Value type is string
+  * There is no default value for this setting.
+  * Specifies address you want to bind to, use "0.0.0.0" to bind to any address
+
+
+
+`port` 
+
+  * This is a required setting.
+  * Value type is number
+  * There is no default value for this setting.
+  * Sets on which port you want to listen for incoming RELP connections
+
+
+`logger`
+  
+  * This is optional setting
+  * Value type is logger object
+  * If is not set - default is `Logger.new(STDOUT)` with all levels of logging
+ 
+`callback`
+  * This is a required setting.
+  * Method you want to be executed upon successfully accepted message, it has only one :string parameter, which is message itself.
+  
+  ####Important Methods
+  * `run` Start connceting clients
+  *  `server_shutdown` Close connection to all clients and shutdown server
+
+### Client
+
+Coming soon.
+
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. 
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/dhlavac/RELP.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,11 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+desc "Run Tests"
+task :default => :test

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "relp"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/relp.rb

@@ -0,0 +1,4 @@
+require 'relp/server'
+
+module Relp
+end

data/lib/relp/client.rb

@@ -0,0 +1,4 @@
+require 'socket'
+
+#TODO client side
+

data/lib/relp/exceptions.rb

@@ -0,0 +1,16 @@
+module Relp
+  class RelpProtocolError < StandardError
+  end
+
+  class ConnectionClosed < RelpProtocolError
+  end
+
+  class ConnectionRefused < RelpProtocolError
+  end
+
+  class FrameReadException < RelpProtocolError
+  end
+
+  class InvalidCommand < RelpProtocolError
+  end
+end

data/lib/relp/relp_protocol.rb

@@ -0,0 +1,58 @@
+require 'relp/exceptions'
+require 'socket'
+module Relp
+  class RelpProtocol
+    @@relp_version = '0'
+    @@relp_software = 'librelp,1.2.13,http://librelp.adiscon.com'
+    def frame_write(socket, frame)
+      raw_data=[
+          frame[:txnr],
+          frame[:command],
+          frame[:message]
+      ].join(' ')
+      @logger.debug "Writing Frame #{frame.inspect}"
+      begin
+        socket.write(raw_data)
+      rescue Errno::EPIPE,IOError,Errno::ECONNRESET
+        raise Relp::ConnectionClosed
+      end
+    end
+    # Read socket and return Relp frame information in hash
+    def frame_read(socket)
+      begin
+        socket_content = socket.read_nonblock(4096)
+        frame = Hash.new
+        if match = socket_content.match(/(^[0-9]+) ([\S]*) (\d+)([\s\S]*)/)
+          frame[:txnr], frame[:command], frame[:data_length], frame[:message] = match.captures
+          frame[:message].lstrip! #message could be empty
+        else
+          raise raise Relp::FrameReadException.new('Problem with reading RELP frame')
+        end
+        @logger.debug "Reading Frame #{frame.inspect}"
+      rescue IOError
+        @logger.error 'Problem with reading RELP frame'
+        raise Relp::FrameReadException.new 'Problem with reading RELP frame'
+      rescue Errno::ECONNRESET
+        @logger.error 'Connection reset'
+        raise Relp::ConnectionClosed.new 'Connection closed'
+      end
+      is_valid_command(frame[:command])
+
+      return frame
+    end
+
+  private
+    # Check if command is one of valid commands if not raise exception
+    def is_valid_command(command)
+      valid_commands = ["open", "close", "rsp", "syslog"]
+      if !valid_commands.include?(command)
+        @logger.error 'Invalid RELP command'
+        raise Relp::InvalidCommand.new('Invalid command')
+      end
+    end
+    # Parse information from message and crate new hash (symbol => value) e.g. (:version => 0)
+    def extract_message_information(message)
+      informations = Hash[message.scan(/^(.*)=(.*)$/).map { |(key, value)| [key.to_sym, value] }]
+    end
+  end
+end

data/lib/relp/server.rb

@@ -0,0 +1,159 @@
+require 'relp/relp_protocol'
+require 'logger'
+require 'thread'
+
+module Relp
+  class RelpServer < RelpProtocol
+    def initialize(host, port, logger = nil, callback)
+      @logger = logger
+      @logger = Logger.new(STDOUT) if logger.nil?
+      @socket_list = Array.new
+      @callback = callback
+      @required_command = 'syslog'
+
+      begin
+        @server = TCPServer.new(host, port)
+        @logger.info "Starting #{self.class} on %s:%i" % @server.local_address.ip_unpack
+      rescue Errno::EADDRINUSE
+        @logger.error  "ERROR Could not start relp server: Port #{port} in use"
+        raise Errno::EADDRINUSE
+      end
+    end
+
+    def run
+      loop do
+        Thread.start(@server.accept) do |client_socket|
+          begin
+            @socket_list.push client_socket
+            remote_ip = client_socket.peeraddr[3]
+            @logger.info "New client connection coming from ip #{remote_ip}"
+            @logger.debug "New client started with object id=#{client_socket.object_id}"
+            connection_setup(client_socket)
+            while Thread.current.alive? do
+              ready = IO.select([client_socket], nil, nil, 10)
+              if ready
+                frame = communication_processing(client_socket)
+                return_message(frame[:message], (@callback))
+                ack_frame(client_socket,frame[:txnr])
+              end
+            end
+          rescue Relp::ConnectionClosed
+            @logger.info "Connection closed"
+          rescue Relp::RelpProtocolError => err
+            @logger.warn 'Relp error: ' + err.class.to_s + ' ' + err.message
+          ensure
+            server_close_message(client_socket) rescue nil
+            @logger.debug "Closing client socket=#{client_socket.object_id}"
+            @logger.info "Client from ip #{remote_ip} closed"
+          end
+        end
+      end
+    rescue Errno::EINVAL
+      # Swallowing exception here because it results even from properly closed socket
+      @logger.info "Socket close."
+    end
+
+    def return_message(message, callback)
+      list_of_messages = message.split(/\n+/)
+      list_of_messages.each do |msg|
+        remove = msg.split(": ").first + ": "
+        msg.slice! remove
+        callback.call(msg)
+      end
+    end
+
+    def create_frame(txnr, command, message)
+      frame = {:txnr => txnr,
+               :command => command,
+               :message => message
+      }
+    end
+
+    def ack_frame(socket, txnr)
+      frame = {:txnr => txnr,
+               :command => 'rsp',
+               :message => "6 200 OK\n"
+      }
+      frame_write(socket, frame)
+    end
+
+    def server_close_message(socket)
+      Hash.new frame = {:txnr => 0,
+               :command => 'serverclose',
+               :message => '0'
+      }
+      begin
+        frame_write(socket,frame)
+        @logger.debug 'Server close message send'
+        socket.close
+        @socket_list.delete socket
+      rescue Relp::ConnectionClosed
+      end
+    end
+
+    def server_shutdown
+      @socket_list.each do |client_socket|
+        if client_socket != nil
+	        server_close_message(client_socket)
+	      end
+      end
+      @logger.info 'Server shutdown'
+      @server.shutdown
+      @server = nil
+    end
+
+    private
+    def communication_processing(socket)
+      @logger.debug 'Communication processing'
+      frame = frame_read(socket)
+      if frame[:command] == 'syslog'
+        return frame
+      elsif frame[:command] == 'close'
+        response_frame = create_frame(frame[:txnr], "rsp", "0")
+        frame_write(socket,response_frame)
+        @logger.info 'Client send close message'
+        server_close_message(socket)
+        raise Relp::ConnectionClosed
+      else
+        server_close_message(socket)
+        raise Relp::RelpProtocolError, 'Wrong relp command'
+      end
+    end
+
+    def connection_setup(socket)
+      @logger.debug 'Connection setup'
+      begin
+        read_ready = IO.select([socket], nil, nil, 10)
+        if read_ready
+          frame = frame_read(socket)
+          @logger.debug 'Frame read complete, processing..'
+          if frame[:command] == 'open'
+            @logger.debug 'Client command open'
+            message_informations = extract_message_information(frame[:message])
+            if message_informations[:relp_version].empty?
+              @logger.warn 'Missing RELP version specification'
+              server_close_message(socket)
+              raise Relp::RelpProtocolError
+            elsif @required_command != message_informations[:commands]
+              @logger.warn 'Missing required commands - syslog'
+              Hash.new response_frame = create_frame(frame[:txnr], 'rsp', '20 500 Missing required command ' + @required_command)
+              frame_write(socket, response_frame)
+              server_close_message(socket)
+              raise Relp::InvalidCommand, 'Missing required command'
+            else
+              Hash.new response_frame = create_frame(frame[:txnr], 'rsp', '93 200 OK' + "\n" + 'relp_version=' +@@relp_version + "\n" + 'relp_software=' + @@relp_software + "\n" + 'commands=' + @required_command + "\n")
+              @logger.debug 'Sending response to client'
+              frame_write(socket, response_frame)
+            end
+          else
+            server_close_message(socket)
+            raise Relp::InvalidCommand, frame[:command] + ' expecting open command'
+          end
+        end
+      rescue Relp::RelpProtocolError
+        @logger.debug 'Timed out (no frame to read)'
+        server_close_message(socket)
+      end
+    end
+  end
+end

data/lib/relp/version.rb

@@ -0,0 +1,3 @@
+module Relp
+  VERSION = "0.1.0"
+end

data/test/RELP_test.rb

@@ -0,0 +1,9 @@
+require 'test_helper'
+
+class RELPTest < Minitest::Test
+  def test_that_it_has_a_version_number
+    refute_nil ::Relp::VERSION
+  end
+
+
+end

data/test/test_helper.rb

@@ -0,0 +1,4 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'relp'
+
+require 'minitest/autorun'

metadata

@@ -0,0 +1,102 @@
+--- !ruby/object:Gem::Specification
+name: relp
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Dominik Hlaváč Ďurán
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-06-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+description: If you want to receive or send message via RELP protocol you can use
+  this gem
+email:
+- dhlavacd@redhat.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/relp.rb
+- lib/relp/client.rb
+- lib/relp/exceptions.rb
+- lib/relp/relp_protocol.rb
+- lib/relp/server.rb
+- lib/relp/version.rb
+- test/RELP_test.rb
+- test/test_helper.rb
+homepage: https://github.com/dhlavac/Relp
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.2
+signing_key: 
+specification_version: 4
+summary: Ruby implementation of RELP (Reliable Event Logging Protocol) protocol.
+test_files:
+- test/RELP_test.rb
+- test/test_helper.rb