rookout 0.1.0 → 0.1.5

data/lib/rookout/com_ws/agent_com_ws.rb

@@ -1,7 +1,5 @@
 module Rookout
   module ComWs
-    require "securerandom"
-    require "kontena-websocket-client"
     require "event_emitter"
     require "google/protobuf/well_known_types"
     require "concurrent"
@@ -10,14 +8,17 @@ module Rookout
     require_relative "../logger"
     require_relative "../user_warnings"
     require_relative "../exceptions"
+    require_relative "../utils"
 
     require_relative "../processor/rook_error"
 
     require_relative "../protobuf/messages_pb"
     require_relative "../protobuf/envelope_pb"
 
+    require_relative "websocket_client"
     require_relative "backoff"
     require_relative "information"
+    require_relative "pinger"
 
     class AgentComWs
       include EventEmitter
@@ -68,7 +69,11 @@ module Rookout
       end
 
       def wait_for_ready
-        @ready_event.wait Config.agent_com_timeout
+        is_finished = @ready_event.wait Config.agent_com_timeout
+        # We didn't finish - will keep trying in the background
+        raise Exceptions::RookCommunicationException unless is_finished
+
+        # We finished - raise if we failed
         raise @connection_error if @connection_error
       end
 
@@ -86,17 +91,15 @@ module Rookout
         while @running
           begin
             backoff.before_connection_attempt
-            Kontena::Websocket::Client.connect(@uri, **create_options) do |client|
-              register client
+            client = open_new_connection
 
-              Logger.instance.debug "WebSocket connected successfully"
-              @token_valid = true
-              backoff.after_connect
+            Logger.instance.debug "WebSocket connected successfully"
+            @token_valid = true
+            backoff.after_connect
 
-              connection_pump client
-            end
+            connection_pump client
           rescue Exception => e
-            if !@token_valid && e.is_a?(Kontena::Websocket::ProtocolError) && e.message.include?("403")
+            if !@token_valid && e.message.include?("403")
               @connection_error = Exceptions::RookInvalidToken.new @token
               @ready_event.set
             end
@@ -109,26 +112,15 @@ module Rookout
         end
       end
 
-      def create_options
-        headers = {
-          "User-Agent" => "RookoutAgent/#{Config.rookout_version}+#{Config.rookout_commit}"
-        }
-
-        headers["X-Rookout-Token"] = @token unless @token.nil?
-
-        # NOTE: WE DONT HAVE PROXY SUPPORT (YET) - THIS WILL PROBABLY REQUIRE FORKING KONTENA
-        { headers: headers,
-          connect_timeout: Config.agent_com_timeout,
-          open_timeout: Config.agent_com_timeout,
-          ping_interval: Config.agent_com_ping_interval,
-          ping_timeout: Config.agent_com_ping_timeout }
-      end
+      def open_new_connection
+        client = WebsocketClient.new @uri, @proxy, @token
+        client.connect
 
-      def register client
         Logger.instance.info "Registering agent with id #{@agent_id}"
-
         msg = Com::Rookout::NewAgentMessage.new agent_info: @info.pack
-        client.send wrap_in_envelope(msg)
+        client.send_frame wrap_in_envelope(msg)
+
+        client
       end
 
       ACCEPTED_MESSAGE_TYPES = [
@@ -140,11 +132,11 @@ module Rookout
       ].freeze
 
       def connection_pump client
-        on_outgoing_exit = proc { client.disconnect }
+        on_outgoing_exit = proc { client.close }
         send_thread = Thread.new { outgoing client, on_outgoing_exit }
         send_thread.name = "rookout-outgoing-thread"
 
-        client.read do |raw_message|
+        message_handler = proc do |raw_message|
           envelope = Com::Rookout::Envelope.decode raw_message.pack("c*")
 
           ACCEPTED_MESSAGE_TYPES.each do |klass|
@@ -153,6 +145,8 @@ module Rookout
           end
         end
 
+        client.connection_pump message_handler
+
         Logger.instance.debug "Incoming loop - socket disconnected"
 
         @pending_messages.push ExitMessage.new(send_thread)
@@ -160,7 +154,7 @@ module Rookout
       end
 
       def outgoing client, on_exit
-        loop do
+        Pinger.new(client, Config.agent_com_ping_interval, Config.agent_com_ping_timeout).repeat do
           begin
             msg = @pending_messages.pop true
           rescue ThreadError
