pact-mock_service 0.2.3 → 0.2.4

data/lib/pact/mock_service/cli/pidfile.rb

@@ -0,0 +1,97 @@
+require 'fileutils'
+
+module Pact
+  module MockService
+    class CLI < Thor
+
+      class Pidfile
+
+        attr_accessor :pid_dir, :name, :pid
+
+        def initialize options
+          @pid_dir = options[:pid_dir] || 'tmp/pids'
+          @name = options[:name] || default_name
+          @pid = options[:pid] || Process.pid
+        end
+
+        def file_exists?
+          File.exist?(pidfile_path)
+        end
+
+        def process_running?
+          process_exists? pid_from_file
+        end
+
+        def pidfile_path
+          File.join(pid_dir, name)
+        end
+
+        def pid_from_file
+          File.read(pidfile_path).to_i
+        end
+
+        def default_name
+          File.basename($0, File.extname($0)) + ".pid"
+        end
+
+        def process_exists? pid
+          Process.kill 0, pid
+          true
+        rescue  Errno::ESRCH
+          false
+        end
+
+        def file_exists_and_process_running?
+          file_exists? && process_running?
+        end
+
+        def can_start?
+          if file_exists? && process_running?
+            $stderr.puts "Server already running."
+            false
+          elsif file_exists?
+            $stderr.puts "WARN: PID file #{pidfile_path} already exists, but process is not running. Overwriting pidfile."
+            true
+          else
+            true
+          end
+        end
+
+        def write
+          FileUtils.mkdir_p pid_dir
+          File.open(pidfile_path, "w") { |file| file << pid }
+        end
+
+        def delete
+          FileUtils.rm pidfile_path
+        end
+
+        def waitpid
+          tries = 0
+          sleep_time = 0.1
+          while process_running? && tries < 100
+            sleep sleep_time
+            tries += 1
+          end
+          raise "Process #{pid_from_file} not stopped after {100 * sleep_time} seconds." if process_running?
+        end
+
+        def kill_process
+          if file_exists?
+            begin
+              `ps -ef | grep pact`
+              Process.kill 2, pid_from_file
+              waitpid
+              delete
+            rescue Errno::ESRCH
+              $stderr.puts "Process in PID file #{pidfile_path} not running. Deleting PID file."
+              delete
+            end
+          else
+            $stderr.puts "No PID file found at #{pidfile_path}, server probably not running. Use `ps -ef | grep pact` if you suspect the process is still running."
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pact/mock_service/cli.rb

@@ -1,100 +1,150 @@
-require 'find_a_port'
 require 'thor'
-require 'thwait'
 require 'webrick/https'
 require 'rack/handler/webrick'
 require 'fileutils'
+require 'pact/mock_service/server/wait_for_server_up'
+require 'pact/mock_service/cli/pidfile'
+require 'socket'
 
 module Pact
   module MockService
     class CLI < Thor
 
-      desc 'execute', "Start a mock service. If the consumer, provider and pact-dir options are provided, the pact will be written automatically on shutdown."
+      desc 'service', "Start a mock service. If the consumer, provider and pact-dir options are provided, the pact will be written automatically on shutdown."
       method_option :port, aliases: "-p", desc: "Port on which to run the service"
-      method_option :ssl, desc: "Use a self-signed SSL cert to run the service over HTTPS"
       method_option :log, aliases: "-l", desc: "File to which to log output"
+      method_option :ssl, desc: "Use a self-signed SSL cert to run the service over HTTPS"
       method_option :cors, aliases: "-o", desc: "Support browser security in tests by responding to OPTIONS requests and adding CORS headers to mocked responses"
       method_option :pact_dir, aliases: "-d", desc: "Directory to which the pacts will be written"
       method_option :consumer, desc: "Consumer name"
       method_option :provider, desc: "Provider name"
 
-      def execute
-        RunStandaloneMockService.call(options)
+      def service
+        require 'pact/mock_service/run'
+        Run.(options)
       end
 
-      default_task :execute
+      desc 'control', "Run a Pact mock service control server."
+      method_option :port, aliases: "-p", desc: "Port on which to run the service"
+      method_option :log_dir, aliases: "-l", desc: "File to which to log output"
+      method_option :pact_dir, aliases: "-d", desc: "Directory to which the pacts will be written"
+      method_option :ssl, desc: "Use a self-signed SSL cert to run the service over HTTPS"
+      method_option :cors, aliases: "-o", desc: "Support browser security in tests by responding to OPTIONS requests and adding CORS headers to mocked responses"
 
