contrast-agent 3.10.2 → 3.13.0

data/lib/contrast/agent/socket_client.rb

@@ -1,128 +0,0 @@
-# Copyright (c) 2020 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
-# frozen_string_literal: true
-
-cs__scoped_require 'socket'
-cs__scoped_require 'uri'
-
-cs__scoped_require 'contrast/api/speedracer'
-cs__scoped_require 'contrast/api/tcp_socket'
-cs__scoped_require 'contrast/api/unix_socket'
-cs__scoped_require 'contrast/api/connection_status'
-cs__scoped_require 'contrast/components/interface'
-
-module Contrast
-  module Agent
-    # SocketClient acts as a interface between the agent and the service. It instantiates a
-    # service proxy and tracks the state of that proxy.
-    class SocketClient
-      include Contrast::Components::Interface
-
-      access_component :logging, :contrast_service, :app_context
-
-      attr_accessor :speedracer, :status
-
-      def initialize
-        @status = Contrast::Api::ConnectionStatus.new
-        @speedracer = Contrast::Api::Speedracer.new(init_connection)
-        @ensure_running = Mutex.new
-      end
-
-      def init_connection
-        if CONTRAST_SERVICE.use_tcp?
-          Contrast::Api::TcpSocket.new(CONTRAST_SERVICE.host, CONTRAST_SERVICE.port)
-        else
-          Contrast::Api::UnixSocket.new(CONTRAST_SERVICE.socket_path)
-        end
-      end
-
-      def service_unavailable?
-        speedracer.nil?
-      end
-
-      def connection_established?
-        status.connected?
-      end
-
-      # Attempt to send the passed message to SpeedRacer. If we're using bundled
-      # service config option, we must first start up the service. Afterwards, we
-      # must send agent startup messages no matter what the config options are.
-      #
-      # @param event [Contrast::Api::Dtm] One of the DTMs valid for the event
-      #   field of Contrast::Api::Dtm::Message
-      # @return [Array<Contrast::Api::Settings::AgentSettings>] the response from SpeedRacer or nil
-      #   if it failed to send or the service is unavailable.
-      def send_to_speedracer event
-        return if service_unavailable?
-
-        @ensure_running.synchronize do
-          if CONTRAST_SERVICE.use_bundled_service?
-            return unless start_or_restart
-          end
-          build_service_context unless status.startup_messages_sent?
-        end
-
-        logger.debug_with_time(event.cs__class.name) do
-          response = speedracer.send_one event
-          status.success!
-          response
-        end
-      rescue StandardError => e
-        status.failure!
-        logger.error(e, "Unable to send #{ event.cs__class } message #{ event.__id__ }.")
-        nil
-      end
-
-      private
-
-      def restart?
-        status.was_connected? && status.failed?
-      end
-
-      # Now that we know we're running with bundled service option, we can tell SpeedRacer that we're
-      # ready for it to be started up.
-      #
-      # @return [Boolean] true if the service is started, false if the service is still offline after
-      # we've attempted to start it up.
-      def start_or_restart
-        if restart?
-          logger.info(nil, 'Attempting to restart service.')
-          return speedracer.start_service
-        elsif !status.was_connected?
-          logger.info(nil, 'Attempting to start service.')
-          return speedracer.start_service
-        end
-
-        true
-      end
-
-      def build_service_context
-        agent_startup_msg = APP_CONTEXT.build_agent_startup_message
-        app_startup_msg = APP_CONTEXT.build_app_startup_message
-
-        # 1 initial attempt, + 3 potential retries.
-        # The agent-service-api REQUIREMENTS.md spec mandates this #.
-        4.times do
-          # TODO: RUBY-794 make Type & ID structured for parsing)
-          logger.debug("Immediately sending #{ agent_startup_msg.cs__class.name } event #{ agent_startup_msg.__id__ }.")
-          next unless (agent_response = speedracer.send_one(agent_startup_msg))
-
-          # Connection was successful
-          # TODO: RUBY-794 make Type & ID structured for parsing)
-          logger.debug("Immediately sending #{ app_startup_msg.cs__class.name } event #{ app_startup_msg.__id__ }.")
-          app_response = speedracer.send_one(app_startup_msg)
-          [agent_response, app_response].each do |msg|
-            Contrast::Utils::ServiceResponseUtil.process_response msg
-          end
-          status.success!
-          logger.debug(nil, 'Successfully sent startup messages to service.')
-          return
-        end
-
-        logger.error('Could not send agent startup message context')
-      rescue StandardError => e
-        logger.error(e, 'Could not build service context')
-        raise # re-raise the error to be caught by SocketClient#send_to_speedracer
-      end
-    end
-  end
-end