@@ -174,7 +168,7 @@ module Rookout
             msg.event.set
           else
             begin
-              client.send msg
+              client.send_frame msg
             rescue RuntimeError
               @queue << msg
               break
@@ -184,6 +178,7 @@ module Rookout
       rescue Exception => e
         Logger.instance.exception "Outgoing thread failed", e
       ensure
+        Logger.instance.debug "Outgoing thread exiting"
         on_exit.call
       end
 
@@ -196,7 +191,7 @@ module Rookout
       end
 
       def reset_id
-        @agent_id = SecureRandom.uuid
+        @agent_id = Utils.uuid
         @output.agent_id = @agent_id
         @info.agent_id = @agent_id
       end

data/lib/rookout/com_ws/information.rb

@@ -14,7 +14,7 @@ module Rookout
       def initialize labels
         @agent_id = nil
         @labels = labels.clone
-        @labels["rookout_debug"] = "on"
+        @labels["rookout_debug"] = "on" if Config.debug
 
         @ip_addr = local_ip
 

data/lib/rookout/com_ws/output.rb

@@ -57,19 +57,13 @@ module Rookout
         return if @closing || !@agent_com
 
         @rule_status_update_bucket.if_available do
-          protobuf_error = nil
+          status = Com::Rookout::RuleStatusMessage.new agent_id: @agent_id,
+                                                       rule_id: rule_id,
+                                                       active: active
           if error
-            protobuf_error = Com::Rookout::Error.new message: error.messsage,
-                                                     type: error.type
-            protobuf_error.parameters.copy_from error.parameters
-            protobuf_error.exc.copy_from error.exc
-            protobuf_error.traceback.copy_from error.traceback
+            status.error = error.dumps
           end
 
-          status = Com::Rookout::RuleStatusMessage.new agent_id: @agent_id,
-                                                       rule_id: rule_id,
-                                                       active: active,
-                                                       error: protobuf_error
           @agent_com.add status
         end
       end

data/lib/rookout/com_ws/pinger.rb

@@ -0,0 +1,36 @@
+module Rookout
+  module ComWs
+    require_relative "../logger"
+
+    class Pinger
+      def initialize connection, interval, timeout
+        @interval = interval
+        @timeout = timeout
+        @connection = connection
+
+        @last_pong = Time.now
+        @last_ping = Time.now
+      end
+
+      def repeat
+        loop do
+          if Time.now - @last_ping > @interval
+            Logger.instance.debug "Sending Ping"
+            @last_ping = Time.now
+            @connection.ping Time.now.to_s do
+              Logger.instance.debug "Got Ping reply"
+              @last_pong = Time.now
+            end
+          end
+
+          if Time.now - @last_pong > @timeout
+            Logger.instance.debug "Ping timeout"
+            break
+          end
+
+          yield
+        end
+      end
+    end
+  end
+end

data/lib/rookout/com_ws/websocket_client.rb

