capistrano_sentinel 0.0.1

data/lib/capistrano_sentinel/classes/request_worker.rb

@@ -0,0 +1,128 @@
+require_relative '../helpers/actor'
+require_relative './websocket_client'
+require_relative '../helpers/application_helper'
+module CapistranoSentinel
+  # class that handles the rake task and waits for approval from the celluloid worker
+  class RequestWorker
+    include CapistranoSentinel::ApplicationHelper
+    #include CapistranoSentinel::Actor
+
+    attr_reader :client, :job_id, :action, :task,
+    :task_approved, :stdin_result, :executor
+
+
+    def work(options = {})
+      @options = options.stringify_keys
+      default_settings
+      socket_client.subscribe("#{CapistranoSentinel::RequestHooks::SUBSCRIPTION_PREFIX}#{@job_id}")
+    end
+
+    def wait_execution(name = task_name, time = 0.1)
+      #    info "Before waiting #{name}"
+      wait_for(name, time)
+      #  info "After waiting #{name}"
+    end
+
+    def wait_for(_name, time)
+      # info "waiting for #{time} seconds on #{name}"
+      sleep time
+      # info "done waiting on #{name} "
+    end
+
+    def socket_client
+      @socket_client = CapistranoSentinel::WebsocketClient.new(actor: self, enable_debug: ENV.fetch('debug_websocket', false), channel: nil, log_file_path: ENV.fetch('websocket_log_file_path', nil))
+    end
+
+    def default_settings
+      @stdin_result = nil
+      @job_id = @options['job_id']
+      @task_approved = false
+      @action = @options['action'].present? ? @options['action'] : 'invoke'
+      @task = @options['task']
+    end
+
+    def task_name
+      @task.respond_to?(:name) ? @task.name : @task
+    end
+
+    def task_data
+      {
+        action: @action,
+        task: task_name,
+        job_id: @job_id
+      }
+    end
+
+    def publish_to_worker(data)
+      socket_client.publish("#{CapistranoSentinel::RequestHooks::PUBLISHER_PREFIX}#{@job_id}", data)
+    end
+
+    def on_error(message)
+      log_to_file("RakeWorker #{@job_id} websocket connection error: #{message.inspect}")
+    end
+
+    def on_message(message)
+      return if message.blank? || !message.is_a?(Hash)
+      message = message.stringify_keys
+      log_to_file("RakeWorker #{@job_id} received after on message: #{message.inspect}")
+      if message['client_action'] == 'successful_subscription'
+        publish_subscription_successfull(message)
+      elsif message_is_about_a_task?(message)
+        task_approval(message)
+      elsif msg_for_stdin?(message)
+        stdin_approval(message)
+      else
+        show_warning "unknown message: #{message.inspect}"
+      end
+    end
+
+
+    def publish_subscription_successfull(message)
+      return unless message['client_action'] == 'successful_subscription'
+      log_to_file("Rake worker #{@job_id} received after publish_subscription_successfull: #{message}")
+      @successfull_subscription = true
+      publish_to_worker(task_data)
+    end
+
+    def wait_for_stdin_input
+      wait_execution until @stdin_result.present?
+      output = @stdin_result.clone
+      @stdin_result = nil
+      output
+    end
+
+    def stdin_approval(message)
+      return unless msg_for_stdin?(message)
+      if @job_id == message['job_id']
+        @stdin_result = message.fetch('result', '')
+      else
+        show_warning "unknown stdin_approval #{message.inspect}"
+      end
+    end
+
+    def task_approval(message)
+      return if !message_is_about_a_task?(message)
+      log_to_file("RakeWorker #{@job_id} #{task_name} task_approval : #{message.inspect}")
+      if @job_id == message['job_id'] && message['task'].to_s == task_name.to_s && message['approved'] == 'yes'
+        @task_approved = true
+      else
+        show_warning "unknown task_approval #{message.inspect} #{task_data}"
+      end
+    end
+
+    def on_close(message)
+      log_to_file("RakeWorker #{@job_id} websocket connection closed: #{message.inspect}")
+    end
+
+    def user_prompt_needed?(data)
+      question, default = get_question_details(data)
+      log_to_file("RakeWorker #{@job_id} tries to determine question #{data.inspect} #{question.inspect} #{default.inspect}")
+      return if question.blank? || @action != 'invoke'
+      publish_to_worker(action: 'stdout',
+      question: question,
+      default: default.present? ? default.delete('()') : '',
+      job_id: @job_id)
+      wait_for_stdin_input
+    end
+  end
+end

