newrelic_rpm 3.7.2.190.beta → 3.7.2.192

data/test/multiverse/suites/mongo/helpers/mongo_replica_set.rb

@@ -0,0 +1,97 @@
+# encoding: utf-8
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+
+require 'fileutils'
+require 'timeout'
+require 'mongo'
+require File.expand_path(File.join(File.dirname(__FILE__), 'mongo_server'))
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', '..', 'helpers', 'file_searching'))
+
+class MongoReplicaSet
+  include Mongo
+
+  attr_accessor :servers, :client
+
+  def initialize
+    create_servers
+  end
+
+  def create_servers
+    self.servers = Array.new(3) { MongoServer.new(:replica) }
+  end
+
+  def start
+    self.servers.each { |server| server.start }
+    initiate
+
+    retry_on_exception(:exception => Mongo::ConnectionFailure, :tries => 100) do
+      self.client = MongoReplicaSetClient.new(server_connections, :read => :secondary)
+    end
+
+    self
+  end
+
+  def retry_on_exception(options)
+    exception = options.fetch(:exception, StandardError)
+    message = options[:message]
+    maximum_tries = options.fetch(:tries, 3)
+
+    tries = 0
+
+    begin
+      result = yield
+    rescue exception => e
+      if message
+        raise e unless e.message.include? message
+      end
+
+      sleep 0.1
+      tries += 1
+      retry unless tries > maximum_tries
+      raise e
+    end
+  end
+
+  def server_connections
+    self.servers.map do |server|
+      "localhost:#{server.port}"
+    end
+  end
+
+  def stop
+    self.servers.each { |server| server.stop }
+    self.client = nil
+  end
+
+  def running?
+    server_running_statuses = self.servers.map(&:running?).uniq
+    server_running_statuses.length == 1 && server_running_statuses.first
+  end
+
+  def status
+    return nil unless running?
+    self.servers.first.client['admin'].command( { 'replSetGetStatus' => 1 } )
+  rescue Mongo::OperationFailure => e
+    raise e unless e.message.include? 'EMPTYCONFIG'
+  end
+
+  def config
+    return unless running?
+
+    config = { :_id => 'multiverse', :members => [] }
+
+    self.servers.each_with_index do |server, index|
+      config[:members] << { :_id => index, :host => "localhost:#{server.port}" }
+    end
+
+    config
+  end
+
+  def initiate
+    return nil unless running?
+    self.servers.first.client['admin'].command( { 'replSetInitiate' => config } )
+  rescue Mongo::OperationFailure => e
+    raise e unless e.message.match(/already initialized/)
+  end
+end

data/test/multiverse/suites/mongo/helpers/mongo_replica_set_test.rb

@@ -0,0 +1,82 @@
+# encoding: utf-8
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+
+require File.expand_path(File.join(File.dirname(__FILE__), 'mongo_replica_set'))
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', '..', 'helpers', 'file_searching'))
+require 'test/unit'
+require 'mocha/setup'
+
+class MongoReplicaSetTest < Test::Unit::TestCase
+  def setup
+    @replica = MongoReplicaSet.new
+  end
+
+  def teardown
+    @replica.stop
+  end
+
+  def test_replica_is_created_with_three_servers
+    assert_equal 3, @replica.servers.length
+  end
+
+  def test_start_starts_all_servers
+    @replica.start
+    assert_equal [true], @replica.servers.map(&:running?).uniq
+  end
+
+  def test_stop_stops_all_servers
+    @replica.start
+    @replica.stop
+    assert_equal [false], @replica.servers.map(&:running?).uniq
+  end
+
+  def test_running_returns_true_for_started_replica_set
+    @replica.start
+    assert @replica.running?
+  end
+
+  def test_running_returns_false_for_stopped_replica_set
+    @replica.start
+    @replica.stop
+    refute @replica.running?
+  end
+
+  def test_status_does_not_raise_an_error_for_uninitiated_replica_set
+    @replica.start
+    assert_nothing_raised Mongo::OperationFailure do
+      @replica.status
+    end
+  end
+
+  def test_config_returns_nil_unless_servers_are_running
+    @replica.start
+    @replica.stop
+    assert_nil @replica.config
+  end
+
+  def test_started_replica_set_servers_have_unique_ports
+    @replica.start
+
+    assert_equal 3, @replica.servers.map(&:port).uniq.length
+  end
+
+  def test_config_includes_replica_set_member_strings_with_correct_ports
+    @replica.start
+
+    result = @replica.config[:members].map { |member| member[:host].split(':').last.to_i }
+    expected = @replica.servers.map(&:port)
+
+    assert_equal expected, result
+  end
+
+  def test_server_connections_returns_the_hosts_and_ports_for_the_servers
+    expected = ['localhost:27017', 'localhost:27018', 'localhost:27019']
+    assert_equal expected, @replica.server_connections
+  end
+
+  def test_start_creates_a_replica_set_client_connection
+    @replica.start
+    assert @replica.client
+  end
+end