@@ -0,0 +1,143 @@
+module Rookout
+  module ComWs
+    require "openssl"
+    require "websocket/driver"
+
+    require_relative "../config"
+    require_relative "../logger"
+    require_relative "../exceptions"
+
+    class WebsocketClient
+      def initialize url, proxy, token
+        @token = token
+        @connection = WebsocketConnection.new url, proxy
+        @driver = nil
+        @error = nil
+        @last_ping = nil
+      end
+
+      def connect
+        # TODO: add proxy support
+        @connection.connect
+        @driver = WebSocket::Driver.client @connection
+
+        headers.each do |key, value|
+          @driver.set_header key, value
+        end
+
+        @driver.on :error do |error|
+          @error = error
+        end
+
+        # Connect to the remote server
+        @driver.start
+        # TODO: ADD CONNECT TIMEOUT
+        while @driver.state == :connecting
+          recv_data = @connection.read_char
+          @driver.parse recv_data
+        end
+
+        raise Exceptions::RookWebsocketException, @error if @driver.state != :open
+      end
+
+      def connection_pump message_handler
+        @driver.on :message do |e|
+          message_handler.call e.data
+        end
+
+        until @driver.state == :closed
+          recv_data = @connection.read_char
+          @driver.parse recv_data
+        end
+      end
+
+      def send_frame msg
+        @driver.binary msg
+      end
+
+      def ping message, &callback
+        @driver.ping message, &callback
+      end
+
+      def close
+        return if @driver.nil?
+
+        @driver.close
+        @connection.close
+      end
+
+      private
+
+      def headers
+        result = {
+          "User-Agent" => "RookoutAgent/#{Config.rookout_version}+#{Config.rookout_commit}"
+        }
+
+        result["X-Rookout-Token"] = @token unless @token.nil?
+
+        result
+      end
+    end
+
+    class WebsocketConnection
+      def initialize url, proxy
+        @url = url
+        @proxy = proxy
+
+        @uri = URI.parse @url
+        @secure = %w[https wss].include? @uri.scheme
+
+        @socket = nil
+      end
+
+      def connect
+        if @secure
+          @socket = ssl_connect
+        else
+          @socket = tcp_connect
+        end
+      end
+
+      attr_reader :url
+
+      def read_char
+        @socket.getc
+      end
+
+      def write buffer
+        @socket << buffer
+      end
+
+      def close
+        return if @socket.nil?
+
+        @socket.close
+        @socket = nil
+      end
+
+      private
+
+      def tcp_connect
+        TCPSocket.new @uri.host,
+                      @uri.port || (@secure ? 443 : 80)
+      end
+
+      def ssl_connect
+        tcp_socket = tcp_connect
+
+        ctx = ::OpenSSL::SSL::SSLContext.new
+        ctx.min_version = ::OpenSSL::SSL::TLS1_2_VERSION
+        cert_store = ::OpenSSL::X509::Store.new
+        cert_store.set_default_paths
+        ctx.cert_store = cert_store
+
+        ssl_socket = ::OpenSSL::SSL::SSLSocket.new tcp_socket, ctx
+        ssl_socket.hostname = @uri.host
+        ssl_socket.sync_close = true
+        ssl_socket.connect
+
+        ssl_socket
+      end
+    end
+  end
+end

data/lib/rookout/commit.rb

@@ -0,0 +1,3 @@
+module Rookout
+  COMMIT = "2a847bf58dabb4d6abd2957f4c382256a4a467db".freeze
+end

data/lib/rookout/config.rb

@@ -1,5 +1,6 @@
 module Rookout
   require_relative "version"
+  require_relative "commit"
 
   module Config
     # Magic to allow for module variables to be easily accessible

data/lib/rookout/exceptions.rb

@@ -136,5 +136,45 @@ module Rookout
         super "No Rookout token was supplied. Make sure to pass the Rookout Token when starting the rook"
       end
     end
+
+    class RookInvalidOptions < ToolException
+      def initialize description
+        super description
+      end
+    end
+
+    class RookCrcMismatchException < ToolException
+      def initialize filepath, expected, calculated
+        super "Line CRC32s do not match! path: #{filepath}, expected: #{expected}, calculated:#{calculated}",
+              {
+                "filepath" => filepath,
+                "expected" => expected,
+                "calculated" => calculated
+              }
+      end
+    end
+
+    class RookLineMoved < ToolException
+      def initialize filepath, old_line_no, new_line_no
+        super "Line has moved! path: #{filepath}, original line no: #{old_line_no}, new line no: #{new_line_no}",
+              {
+                "filepath" => filepath,
+                "old_line_no" => old_line_no,
+                "new_line_no" => new_line_no
+              }
+      end
+    end
+
+    class RookCommunicationException < ToolException
+      def initialize
+        super "Failed to connect to the controller - will continue attempting in the background"
+      end
+    end
+
+    class RookWebsocketException < ToolException
+      def initialize error
+        super "Error from Websocket #{error}", { "error" => error }
+      end
+    end
   end
 end

data/lib/rookout/interface.rb

@@ -5,6 +5,7 @@ module Rookout
 
     require_relative "config"
     require_relative "exceptions"
+    include Exceptions
 
     def initialize
       @rook = nil
@@ -19,24 +20,21 @@ module Rookout
         require_relative "rookout_singleton"
 
         configure_logging options
-        labels = options[:labels] || parse_labels(ENV["ROOKOUT_LABELS"])
-        validate_labels labels
-
         configure_git options
 
-        com = configure_com options
-
-        async_start = true? ENV["ROOKOUT_ASYNC_START"]
-        fork = evaluate_flag options[:fork], "ROOKOUT_ENABLE_FORK"
-
-        print_config com, labels: labels, async_start: async_start, fork: fork if Config.debug
+        start_options = configure_start_options options
+        print_config start_options
 
         rook = RookoutSingleton.instance