-    end
+      def control
+        require 'pact/mock_service/control_server/run'
+        ControlServer::Run.(options)
+      end
 
-    class RunStandaloneMockService
+      desc 'start', "Start a mock service. If the consumer, provider and pact-dir options are provided, the pact will be written automatically on shutdown."
+      method_option :port, aliases: "-p", default: '1234', desc: "Port on which to run the service"
+      method_option :log, aliases: "-l", desc: "File to which to log output"
+      method_option :ssl, desc: "Use a self-signed SSL cert to run the service over HTTPS"
+      method_option :cors, aliases: "-o", desc: "Support browser security in tests by responding to OPTIONS requests and adding CORS headers to mocked responses"
+      method_option :pact_dir, aliases: "-d", desc: "Directory to which the pacts will be written"
+      method_option :consumer, desc: "Consumer name"
+      method_option :provider, desc: "Provider name"
+      method_option :pid_dir, desc: "PID dir", default: 'tmp/pids'
 
-      def self.call options
-        new(options).call
+      def start
+        start_server(mock_service_pidfile) do
+          service
+        end
       end
 
-      def initialize options
-        @options = options
-      end
+      desc 'stop', "Stop a Pact mock service"
+      method_option :port, aliases: "-p", desc: "Port of the service to stop", default: '1234', required: true
+      method_option :pid_dir, desc: "PID dir, defaults to tmp/pids", default: "tmp/pids"
 
-      def call
-        require 'pact/consumer/mock_service/app'
+      def stop
+        mock_service_pidfile.kill_process
+      end
 
-        trap(:INT) { call_shutdown_hooks  }
-        trap(:TERM) { call_shutdown_hooks }
+      desc 'restart', "Start or restart a mock service. If the consumer, provider and pact-dir options are provided, the pact will be written automatically on shutdown."
+      method_option :port, aliases: "-p", default: '1234', desc: "Port on which to run the service"
+      method_option :log, aliases: "-l", desc: "File to which to log output"
+      method_option :ssl, desc: "Use a self-signed SSL cert to run the service over HTTPS"
+      method_option :cors, aliases: "-o", desc: "Support browser security in tests by responding to OPTIONS requests and adding CORS headers to mocked responses"
+      method_option :pact_dir, aliases: "-d", desc: "Directory to which the pacts will be written"
+      method_option :consumer, desc: "Consumer name"
+      method_option :provider, desc: "Provider name"
+      method_option :pid_dir, desc: "PID dir", default: 'tmp/pids'
 
-        Rack::Handler::WEBrick.run(mock_service, webbrick_opts)
+      def restart
+        restart_server(mock_service_pidfile) do
+          service
+        end
       end
 
-      private
+      desc 'control-start', "Start a Pact mock service control server."
+      method_option :port, aliases: "-p", desc: "Port on which to run the service", default: '1234'
+      method_option :log_dir, aliases: "-l", desc: "File to which to log output", default: "log"
+      method_option :ssl, desc: "Use a self-signed SSL cert to run the service over HTTPS"
+      method_option :cors, aliases: "-o", desc: "Support browser security in tests by responding to OPTIONS requests and adding CORS headers to mocked responses"
+      method_option :pact_dir, aliases: "-d", desc: "Directory to which the pacts will be written", default: "."
+      method_option :pid_dir, desc: "PID dir", default: "tmp/pids"
+
+      def control_start
+        start_server(control_server_pidfile) do
+          control
+        end
+      end
 
-      attr_reader :options
+      desc 'control-stop', "Stop a Pact mock service control server."
+      method_option :port, aliases: "-p", desc: "Port of control server to stop", default: "1234"
+      method_option :pid_dir, desc: "PID dir, defaults to tmp/pids", default: "tmp/pids"
 
-      def mock_service
-        @mock_service ||= Pact::Consumer::MockService.new(service_options)
+      def control_stop
+        control_server_pidfile.kill_process
       end
 