data/test/multiverse/suites/mongo/helpers/mongo_server.rb

@@ -0,0 +1,239 @@
+# encoding: utf-8
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+
+require 'fileutils'
+require 'timeout'
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', '..', 'helpers', 'file_searching'))
+
+class MongoServer
+  extend NewRelic::TestHelpers::FileSearching
+
+  attr_reader :type
+  attr_accessor :port, :client
+
+  def initialize(type = :single)
+    @type = type
+    lock_port
+
+    make_directories
+  end
+
+  def self.count(type = :all)
+    count = `ps aux | grep mongo[d]`.split("\n").length
+    count -= Dir.glob(File.join(MongoServer.pid_directory, '*.pid')).length if type == :children
+    count
+  end
+
+  def self.tmp_directory
+    ENV["MULTIVERSE_TMP"] || File.join(gem_root, 'tmp')
+  end
+
+  def self.port_lock_directory
+    File.join(tmp_directory, 'ports')
+  end
+
+  def self.pid_directory
+    File.join(tmp_directory, 'pids')
+  end
+
+  def self.db_directory
+    File.join(tmp_directory, 'db')
+  end
+
+  def self.log_directory
+    File.join(tmp_directory, 'log')
+  end
+
+  def ping
+    return unless self.client
+    self.client['admin'].command( { 'ping' => 1 } )
+  end
+
+  def pingable?
+    ping == { "ok" => 1.0 }
+  end
+
+  def make_directories
+    directories = [
+      MongoServer.pid_directory,
+      MongoServer.db_directory,
+      MongoServer.log_directory,
+      db_path
+    ]
+
+    FileUtils.mkdir_p(directories)
+  end
+
+  def make_port_lock_directory
+    FileUtils.mkdir_p(MongoServer.port_lock_directory)
+  end
+
+  def port_lock_path
+    File.join(MongoServer.port_lock_directory, "#{self.port}.lock")
+  end
+
+  def pid_path
+    File.join(MongoServer.pid_directory, "#{self.port}-#{self.object_id}-#{Process.pid}.pid")
+  end
+
+  def db_path
+    File.join(MongoServer.db_directory, "data_#{self.port}")
+  end
+
+  def log_path
+    File.join(MongoServer.log_directory, "#{self.port}.log")
+  end
+
+  def start(wait_for_startup = true)
+    lock_port
+
+    unless running?
+      `#{startup_command}`
+
+      wait_until do
+        running?
+      end
+
+      if wait_for_startup
+        create_client
+        wait_until do
+          pingable?
+        end
+      end
+    end
+
+    self
+  end
+
+  def wait_until(seconds = 10)
+    Timeout.timeout(seconds) do
+      sleep 0.1 until yield
+    end
+  end
+
+  def startup_command
+    pid_file = "--pidfilepath #{pid_path}"
+    log_file = "--logpath #{log_path} "
+
+    dbpath = "--dbpath #{db_path}"
+    port_flag = "--port #{self.port}"
+    small_mongo = "--oplogSize 128 --smallfiles"
+    repl_set = "--fork --replSet multiverse"
+
+    base = "#{port_flag} #{pid_file} #{log_file} #{small_mongo} #{dbpath}"
+
+    if self.type == :single
+      "mongod #{base} &"
+    elsif self.type == :replica
+      "mongod #{repl_set} #{base} &"
+    end
+  end
+
+  def create_client(client_class = nil)
+    require 'mongo'
+    if defined? MongoClient
+      client_class ||= MongoClient
+    else
+      client_class ||= Mongo::Connection
+    end
+
+    begin
+      self.client = client_class.new('localhost', self.port, :connect_timeout => 10)
+    rescue Mongo::ConnectionFailure => e
+      raise e unless message = "Failed to connect to a master node at localhost:#{port}"
+      retry
+    end
+  end
+
+  def stop
+    if pid
+      begin
+        Process.kill('TERM', pid)
+      rescue Errno::ESRCH => e
+        # fine if we're already gone...
+      end
+
+      wait_until do
+        !running?
+      end
+
+      cleanup_files
+      self.client = nil
+    end
+
+    release_port
+    self
+  end
+
+  def running?
+    return false unless pid
+    Process.kill(0, pid) == 1
+  rescue Errno::ESRCH => e
+    false
+  end
+
+  def pid
+    File.read(pid_path).to_i if File.exists? pid_path
+  end
+
+  def next_available_port
+    used_ports = all_port_lock_files.map do |filename|
+      File.basename(filename, '.lock').to_i
+    end
+
+    if used_ports.empty?
+      27017
+    else
+      used_ports.sort.last + 1
+    end
+  end
+
+  def all_port_lock_files
+    Dir.glob(File.join(MongoServer.port_lock_directory, '*.lock'))
+  end
+
+  def lock_port
+    return if self.port
+
+    make_port_lock_directory
+
+    retry_on_exception(:exception => Errno::EEXIST, :tries => 10) do
+      self.port = next_available_port
+      File.new(port_lock_path, File::CREAT|File::EXCL)
+    end
+  end
+
+  def retry_on_exception(options)
+    exception = options.fetch(:exception, StandardError)
+    message = options[:message]
+    maximum_tries = options.fetch(:tries, 3)
+
+    tries = 0
+
+    begin
+      result = yield
+    rescue exception => e
+      if message
+        raise e unless e.message.include? message
+      end
+
+      sleep 0.1
+      tries += 1
+      retry unless tries > maximum_tries
+      raise e
+    end
+  end
+
+  def release_port
+    FileUtils.rm port_lock_path, :force => true
+    self.port = nil
+  end
+
+  # PID file needs to be cleaned up for our process checking logic
+  # DB needs to get cleaned up because it's massive
+  def cleanup_files
+    FileUtils.rm(pid_path)
+    FileUtils.rm_rf(db_path)
+  end
+end