-        rook.connect com[:token], com[:host], com[:port], com[:proxy], labels, async_start, fork
-
-        # TODO: ADD DETAILED PROCESSING FOR SPECIFIC ERRORS
+        rook.connect(**start_options)
+      rescue RookMissingToken, RookInvalidToken, RookInvalidOptions, RookVersionNotSupported => e
+        raise if throw_errors
+        STDERR.puts "[Rookout] Failed to start Rookout: #{e.message}"
+      rescue RookCommunicationException => e
+        raise if throw_errors
+        STDERR.puts "[Rookout] " + e.message
       rescue Exception => e
-        puts e.full_message if Config.debug
+        STDERR.puts e.full_message if Config.debug
         raise if throw_errors
       end
     end
@@ -59,7 +57,7 @@ module Rookout
     def configure_logging options
       if Config.debug
         log_to_stderr = true
-        log_level = "DEBUG"
+        log_level = :DEBUG
       else
         log_to_stderr = evaluate_flag options[:log_to_stderr], "ROOKOUT_LOG_TO_STDERR"
         log_level = options[:log_level] || ENV["ROOKOUT_LOG_FILE"]
@@ -77,16 +75,22 @@ module Rookout
       Config.user_git_commit = options[:git_commit] if options[:git_commit]
     end
 
-    def configure_com options
+    def configure_start_options options
       host = evaluate_config options[:host], "ROOKOUT_CONTROLLER_HOST", "wss://control.rookout.com"
       port = evaluate_config options[:port], "ROOKOUT_CONTROLLER_PORT", 443
       proxy = evaluate_config options[:proxy], "ROOKOUT_PROXY"
       token = evaluate_config options[:token], "ROOKOUT_TOKEN"
 
-      raise Exceptions::RookMissingToken if token.nil? && host == "wss://control.rookout.com"
+      raise RookMissingToken if token.nil? && host == "wss://control.rookout.com"
       verify_token token if token
 
-      { host: host, port: port, proxy: proxy, token: token }
+      labels = stringify_labels(options[:labels]) || parse_labels(ENV["ROOKOUT_LABELS"])
+      validate_labels labels
+
+      async_start = true? ENV["ROOKOUT_ASYNC_START"]
+      fork = evaluate_flag options[:fork], "ROOKOUT_ENABLE_FORK"
+
+      { host: host, port: port, proxy: proxy, token: token, labels: labels, async_start: async_start, fork: fork }
     end
 
     def evaluate_flag argument, env_var_name
@@ -104,6 +108,18 @@ module Rookout
       default
     end
 
+    def stringify_labels labels
+      return nil unless labels
+
+      stringified_labels = {}
+
+      labels.each do |label_name, label_value|
+        stringified_labels[label_name.to_s] = label_value.to_s
+      end
+
+      stringified_labels
+    end
+
     def parse_labels raw_labels
       labels = {}
       return labels if raw_labels.nil?
@@ -120,21 +136,22 @@ module Rookout
     def validate_labels labels
       labels.each do |label_name, _|
         if label_name.start_with? "$"
-          raise Exceptions::RookInvalidLabel, label_name
+          raise RookInvalidLabel, label_name
         end
       end
     end
 
     def verify_token token
-      raise Exceptions::RookInvalidOptions, "Rookout token should be a String" unless token.is_a? String
-      raise Exceptions::RookInvalidOptions, "Rookout token should be 64 characters" unless token.length == 64
-      raise Exceptions::RookInvalidOptions, "Rookout token must consist of only hexadecimal characters" unless
+      raise RookInvalidOptions, "Rookout token should be a String" unless token.is_a? String
+      raise RookInvalidOptions, "Rookout token should be 64 characters" unless token.length == 64
+      raise RookInvalidOptions, "Rookout token must consist of only hexadecimal characters" unless
           token.match(/^[0-9a-zA-Z]{0,64}$/)
     end
 
-    def print_config com, options
-      puts "[Rookout] Communication Options: #{com}"
-      puts "[Rookout] Other Options #{options}"
+    def print_config options
+      return unless Config.debug
+
+      puts "[Rookout] Start Options: #{options}"
     end
   end
 end