newrelic_rpm 4.1.0.333 → 4.2.0.334

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

@@ -1,97 +0,0 @@
-# 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
-      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

@@ -1,82 +0,0 @@
-# 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

@@ -1,241 +0,0 @@
-# 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} "
-    fork     = "--fork"
-
-    dbpath = "--dbpath #{db_path}"
-    port_flag = "--port #{self.port}"
-    small_mongo = "--oplogSize 128 --smallfiles"
-    repl_set = "--replSet multiverse"
-
-    base = "#{port_flag} #{fork} #{pid_file} #{log_file} #{small_mongo} #{dbpath}"
-
-    mongod_path = ENV['MONGOD_PATH'] || 'mongod'
-    if self.type == :single
-      "#{mongod_path} #{base}"
-    elsif self.type == :replica
-      "#{mongod_path} #{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
-        # 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
-    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
-      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

@@ -1,176 +0,0 @@
-# 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
-