data/test/multiverse/suites/mongo/helpers/mongo_server_test.rb

@@ -0,0 +1,176 @@
+# encoding: utf-8
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+
+require File.expand_path(File.join(File.dirname(__FILE__), 'mongo_server'))
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', '..', 'helpers', 'file_searching'))
+require 'test/unit'
+require 'mocha/setup'
+
+class MongoServerTest < Test::Unit::TestCase
+  include NewRelic::TestHelpers::FileSearching
+
+  def setup
+    @server = MongoServer.new
+  end
+
+  def teardown
+    @server.stop
+  end
+
+  def test_new_server_has_a_locked_port
+    assert File.exists?(@server.port_lock_path)
+  end
+
+  def test_creating_a_new_server_after_locking_port_uses_the_next_port
+    new_server = MongoServer.new
+    new_server_port = new_server.port
+    assert_equal @server.port + 1, new_server_port
+  ensure
+    new_server.stop
+  end
+
+  def test_pid_path_is_unique_for_two_servers
+    new_server = MongoServer.new
+    pid_path1 = @server.start.pid_path
+    pid_path2 = new_server.start.pid_path
+
+    refute_equal pid_path1, pid_path2
+  ensure
+    new_server.stop
+  end
+
+  def test_release_port_deletes_the_port_lock_file
+    path = @server.port_lock_path
+    assert File.exists?(path)
+    @server.release_port
+    refute File.exists?(path)
+  end
+
+  def test_all_port_lock_files_returns_all_file_names
+    File.write(@server.port_lock_path, @server.port)
+    result = @server.all_port_lock_files
+    assert_equal [@server.port_lock_path], result
+  end
+
+  def test_start_creates_a_mongod_process
+    @server.start
+    assert_equal 1, MongoServer.count
+  end
+
+  def test_starting_twice_only_creates_one_process
+    @server.start
+    @server.start
+    assert_equal 1, MongoServer.count
+  end
+
+  def test_server_is_running_after_start
+    @server.start
+    assert @server.running?
+  end
+
+  def test_stop_kills_a_mongod_process
+    @server.start
+    @server.stop
+    assert_equal 0, MongoServer.count
+  end
+
+  def test_stop_releases_port
+    @server.start
+    assert File.exists?(@server.port_lock_path)
+    @server.stop
+    refute File.exists?(@server.port_lock_path)
+  end
+
+  def test_stop_deletes_pid_file
+    @server.start
+    assert File.exists?(@server.pid_path)
+    @server.stop
+    refute File.exists?(@server.pid_path)
+  end
+
+  def test_pingable_returns_true_if_ping_is_ok
+    ok_status = { "ok" => 1.0 }
+    @server.stubs(:ping).returns ok_status
+    assert @server.pingable?
+  end
+
+  def test_server_start_times_out_if_it_isnt_pingable
+    @server.stubs(:pingable?).returns false
+
+    assert_raise Timeout::Error do
+      @server.start
+    end
+  end
+
+  def test_server_count_returns_the_number_of_mongo_processes
+    previous_server_count = `ps aux | grep mongo[d]`.split("\n").length
+    @server.start
+    assert_equal previous_server_count + 1, MongoServer.count
+  end
+
+  def test_server_count_children_returns_number_of_mongo_processes_started_by_mongo_server
+    test_pid_path = File.join(MongoServer.tmp_directory, 'test.pid')
+    `mongod --pidfilepath #{test_pid_path} &`
+    pid = File.read(test_pid_path).to_i
+    @server.start
+    result = MongoServer.count(:children)
+
+    assert_equal 1, result
+  ensure
+    Process.kill('TERM', pid)
+    FileUtils.rm(test_pid_path)
+  end
+
+  def test_replica_set_servers_include_fork_flag
+    replica = MongoServer.new(:replica)
+    assert_includes replica.startup_command, '--fork'
+    replica.stop
+  end
+
+  def test_replica_set_servers_include_repl_set
+    replica = MongoServer.new(:replica)
+    assert_includes replica.startup_command, '--replSet'
+    replica.stop
+  end
+
+  def test_starting_a_server_creates_a_client
+    @server.start
+    assert @server.client
+  end
+
+  def test_ping_returns_ok_for_started_server
+    @server.start
+    ok_status = { "ok" => 1.0 }
+    assert_equal ok_status, @server.ping
+  end
+
+  def test_stop_sets_client_to_nil
+    @server.start
+    @server.stop
+    assert_nil @server.client
+  end
+
+  def test_ping_returns_nil_for_stopped_server
+    @server.start
+    @server.stop
+    assert_nil @server.ping
+  end
+
+  def test_servers_in_different_threads_use_unique_ports
+    threads = []
+
+    20.times do
+      threads << Thread.new do
+        MongoServer.new
+      end
+    end
+
+    servers = threads.map(&:value)
+
+    assert_equal 20, servers.map(&:port).uniq.length
+  ensure
+    servers.each(&:stop)
+  end
+end
+