data/lib/contrast/api/connection_status.rb

@@ -1,49 +0,0 @@
-# Copyright (c) 2020 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
-# frozen_string_literal: true
-
-module Contrast
-  module Api
-    # Keeps track of the state of connections to the service.
-    class ConnectionStatus
-      def initialize
-        @last_success = nil
-        @last_failure = nil
-        @startup_messages_sent = false
-      end
-
-      # Whether we have sent startup message to the service. True after successfully
-      # sending startup messages to service and reset to false if we lose connection
-      # to the service.
-      def startup_messages_sent?
-        @startup_messages_sent
-      end
-
-      # A message was successfully sent to the service at some point
-      def was_connected?
-        @last_success
-      end
-
-      # The last message sent was successful
-      def connected?
-        @last_success && (@last_failure.nil? || @last_success > @last_failure)
-      end
-
-      # The last message sent was unsuccessful
-      def failed?
-        @last_failure && (@last_success.nil? || @last_failure > @last_success)
-      end
-
-      # The current state of the service is active with a successful message sent
-      def success!
-        @startup_messages_sent = true
-        @last_success = Time.now.to_f
-      end
-
-      # The service may be in some sort of error state
-      def failure!
-        @startup_messages_sent = false
-        @last_failure = Time.now.to_f
-      end
-    end
-  end
-end

data/lib/contrast/api/socket.rb

@@ -1,43 +0,0 @@
-# Copyright (c) 2020 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
-# frozen_string_literal: true
-
-module Contrast
-  module Api
-    # Behavior common to all sockets used
-    # to communicate with the Contrast Service.
-    module Socket
-      SOCKET_MONITOR = Monitor.new
-
-      # Send a message across the socket and read back the response.
-      # @param marshaled [String] some marshaled form of data to be sent across
-      #   the socket. Typically an encoded form of Contrast::Api::Dtm::Message.
-      # @return [String] some marshalled form of data returned by the socket.
-      #   Typically an encoded form of Contrast::Api::Settings::AgentSettings.
-      def send_marshaled marshaled
-        SOCKET_MONITOR.synchronize do
-          socket = new_socket
-
-          # write message length
-          len = marshaled.length
-          socket.write([len].pack(Contrast::Api::ENCODING_STRING))
-
-          # write the entire message
-          socket.write(marshaled)
-          socket.close_write
-
-          # read the response length
-          len = socket.read(4).unpack1(Contrast::Api::ENCODING_STRING)
-
-          # read expected response to end
-          socket.read(len)
-        end
-      end
-
-      # Override this method to return a socket.
-      # Should be interface compatible with TCPSocket, UNIXSocket, etc.
-      def new_socket
-        raise NotImplementedError, 'This is abstract, override it.'
-      end
-    end
-  end
-end

data/lib/contrast/api/speedracer.rb