data/lib/capistrano_sentinel/classes/websocket/errors.rb

@@ -0,0 +1,13 @@
+module CapistranoSentinel
+  class WsError < StandardError
+  end
+
+  class ConnectError < WsError
+  end
+
+  class WsProtocolError < WsError
+  end
+
+  class BadMessageTypeError < WsError
+  end
+end

data/lib/capistrano_sentinel/classes/websocket_client.rb

@@ -0,0 +1,345 @@
+require_relative './websocket/errors'
+require_relative '../helpers/actor'
+require_relative '../helpers/application_helper'
+module CapistranoSentinel
+  class WebsocketClient
+    include CapistranoSentinel::AsyncActor
+    include CapistranoSentinel::ApplicationHelper
+
+    HOST = '0.0.0.0'
+    PORT = 1234
+    PATH = '/ws'
+
+    DEFAULT_OPTS = {
+      auto_pong: true,
+      read_buffer_size: 2048,
+      reconnect: false,
+      secure: false,
+      retry_time: 0
+    }
+
+    attr_reader :socket, :read_thread,  :protocol_version
+    attr_accessor :auto_pong, :on_ping, :on_error, :on_message
+
+    ##
+    # +host+:: Host of request. Required if no :url param was provided.
+    # +path+:: Path of request. Should start with '/'. Default: '/'
+    # +query+:: Query for request. Should be in format "aaa=bbb&ccc=ddd"
+    # +secure+:: Defines protocol to use. If true then wss://, otherwise ws://. This option will not change default port - it should be handled by programmer.
+    # +port+:: Port of request. Default: nil
+    # +opts+:: Additional options:
+    #   :reconnect - if true, it will try to reconnect
+    #   :retry_time - how often should retries happen when reconnecting [default = 1s]
+    # Alternatively it can be called with a single hash where key names as symbols are the same as param names
+    def initialize(opts)
+
+      # Initializing with a single hash
+      @options = CapistranoSentinel::WebsocketClient::DEFAULT_OPTS.merge(opts).symbolize_keys
+      @secure  = @options.delete :secure
+
+      @host    = @options.fetch(:host, nil) || CapistranoSentinel::WebsocketClient::HOST
+      @port    = @secure ? 443 : (@options.fetch(:port, nil) || CapistranoSentinel::WebsocketClient::PORT)
+      @path    = @options.fetch(:path, nil).to_s || CapistranoSentinel::WebsocketClient::PATH
+      @query   = @options.fetch(:query, nil).to_s
+
+      @actor ||=  @options.fetch(:actor, nil)
+      @channel ||= @options.fetch(:channel, nil)
+      raise "#{self}: Please provide an actor in the options list!!!" if @actor.blank?
+
+      @auto_pong   = @options.fetch(:auto_pong, true) || true
+      @closed      = false
+      @opened      = false
+
+      @on_open    = lambda {
+        log_to_file("#{@actor.class} websocket connection opened")
+        subscribe(@channel) if @channel.present?
+      }
+
+      @on_close   = lambda { |message|
+        log_to_file("#{@actor.class} dispatching on close  #{message}")
+        @actor.on_close(message)
+      }
+
+      @on_ping    = lambda { |message|
+        @actor.on_ping(message) if @actor.respond_to?(:on_ping)
+      }
+
+      @on_error   = lambda { |error|
+        @actor.on_error(message) if @actor.respond_to?(:on_error)
+      }
+
+      @on_message = lambda { |message|
+        message = parse_json(message)
+        log_to_file("#{@actor.class} received JSON  #{message}")
+        @actor.on_message(message)
+      }
+        connect
+    end
+
+    def is_windows?
+      RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/
+    end
+
+    # subscribes to a channel . need to be used inside the connect block passed to the actor
+    #
+    # @param [string] channel
+    #
+    # @return [void]
+    #
+    # @api public
+    def subscribe(channel, data = {})
+      log_to_file("#{@actor.class} tries to subscribe to channel  #{channel}")
+      send_action('subscribe', channel, data)
+    end
+
+    # publishes to a channel some data (can be anything)
+    #
+    # @param [string] channel
+    # @param [#to_s] data
+    #
+    # @return [void]
+    #
+    # @api public
+    def publish(channel, data)
+      send_action('publish', channel, data)
+    end
+
+    # unsubscribes current client from a channel
+    #
+    # @param [string] channel
+    #
+    # @return [void]
+    #
+    # @api public
+    def unsubscribe(channel)
+      send_action('unsubscribe', channel)
+    end
+
+    # unsubscribes all clients subscribed to a channel
+    #
+    # @param [string] channel
+    #
+    # @return [void]
+    #
+    # @api public
+    def unsubscribe_clients(channel)
+      send_action('unsubscribe_clients', channel)
+    end
+
+    # unsubscribes all clients from all channels
+    #
+    # @return [void]
+    #
+    # @api public
+    def unsubscribe_all
+      send_action('unsubscribe_all')
+    end
+
+
+    protected
+
+    def send_action(action, channel = nil, data = {})
+      data = data.is_a?(Hash) ? data : {}
+      publishing_data = { 'client_action' => action, 'channel' => channel, 'data' => data }.reject { |_key, value| value.blank? }
+      chat(publishing_data)
+    end
+
+    # method used to send messages to the webserver
+    # checks too see if the message is a hash and if it is it will transform it to JSON and send it to the webser
+    # otherwise will construct a JSON object that will have the key action with the value 'message" and the key message witth the parameter's value
+    #
+    # @param [Hash] message
+    #
+    # @return [void]
+    #
+    # @api private
+    def chat(message)
+      final_message = nil
+      if message.is_a?(Hash)
+        final_message = message.to_json
+      else
+        final_message = JSON.dump(action: 'message', message: message)
+      end
+      log_to_file("#{@actor.class} sends JSON #{final_message}")
+      send(final_message)
+    end
+
+    ##
+    #Send the data given by the data param
+    #if running on a posix system this uses Ruby's fork method to send
+    #if on windows fork won't be attempted.
+    #+data+:: the data to send
+    #+type+:: :text or :binary, defaults to :text
+    def send(data, type = :text)
+      pid = Thread.new do
+        log_to_file("#{@actor.class} calls send: #{data}")
+        do_send(data, type)
+      end
+    end
+
+    def connect
+      tcp_socket = ::TCPSocket.new(@host, @port)
+      tcp_socket.setsockopt(::Socket::SOL_SOCKET, ::Socket::SO_KEEPALIVE, true)
+      tcp_socket.setsockopt(::Socket::SOL_TCP, ::Socket::TCP_KEEPIDLE, 50)
+      tcp_socket.setsockopt(::Socket::SOL_TCP, ::Socket::TCP_KEEPINTVL, 50)
+      tcp_socket.setsockopt(::Socket::SOL_TCP, ::Socket::TCP_KEEPCNT, 10)
+
+      if @secure
+        @socket = ::OpenSSL::SSL::SSLSocket.new(tcp_socket)
+        @socket.connect
+      else
+        @socket = tcp_socket
+      end
+      perform_handshake
+    end
+
+    def reconnect
+      @closed = false
+      @opened = false
+
+      until @opened
+        begin
+          connect
+        rescue ::Errno::ECONNREFUSED => e
+          log_to_file("#{@actor.class} got ECONNREFUSED #{e.inspect} ")
+          sleep @options[:retry_time]
+        rescue => e
+          fire_on_error e
+        end
+      end
+    end
+
+    def perform_handshake
+      handshake = ::WebSocket::Handshake::Client.new({
+        :host   => @host,
+        :port   => @port,
+        :secure => @secure,
+        :path   => @path,
+        :query  => @query
+        })
+
+        @socket.write handshake.to_s
+        buf = ''
+
+        loop do
+          begin
+            if handshake.finished?
+              @protocol_version = handshake.version
+              @active = true
+              @opened = true
+              log_to_file("#{@actor.class} got handshake finished ")
+              init_messaging
+              fire_on_open
+              break
+            else
+              # do non blocking reads on headers - 1 byte at a time
+              buf.concat(@socket.read_nonblock(1))
+              # \r\n\r\n i.e. a blank line, separates headers from body
+              if idx = buf.index(/\r\n\r\n/m)
+                handshake << buf # parse headers
+
+                if handshake.finished? && !handshake.valid?
+                  fire_on_error(CapistranoSentinel::ConnectError.new('Server responded with an invalid handshake'))
+                  fire_on_close #close if handshake is not valid
+                  break
+                end
+              end
+            end
+          rescue ::IO::WaitReadable => e
+            #log_to_file("#{@actor.class} got WaitReadable #{e.inspect}")
+          rescue ::IO::WaitWritable => e
+            #log_to_file("#{@actor.class} got WaitWritable #{e.inspect}")
+            # ignored
+          end
+        end
+      end
+
+      # Use one thread to perform blocking read on the socket
+      def init_messaging
+        @read_thread = Thread.new { read_loop }
+      end
+
+      def read_loop
+        frame = ::WebSocket::Frame::Incoming::Client.new(:version => @protocol_version)
+        loop do
+          begin
+            frame << @socket.readpartial(@options[:read_buffer_size])
+            while message = frame.next
+              #"text", "binary", "ping", "pong" and "close" (according to websocket/base.rb)
+              determine_message_type(message)
+            end
+            fire_on_error CapistranoSentinel::WsProtocolError.new(frame.error) if frame.error?
+          rescue => e
+            log_to_file("#{@actor.class} crashed with #{e.inspect} #{e.backtrace}")
+            fire_on_error(e)
+            if @socket.closed? || @socket.eof?
+              @read_thread = nil
+              fire_on_close
+              break
+            end
+          end
+        end
+      end
+
+      def determine_message_type(message)
+        log_to_file("#{@actor.class} tries to dispatch message #{message.inspect}")
+        case message.type
+        when :binary, :text
+          fire_on_message(message.data)
+        when :ping
+          send(message.data, :pong) if @auto_pong
+          fire_on_ping(message)
+        when :pong
+          fire_on_error(CapistranoSentinel::WsProtocolError.new('Invalid type pong received'))
+        when :close
+          fire_on_close(message)
+        else
+          fire_on_error(CapistranoSentinel::BadMessageTypeError.new("An unknown message type was received #{message.inspect}"))
+        end
+      end
+
+      def do_send(data, type=:text)
+        frame = ::WebSocket::Frame::Outgoing::Client.new(:version => @protocol_version, :data => data, :type => type)
+        begin
+          @socket.write_nonblock frame
+          @socket.flush
+        rescue ::Errno::EPIPE => ce
+          fire_on_error(ce)
+          fire_on_close
+        rescue => e
+          fire_on_error(e)
+        end
+      end
+
+      def fire_on_ping(message)
+        log_to_file("#{@actor.class} tries to ping #{message.inspect}")
+        @on_ping.call(message) if @on_ping
+      end
+
+      def fire_on_message(message)
+        log_to_file("#{@actor.class} tries to fire_on_message #{message.inspect}")
+        @on_message.call(message) if @on_message
+      end
+
+      def fire_on_open
+        log_to_file("#{@actor.class} tries to on_open ")
+        @on_open.call() if @on_open
+      end
+
+      def fire_on_error(error)
+        log_to_file("#{@actor.class} tries to on_error with #{error.inspect} ")
+        @on_error.call(error) if @on_error
+      end
+
+      def fire_on_close(message = nil)
+        log_to_file("#{@actor.class} tries to fire_on_close with #{message.inspect} ")
+        @active = false
+        @closed = true
+        @on_close.call(message) if @on_close
+        @socket.close unless @socket.closed?
+
+        reconnect if @options[:reconnect]
+      end
+
+    end # class
+  end # module