-      def call_shutdown_hooks
-        begin
-          mock_service.shutdown
-        rescue StandardError => e
-          $stderr.puts "Error writing pact on shutdown. #{e.class} - #{e.message}"
-          $stderr.puts e.backtrace.join("\n")
+      desc 'control-restart', "Start a Pact mock service control server."
+      method_option :port, aliases: "-p", desc: "Port on which to run the service", default: '1234'
+      method_option :log_dir, aliases: "-l", desc: "File to which to log output", default: "log"
+      method_option :ssl, desc: "Use a self-signed SSL cert to run the service over HTTPS"
+      method_option :cors, aliases: "-o", desc: "Support browser security in tests by responding to OPTIONS requests and adding CORS headers to mocked responses"
+      method_option :pact_dir, aliases: "-d", desc: "Directory to which the pacts will be written", default: "."
+      method_option :pid_dir, desc: "PID dir", default: "tmp/pids"
+
+      def control_restart
+        restart_server(control_server_pidfile) do
+          control
         end
-        Rack::Handler::WEBrick.shutdown
       end
 
-      def service_options
-        service_options = {
-          pact_dir: options[:pact_dir],
-          consumer: options[:consumer],
-          provider: options[:provider],
-          cors_enabled: options[:cors]
-        }
-        service_options[:log_file] = open_log_file if options[:log]
-        service_options
-      end
+      default_task :service
 
-      def open_log_file
-        FileUtils.mkdir_p File.dirname(options[:log])
-        log = File.open(options[:log], 'w')
-        log.sync = true
-        log
-      end
+      no_commands do
 
-      def webbrick_opts
-        opts = {
-          :Port => options[:port] || FindAPort.available_port,
-          :AccessLog => []
-        }
-        opts.merge!(ssl_opts) if options[:ssl]
-        opts
-      end
+        def control_server_pidfile
+          Pidfile.new(pid_dir: options[:pid_dir], name: control_pidfile_name)
+        end
+
+        def mock_service_pidfile
+          Pidfile.new(pid_dir: options[:pid_dir], name: mock_service_pidfile_name)
+        end
+
+        def mock_service_pidfile_name
+          "mock-service-#{options[:port]}.pid"
+        end
 
-      def ssl_opts
-        {
-          :SSLEnable => true,
-          :SSLCertName => [ %w[CN localhost] ]
-        }
+        def control_pidfile_name
+          "mock-service-control-#{options[:port]}.pid"
+        end
+
+        def start_server pidfile
+          require 'pact/mock_service/server/spawn'
+          Pact::MockService::Server::Spawn.(pidfile, options[:port]) do
+            yield
+          end
+        end
+
+        def restart_server pidfile
+          require 'pact/mock_service/server/respawn'
+          Pact::MockService::Server::Respawn.(pidfile, options[:port]) do
+            yield
+          end
+        end
       end
     end
   end

data/lib/pact/mock_service/control_server/app.rb

@@ -0,0 +1,42 @@
+require 'pact/consumer/mock_service/rack_request_helper'
+require 'pact/mock_service/control_server/require_pacticipant_headers'
+require 'pact/mock_service/control_server/index'
+require 'pact/mock_service/control_server/mock_services'
+require 'pact/mock_service/control_server/mock_service_creator'
+require 'rack'
+require 'rack/cascade'
+
+module Pact
+  module MockService
+    module ControlServer
+      class App
+
+        include Pact::Consumer::RackRequestHelper
+
+        def initialize options = {}
+          @mock_services = mock_services = MockServices.new([])
+          @app = Rack::Builder.new {
+            run Rack::Cascade.new([
+              Index.new,
+              Rack::Builder.new {
+                use RequirePacticipantHeaders
+                run Rack::Cascade.new([
+                  mock_services,
+                  MockServiceCreator.new(mock_services, options)
+                ])
+              }
+            ])
+          }
+        end
+
+        def call env
+          @app.call(env)
+        end
+
+        def shutdown
+          @mock_services.shutdown
+        end
+      end
+    end
+  end
+end

data/lib/pact/mock_service/control_server/delegator.rb