@@ -1,184 +0,0 @@
-# Copyright (c) 2020 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
-# frozen_string_literal: true
-
-cs__scoped_require 'contrast/utils/object_share'
-cs__scoped_require 'contrast/utils/os'
-cs__scoped_require 'contrast/components/interface'
-
-module Contrast
-  module Api
-    # This class acts as the interface for the communication between the Agent
-    # and the Service (SpeedRacer) as well as functions as a way for the Agent
-    # to manage the bundled Service.
-    class Speedracer
-      include Contrast::Components::Interface
-      access_component :logging, :contrast_service, :app_context
-
-      attr_reader :client_number,
-                  :host,
-                  :port,
-                  :socket,
-                  :connection,
-                  :messages_total
-
-      @instance_count = 0
-      @instance_mutex = Mutex.new
-
-      def self.next_client_number
-        @instance_mutex.synchronize do
-          @instance_count += 1
-        # Rollover things
-        rescue StandardError
-          @instance_count = 1
-        end
-      end
-
-      def self.read_only_instance_count
-        @instance_count.dup
-      end
-
-      def initialize connection
-        @client_number = Contrast::Api::Speedracer.next_client_number
-        @messages_total = 0
-
-        @pid = Process.pid.to_i
-        @ppid = Process.ppid.to_i
-        @connection = connection
-      end
-
-      # Allow for the start of a Service, but block so that we only attempt to
-      # start the service one try at a time in the case multiple threads are
-      # trying to send messages.
-      def start_service
-        zombie_check
-        service_starter_thread.join(5)
-        is_service_started = Contrast::Utils::OS.running?
-        logger.error(nil, 'The bundled service could not be started. The agent will not function properly.') unless is_service_started
-        is_service_started
-      end
-
-      # Wrap the given DTM in a Contrast::Api::Dtm::Message and send it to the
-      # Service for processing
-      #
-      # @param event [Contrast::Api::Dtm] One of the DTMs valid for the event field of
-      #   Contrast::Api::Dtm::Message
-      def send_one event
-        msg = build_message(event)
-        send_message(msg)
-      end
-
-      private
-
-      # check if there's a zombie service that exists, and wait on it if so.
-      # currently, this only happens when trying to initialize speedracer
-      def zombie_check
-        return if windows?
-
-        zombie_pid_list = Contrast::Utils::OS.zombie_pids
-        zombie_pid_list.each do |pid|
-          Process.wait(pid.to_i)
-        end
-      end
-
-      def windows?
-        @_windows = Contrast::Utils::OS.windows? if @_windows.nil?
-        @_windows
-      end
-
-      def determine_startup_options
-        return { out: :out, err: :err } if Contrast::Agent::FeatureState.instance.service_control[:logger_path] == 'STDOUT'
-
-        { out: File::NULL, err: File::NULL }
-      end
-
-      # This is a separate method so we can overwrite it globally in specs
-      def spawn_service
-        options = determine_startup_options
-        spawn 'contrast_service', options
-      end
-
-      def service_starter_thread
-        Contrast::Agent::Thread.new do
-          # Always check to see if it already started
-          unless Contrast::Utils::OS.running?
-            # Spawn the service process
-            spawn_service
-            # Block until service is running
-            sleep(0.1) until Contrast::Utils::OS.running?
-          end
-        end
-      end
-
-      # Wrap the given event in a Contrast::Api::Dtm::Message
-      #
-      # @param event [Contrast::Api::Dtm] One of the DTMs valid for the event field of
-      #   Contrast::Api::Dtm::Message
-      # @return Contrast::Api::Dtm::Message
-      def build_message event
-        message = base_message
-        case event
-        when Contrast::Api::Dtm::ServerActivity
-          message.server_activity = event
-        when Contrast::Api::Dtm::AgentStartup
-          message.agent_startup = event
-        when Contrast::Api::Dtm::ApplicationCreate
-          message.application_create = event
-        when Contrast::Api::Dtm::ApplicationUpdate
-          message.application_update = event
-        when Contrast::Api::Dtm::Activity
-          message.activity = event
-        when Contrast::Api::Dtm::HttpRequest
-          message.prefilter = event
-        when Contrast::Api::Dtm::HttpResponse
-          message.postfilter = event
-        when Contrast::Api::Dtm::Poll
-          message.poll = event
-        when Contrast::Api::Dtm::ObservedRoute
-          message.observed_route = event
-        else
-          logger.error("Unknown event type #{ event.cs__class.name } received. Unsure how to send.")
-          return
-        end
-        # TODO: RUBY-794 make ID structured for parsing
-        logger.debug("Wrapping the event #{ event.__id__ } in message #{ message.__id__ } (#{ message.pid }-#{ message.message_count }.")
-        message
-      end
-
-      def base_message
-        msg               = Contrast::Api::Dtm::Message.new
-        msg.app_name      = APP_CONTEXT.name
-        msg.app_path      = APP_CONTEXT.path
-        msg.app_language  = Contrast::Utils::ObjectShare::RUBY
-        msg.client_id     = APP_CONTEXT.client_id
-        msg.client_number = client_number
-        msg.client_total  = Contrast::Api::Speedracer.read_only_instance_count
-        msg.message_count = (@messages_total += 1)
-        msg.pid           = APP_CONTEXT.pid
-        msg.ppid          = APP_CONTEXT.ppid
-        msg
-      end
-
-      def send_message msg
-        # TODO: RUBY-794 make PID & Count structured for parsing
-        logger.debug "[m__id__:#{ msg.__id__ }]\tSending message #{ msg.pid }-#{ msg.message_count }."
-        to_service = Contrast::Api::Dtm::Message.encode(msg)
-        from_service = send_marshaled(to_service)
-        response = Contrast::Api::Settings::AgentSettings.decode(from_service)
-        # TODO: RUBY-794 make PID & Count structured for parsing
-        log_message = "[m__id__:#{ msg.__id__ }]\tReceived response: " \
-                      "#{ response ? response.__id__ : '[No Response]' } for " \
-                      "message #{ msg.pid }-#{ msg.message_count }."
-        logger.debug(log_message)
-        response
-      rescue StandardError => e
-        # TODO: RUBY-794 make PID & Count structured for parsing
-        logger.error(e, "[m__id__:#{ msg.__id__ }]\tSending failed for message #{ msg.pid }-#{ msg.message_count }.")
-        raise e # reraise to let SocketClient manage the connection
-      end
-
-      def send_marshaled marshaled
-        connection.send_marshaled(marshaled)
-      end
-    end
-  end
-end