@@ -0,0 +1,55 @@
+# Delegates the incoming request that was sent to the control server
+# to the underlying MockService
+# if the X-Pact-Consumer and X-Pact-Provider headers match
+# the consumer and provider for this MockService.
+
+module Pact
+  module MockService
+    module ControlServer
+
+      class Delegator
+
+        HTTP_X_PACT_CONSUMER = 'HTTP_X_PACT_CONSUMER'.freeze
+        HTTP_X_PACT_PROVIDER = 'HTTP_X_PACT_PROVIDER'.freeze
+        LOCATION = 'X-Pact-Mock-Service-Location'.freeze
+        PACT_MOCK_SERVICE_HEADER = {'HTTP_X_PACT_MOCK_SERVICE' => 'true'}.freeze
+        NOT_FOUND_RESPONSE = [404, {}, []].freeze
+
+        def initialize app, base_url, consumer_name, provider_name
+          @app = app
+          @base_url = base_url
+          @consumer_name = consumer_name
+          @provider_name = provider_name
+          @location_header = {LOCATION => @base_url}.freeze
+        end
+
+        def call env
+          return NOT_FOUND_RESPONSE unless consumer_and_provider_headers_match?(env)
+          delegate env
+        end
+
+        def shutdown
+          @app.shutdown
+        end
+
+        private
+
+        def consumer_and_provider_headers_match? env
+          env[HTTP_X_PACT_CONSUMER] == @consumer_name && env[HTTP_X_PACT_PROVIDER] == @provider_name
+        end
+
+        def delegate env
+          add_location_header_to_response(call_app(env))
+        end
+
+        def call_app env
+          @app.call(env.merge(PACT_MOCK_SERVICE_HEADER))
+        end
+
+        def add_location_header_to_response response
+          [response.first, response[1].merge(@location_header), response.last]
+        end
+      end
+    end
+  end
+end

data/lib/pact/mock_service/control_server/index.rb

@@ -0,0 +1,25 @@
+module Pact
+  module MockService
+    module ControlServer
+      class Index
+
+        HTTP_X_PACT_MOCK_SERVICE = 'HTTP_X_PACT_MOCK_SERVICE'
+        PATH_INFO = 'PATH_INFO'
+        INDEX_RESPONSE = [200, {'Content-Type' => 'text/plain'}, ['Control server running']].freeze
+        NOT_FOUND_RESPONSE = [404, {}, []].freeze
+
+        def call env
+          if is_index_request_with_mock_service_header? env
+            INDEX_RESPONSE
+          else
+            NOT_FOUND_RESPONSE
+          end
+        end
+
+        def is_index_request_with_mock_service_header? env
+          env[HTTP_X_PACT_MOCK_SERVICE] && env[PATH_INFO].chomp("/").size == 0
+        end
+      end
+    end
+  end
+end

data/lib/pact/mock_service/control_server/mock_service_creator.rb

@@ -0,0 +1,34 @@
+require 'pact/mock_service/spawn'
+require 'pact/mock_service/control_server/delegator'
+require 'find_a_port'
+require 'pact/mock_service/server/wait_for_server_up'
+
+# Create a new MockService on a random port and delegate the incoming request to it
+
+module Pact
+  module MockService
+    module ControlServer
+
+      class MockServiceCreator
+
+        attr_reader :options
+
+        def initialize mock_services, options
+          @mock_services = mock_services
+          @options = options
+        end
+
+        def call env
+          consumer_name = env['HTTP_X_PACT_CONSUMER']
+          provider_name = env['HTTP_X_PACT_PROVIDER']
+          port = FindAPort.available_port
+          mock_service = Pact::MockService::Spawn.(consumer_name, provider_name, port, options)
+          delegator = Delegator.new(mock_service, "http://localhost:#{port}", consumer_name, provider_name)
+          @mock_services.add(delegator)
+          response = delegator.call(env)
+          response
+        end
+      end
+    end
+  end
+end

data/lib/pact/mock_service/control_server/mock_services.rb

@@ -0,0 +1,26 @@
+require 'rack'
+require 'rack/cascade'
+
+module Pact
+  module MockService
+    module ControlServer
+      class MockServices < Rack::Cascade
+
+        def add app
+          mock_services << app
+          super
+        end
+
+        def shutdown
+          mock_services.each(&:shutdown)
+        end
+
+        private
+
+        def mock_services
+          @mock_services ||= []
+        end
+      end
+    end
+  end
+end

data/lib/pact/mock_service/control_server/require_pacticipant_headers.rb

@@ -0,0 +1,20 @@
+module Pact
+  module MockService
+    module ControlServer
+      class RequirePacticipantHeaders
+
+        def initialize app
+          @app = app
+        end
+
+        def call env
+          if env['HTTP_X_PACT_CONSUMER'] && env['HTTP_X_PACT_PROVIDER']
+            @app.call(env)
+          else
+            [500, {}, ["Please specify the consumer name and the provider name by setting the X-Pact-Consumer and X-Pact-Provider headers"]]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pact/mock_service/control_server/run.rb

@@ -0,0 +1,68 @@
+require 'pact/mock_service/control_server/app'
+
+module Pact
+  module MockService
+    module ControlServer
+      class Run
+
+        def self.call options
+          new(options).call
+        end
+
+        def initialize options
+          @options = options
+        end
+
+        def call
+          trap(:INT) { shutdown }
+          trap(:TERM) { shutdown }
+
+          # https://github.com/rack/rack/blob/ae78184e5c1fcf4ac133171ed4b47b0548cd9b44/lib/rack/handler/webrick.rb#L32
+          # Rack adapter for webrick uses class variable for the server which contains the port,
+          # so if we use it more than once in the same process, we lose the reference to the first
+          # server, and can't shut it down. So, keep a manual reference to the Webrick server, and
+          # shut it down directly rather than use Rack::Handler::WEBrick.shutdown
+          # Ruby!
+          Rack::Handler::WEBrick.run(control_server, webbrick_opts) do | server |
+            @webrick_server = server
+          end
+        end
+
+        private
+
+        attr_reader :options
+
+        def control_server
+          @control_server ||= Pact::MockService::ControlServer::App.new control_server_options
+        end
+
+        def shutdown
+          unless @shutting_down
+            @shutting_down = true
+            begin
+              @control_server.shutdown
+            ensure
+              @webrick_server.shutdown
+            end
+          end
+        end
+
+        def control_server_options
+          {
+            log_dir: options[:log_dir] || "log",
+            pact_dir: options[:pact_dir] || ".",
+            cors_enabled: options[:cors] || false,
+            ssl: options[:ssl]
+          }
+        end
+
+        def webbrick_opts
+          {
+            :Port => options[:port],
+            :AccessLog => []
+          }
+        end
+      end
+    end
+  end
+end

data/lib/pact/mock_service/run.rb

@@ -0,0 +1,81 @@
+require 'find_a_port'
+require 'pact/consumer/mock_service'
+
+module Pact
+  module MockService
+    class Run
+
+      def self.call options
+        new(options).call
+      end
+
+      def initialize options
+        @options = options
+      end
+
+      def call
+        require 'pact/consumer/mock_service'
+
+        trap(:INT) { call_shutdown_hooks  }
+        trap(:TERM) { call_shutdown_hooks }
+
+        Rack::Handler::WEBrick.run(mock_service, webbrick_opts)
+      end
+
+      private
+
+      attr_reader :options
+
+      def mock_service
+        @mock_service ||= begin
+          Pact::Consumer::MockService.new(service_options)
+        end
+      end
+
+      def call_shutdown_hooks
+        unless @shutting_down
+          @shutting_down = true
+          begin
+            mock_service.shutdown
+          ensure
+            Rack::Handler::WEBrick.shutdown
+          end
+        end
+      end
+
+      def service_options
+        service_options = {
+          pact_dir: options[:pact_dir],
+          consumer: options[:consumer],
+          provider: options[:provider],
+          cors_enabled: options[:cors]
+        }
+        service_options[:log_file] = open_log_file if options[:log]
+        service_options
+      end
+
+      def open_log_file
+        FileUtils.mkdir_p File.dirname(options[:log])
+        log = File.open(options[:log], 'w')
+        log.sync = true
+        log
+      end
+
+      def webbrick_opts
+        opts = {
+          :Port => options[:port] || FindAPort.available_port,
+          :AccessLog => []
+        }
+        opts.merge!(ssl_opts) if options[:ssl]
+        opts
+      end
+
+      def ssl_opts
+        {
+          :SSLEnable => true,
+          :SSLCertName => [ %w[CN localhost] ]
+        }
+      end
+    end
+  end
+end

data/lib/pact/mock_service/server/restart.rb

@@ -0,0 +1,20 @@
+require 'pact/mock_service/server/spawn'
+
+module Pact
+  module MockService
+    module Server
+      class Respawn
+
+        def self.call pidfile, port
+          if pidfile.file_exists_and_process_running?
+            pidfile.kill_process
+          end
+
+          Spawn.(pidfile, port) do
+            yield
+          end
+        end
+      end
+    end
+  end
+end