data/lib/contrast/api/tcp_socket.rb

@@ -1,31 +0,0 @@
-# Copyright (c) 2020 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
-# frozen_string_literal: true
-
-cs__scoped_require 'contrast/api/socket'
-
-module Contrast
-  module Api
-    # This class allows us to create a TCP Socket to communicate to the Service
-    # (Speed Racer). Either it or the Unix Socket will be used, as determined
-    # by the configuration options set for Service communication.
-    class TcpSocket
-      include Contrast::Api::Socket
-
-      LOCAL_HOSTS = %w[localhost 127.0.0.1 0.0.0.0 ::1].cs__freeze
-
-      attr_reader :host, :port
-
-      # Create the socket
-      # @param host [String] socket target hostname or IP address
-      # @param port [String,Integer] socket target port
-      def initialize host, port
-        @host = host.to_s
-        @port = port.to_i
-      end
-
-      def new_socket
-        ::TCPSocket.new(host, port)
-      end
-    end
-  end
-end

data/lib/contrast/api/unix_socket.rb

@@ -1,25 +0,0 @@
-# Copyright (c) 2020 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
-# frozen_string_literal: true
-
-cs__scoped_require 'contrast/api/socket'
-
-module Contrast
-  module Api
-    # Implements a UNIX domain socket to connect to the Contrast Service.
-    class UnixSocket
-      include Contrast::Api::Socket
-
-      attr_reader :path
-
-      # Create the socket
-      # @param path [String] file path to a UNIX domain socket
-      def initialize path
-        @path = path
-      end
-
-      def new_socket
-        ::UNIXSocket.new(path)
-      end
-    end
-  end
-end