mongolly 0.2.10 → 0.2.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0e5dfd7e55a93db2f0ab03b50b7676d97b25a212
-  data.tar.gz: 26304958d35572763588aeb6521f6f86037caa9f
+  metadata.gz: f0eff9f2f6fa9f6d84af21df7c18e5e5d5d245d6
+  data.tar.gz: 34f7bc7b32932fba31b23b5a59b860137f712492
 SHA512:
-  metadata.gz: 19cfd8db4e216c2789aeb4e4099ab7c1e6e7812631ee2c0f64b032cf0537cd9b871f9188b286d89f98258dab9e362c5fdfdb87f43c16172c1e5893a6ee8fba48
-  data.tar.gz: d9538c0a1fcd46158a1bee43a662174191347f8f0661316a896b3916326382095a411508fdb327682a87e1317009b794fab0b4d8f1dd92959cf93f6c25f98869
+  metadata.gz: 3b6a9a24534f3a0a02e82c89646b397a47b2ef7435677948b9765c5bf8ae2497cca6022b45df00c719f44006922269fad91ab051c1768b982894bbc28bf7186e
+  data.tar.gz: 1c76a9c0696fafe6321bf0d6e97efcb0a688860d0cefda2f51d34168ec4cea84af89f4cc38d833afc26622739b7acedae72787d1504b5aedeb41b763f707cc94

data/.rubocop.yml

@@ -0,0 +1,74 @@
+AllCops:
+  DisplayCopNames: true
+  DisplayStyleGuide: true
+  TargetRubyVersion: 2.2
+
+Style/AlignParameters:
+  EnforcedStyle: with_fixed_indentation
+
+Style/DotPosition:
+  EnforcedStyle: leading
+
+Style/Encoding:
+  Enabled: false
+
+Style/EmptyLinesAroundClassBody:
+  Enabled: false
+
+Style/ExtraSpacing:
+  Enabled: false
+
+Style/GlobalVars:
+  AllowedVariables: [$statsd, $rollout, $rails_rake_task]
+
+Style/FileName:
+  Enabled: false
+
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+
+Metrics/AbcSize:
+  Enabled: false
+
+Metrics/CyclomaticComplexity:
+  Enabled: false
+
+Metrics/MethodLength:
+  Enabled: false
+
+Metrics/LineLength:
+  Enabled: false
+
+Metrics/BlockLength:
+  Enabled: true
+  ExcludedMethods: ['describe', 'context']
+  Exclude:
+    - 'Rakefile'
+    - '**/*.rake'
+    - 'spec/**/*.rb'
+
+Lint/AssignmentInCondition:
+  Enabled: true
+
+Style/ClassAndModuleChildren:
+  Enabled: false
+
+Rails:
+  Enabled: true
+
+Rails/ActionFilter:
+  Enabled: false
+
+Rails/HttpPositionalArguments:
+  Enabled: false
+
+Rails/SkipsModelValidations:
+  Enabled: true
+  Exclude:
+    - 'spec/**/*.rb'
+
+Style/FrozenStringLiteralComment:
+  Enabled: true
+
+Performance/CaseWhenSplat:
+  Enabled: false

data/bin/mongolly

@@ -1,40 +1,41 @@
 #!/usr/bin/env ruby
-require 'thor'
-require 'yaml'
-require 'time'
-require 'mongolly'
+require "thor"
+require "yaml"
+require "time"
+require "mongolly"
 
 module Mongolly
   class Runner < Thor
-    class_option :config, :type => :string, aliases: '-c', default: '~/.mongolly', desc: 'Path to config file'
+    class_option :config, type: :string, aliases: "-c", default: "~/.mongolly", desc: "Path to config file"
 
     desc "backup", "Snapshots the Database EBS Volumes"
-    method_option :dry_run, type: :boolean, desc: 'Step through command without changes'
+    method_option :dry_run, type: :boolean, desc: "Step through command without changes"
     def backup
-      Shepherd.new({dry_run: options[:dry_run]}.merge(config)).backup
+      Shepherd.new({ dry_run: options[:dry_run] }.merge(config)).backup
     end
 
     desc "clean", "Removes old Database EBS Snapshots"
-    method_option :age, aliases: '-a', required: true
-    method_option :dry_run, type: :boolean, desc: 'Step through command without changes'
+    method_option :age, aliases: "-a", required: true
+    method_option :dry_run, type: :boolean, desc: "Step through command without changes"
     def clean
-      age = Time.parse(options[:age])
-      Shepherd.new({dry_run: options[:dry_run]}.merge(config)).cleanup(age)
+      age = Time.parse.utc(options[:age])
+      Shepherd.new({ dry_run: options[:dry_run] }.merge(config)).cleanup(age)
     end
 
-  private
+    private
+
     def config
       @config ||= read_config
     end
 
     def read_config
-      unless File.exists? config_path
+      unless File.exist? config_path
         seed_config
         exit 1
       end
 
       begin
-        cfg = YAML::load( File.read( config_path ) )
+        cfg = YAML.load(File.read(config_path))
       rescue e
         puts " ** Unable to read config at #{config_path}"
         raise e
@@ -50,16 +51,16 @@ module Mongolly
         db_password: nil,
         access_key_id: nil,
         secret_access_key: nil,
-        region: 'us-east-1',
-        log_level: 'info',
+        region: "us-east-1",
+        log_level: "info",
         mongo_start_command: nil,
         mongo_stop_command: nil,
         config_server_ssh_user: nil,
         config_server_ssh_keypath: nil
       }
 
-      File.open( config_path, "w" ) do |f|
-        f.write( empty_config.to_yaml )
+      File.open(config_path, "w") do |f|
+        f.write(empty_config.to_yaml)
       end
 
       puts " ** An empty configuration file has been written to #{config_path}."
@@ -70,13 +71,13 @@ module Mongolly
 
     def validated_config(cfg)
       %w(database access_key_id secret_access_key).each do |arg|
-        raise ArgumentError.new("#{arg} cannot be empty") if cfg[arg.to_sym].to_s.strip.empty?
+        raise ArgumentError, "#{arg} cannot be empty" if cfg[arg.to_sym].to_s.strip.empty?
       end
       cfg
     end
 
     def config_path
-      config_path ||= File.expand_path(options[:config])
+      @config_path ||= File.expand_path(options[:config])
     end
   end
 end

data/lib/mongolly.rb

@@ -1,11 +1,11 @@
-require 'mongolly/extensions/aws/ec2/instance'
-require 'mongolly/extensions/aws/ec2/instance_collection'
-require 'mongolly/extensions/bson/timestamp'
-require 'mongolly/extensions/mongo/mongo_client'
-require 'mongolly/extensions/mongo/mongo_replica_set_client'
+require "mongolly/extensions/aws/ec2/instance"
+require "mongolly/extensions/aws/ec2/instance_collection"
+require "mongolly/extensions/bson/timestamp"
+require "mongolly/extensions/mongo/mongo_client"
+require "mongolly/extensions/mongo/mongo_replica_set_client"
 
-require 'mongolly/version'
-require 'mongolly/shepherd'
+require "mongolly/version"
+require "mongolly/shepherd"
 
 module Mongolly
 end

data/lib/mongolly/extensions.rb

@@ -1,6 +1,5 @@
-require 'extensions/aws/ec2/instance'
-require 'extensions/aws/ec2/instance_collection'
-require 'extensions/bson/timestamp'
-require 'extensions/mongo/mongo_client'
-require 'extensions/mongo/mongo_replica_set_client'
-
+require "extensions/aws/ec2/instance"
+require "extensions/aws/ec2/instance_collection"
+require "extensions/bson/timestamp"
+require "extensions/mongo/mongo_client"
+require "extensions/mongo/mongo_replica_set_client"

data/lib/mongolly/extensions/aws/ec2/instance.rb

@@ -1,13 +1,13 @@
-require 'aws-sdk'
+require "aws-sdk"
 
 class AWS::EC2::Instance
 
   def volumes_with_tag(key)
     volumes = []
-    attachments.each do |name,attachment|
+    attachments.each do |_, attachment|
       next  unless attachment.status == :attached
       volume = attachment.volume
-      volumes << volume  if volume.status == :in_use && volume.tags.has_key?(key)
+      volumes << volume if volume.status == :in_use && volume.tags.key?(key)
     end
     volumes
   end

data/lib/mongolly/extensions/aws/ec2/instance_collection.rb

@@ -1,30 +1,31 @@
-require 'aws-sdk'
-require 'socket'
-require 'ipaddress'
+require "aws-sdk"
+require "socket"
+require "ipaddress"
 
 class AWS::EC2::InstanceCollection
 
-    def find_from_address(address, port = 27107)
-      ip_address = convert_address_to_ip(address, port)
+  def find_from_address(address, port = 27107) # rubocop:disable Style/NumericLiterals
+    ip_address = convert_address_to_ip(address, port)
 
-      instances = select do |instance|
-        instance.public_ip_address == ip_address || instance.private_ip_address == ip_address
-      end
-      raise error_class "InstanceNotFound"  if instances.length != 1
-
-      return instances.first
-    rescue SocketError
-      raise RuntimeError.new("Unable to determine IP address from #{address}:#{port}")
+    instances = select do |instance|
+      instance.public_ip_address == ip_address || instance.private_ip_address == ip_address
     end
+    raise error_class "InstanceNotFound"  if instances.length != 1
+
+    return instances.first
+  rescue SocketError
+    raise RuntimeError.new("Unable to determine IP address from #{address}:#{port}")
+  end
+
+  private
 
-private
   def convert_address_to_ip(address, port)
     return address if ::IPAddress.valid? address
 
     ip_addresses = ::Addrinfo.getaddrinfo(address, port, nil, :STREAM)
-    raise error_class "MultipleIpAddressFound"  if ip_addresses.length > 1
+    raise error_class "MultipleIpAddressFound" if ip_addresses.length > 1
 
-    return ip_addresses[0].ip_address
+    ip_addresses[0].ip_address
   end
 
 end

data/lib/mongolly/extensions/bson/timestamp.rb

@@ -1,4 +1,4 @@
-require 'mongo'
+require "mongo"
 
 class BSON::Timestamp
   include Comparable

data/lib/mongolly/extensions/mongo/mongo_client.rb

@@ -1,18 +1,19 @@
-require 'mongo'
-require 'logger'
-require 'net/ssh'
-require 'retries'
+require "mongo"
+require "logger"
+require "net/ssh"
+require "retries"
 
 class Mongo::MongoClient
-  MAX_DISABLE_BALANCER_WAIT = 60*8 # 8 Minutes
-  REPLICA_SNAPSHOT_THRESHOLD = 60*5 # 5 Minutes
+  MAX_DISABLE_BALANCER_WAIT = 60 * 8 # 8 Minutes
+  REPLICA_SNAPSHOT_THRESHOLD = 60 * 5 # 5 Minutes
   REPLICA_SNAPSHOT_PREFER_HIDDEN = true
+  DEFAULT_MONGO_PORT = 27017 # rubocop: disable Style/NumericLiterals
 
-  def snapshot_ebs(options={})
+  def snapshot_ebs(options = {})
     @mongolly_dry_run = options[:dry_run] || false
     @mongolly_logger = options[:logger] || Logger.new(STDOUT)
-    options[:volume_tag] ||= 'mongolly'
-    options[:backup_key] ||= (0...8).map{65.+(rand(25)).chr}.join
+    options[:volume_tag] ||= "mongolly"
+    options[:backup_key] ||= (0...8).map { 65.+(rand(25)).chr }.join
 
     @ec2 = AWS::EC2.new(access_key_id: options[:access_key_id], secret_access_key: options[:secret_access_key], region: options[:region])
 
@@ -20,131 +21,93 @@ class Mongo::MongoClient
       @mongolly_logger.info("Detected sharded cluster")
       with_disabled_balancing do
         with_config_server_stopped(options) do
-          backup_instance(config_server, options, false)
+          backup_instance(config_server, options)
 
-          shards.each do |name,hosts|
+          shards.each do |name, hosts|
             @mongolly_logger.debug("Found Shard #{name} with hosts #{hosts}.")
             replica_set_connection(hosts, options).snapshot_ebs(options)
           end
         end
       end
     else
-      backup_instance(snapshot_ebs_target(REPLICA_SNAPSHOT_THRESHOLD, REPLICA_SNAPSHOT_PREFER_HIDDEN), options, false )
+      backup_instance(snapshot_ebs_target(REPLICA_SNAPSHOT_THRESHOLD, REPLICA_SNAPSHOT_PREFER_HIDDEN), options.merge(strict_connection: true))
     end
   end
 
-protected
-  def snapshot_ebs_target(threshold=nil, prefer_hidden=nil)
-    host_port.join(':')
-  end
-
-  def backup_instance(address, options, lock = true)
-    host, port = address.split(':')
-    instance = @ec2.instances.find_from_address(host, port)
-
-    @mongolly_logger.info("Backing up instance #{instance.id} from #{host}:#{port}")
-
-    volumes = instance.volumes_with_tag(options[:volume_tag])
+  protected
 
-    @mongolly_logger.debug("Found target volumes #{volumes.map(&:id).join(', ')} ")
-
-    raise RuntimeError.new "no suitable volumes found"  unless volumes.length > 0
-
-    # Force lock with multiple volumes
-    lock = true  if volumes.length > 1
-
-    backup_block = proc do
-      volumes.each do |volume|
-        @mongolly_logger.debug("Snapshotting #{volume.id} with tag #{options[:backup_key]}")
-        unless @mongolly_dry_run
-          snapshot = volume.create_snapshot("#{options[:backup_key]} #{Time.now} mongolly #{host}")
-          snapshot.add_tag('created_at', value: Time.now)
-          snapshot.add_tag('backup_key', value: options[:backup_key])
-        end
-      end
-    end
-
-    if lock
-      with_database_locked &backup_block
-    else
-      backup_block.call
-    end
+  def snapshot_ebs_target(_threshold = nil, _prefer_hidden = nil)
+    host_port.join(":")
   end
 
   def disable_balancing
     @mongolly_logger.debug "Disabling Shard Balancing"
-    self['config'].collection('settings').update({_id: 'balancer'}, {'$set' => {stopped: true}}, upsert: true)  unless @mongolly_dry_run
+    self["config"].collection("settings").update({ _id: "balancer" }, { "$set" => { stopped: true } }, upsert: true) unless @mongolly_dry_run
   end
 
   def enable_balancing
     @mongolly_logger.debug "Enabling Shard Balancing"
-    retry_logger = Proc.new do |exception, attempt_number, total_delay|
+    retry_logger = proc do |_, attempt_number, total_delay|
       @mongolly_logger.debug "Error enabling balancing (config server not up?); retry attempt #{attempt_number}; #{total_delay} seconds have passed."
     end
     with_retries(max_tries: 5, handler: retry_logger, rescue: Mongo::OperationFailure, base_sleep_seconds: 5, max_sleep_seconds: 120) do
-      self['config'].collection('settings').update({_id: 'balancer'}, {'$set' => {stopped: false}}, upsert: true)  unless @mongolly_dry_run
+      self["config"].collection("settings").update({ _id: "balancer" }, { "$set" => { stopped: false } }, upsert: true) unless @mongolly_dry_run
     end
   end
 
   def balancer_active?
-    self['config'].collection('locks').find({_id: 'balancer', state: {'$ne' => 0}}).count > 0
+    self["config"].collection("locks").find(_id: "balancer", state: { "$ne" => 0 }).count > 0
   end
 
   def config_server
     unless @config_server
-      @config_server = self['admin'].command( { getCmdLineOpts: 1 } )["parsed"]["sharding"]["configDB"].split(",").sort.first.split(":").first
+      @config_server = self["admin"].command(getCmdLineOpts: 1)["parsed"]["sharding"]["configDB"].split(",").sort.first.split(":").first
       @mongolly_logger.debug "Found config server #{@config_server}"
     end
-    return @config_server
+    @config_server
   end
 
-  def with_config_server_stopped(options={})
-    begin
-      # Stop Config Server
-      ssh_command(options[:config_server_ssh_user], config_server, options[:mongo_stop_command], options[:config_server_ssh_keypath])
-      yield
-    rescue => ex
-      @mongolly_logger.error "Error with config server stopped: #{ex.to_s}"
-    ensure
-      # Start Config Server
-      ssh_command(options[:config_server_ssh_user], config_server, options[:mongo_start_command], options[:config_server_ssh_keypath])
-    end
+  def with_config_server_stopped(options = {})
+    # Stop Config Server
+    ssh_command(options[:config_server_ssh_user], config_server, options[:mongo_stop_command], options[:config_server_ssh_keypath])
+    yield
+  rescue => ex
+    @mongolly_logger.error "Error with config server stopped: #{ex}"
+  ensure
+    # Start Config Server
+    ssh_command(options[:config_server_ssh_user], config_server, options[:mongo_start_command], options[:config_server_ssh_keypath])
   end
 
   def with_disabled_balancing
-    begin
-      disable_balancing
-      term_time = Time.now + MAX_DISABLE_BALANCER_WAIT
-      while !@mongolly_dry_run && (Time.now < term_time) && balancer_active?
-        @mongolly_logger.info "Balancer active, sleeping for 10s (#{(term_time - Time.now).round}s remaining)"
-        sleep 10
-      end
-      if !@mongolly_dry_run && balancer_active?
-        raise RuntimeError.new "Unable to disable balancer within #{MAX_DISABLE_BALANCER_WAIT}s"
-      end
-      @mongolly_logger.debug "With shard balancing disabled..."
-      yield
-    rescue => ex
-      @mongolly_logger.error "Error with disabled balancer: #{ex.to_s}"
-    ensure
-      enable_balancing
-    end
+    disable_balancing
+    term_time = Time.now.utc + MAX_DISABLE_BALANCER_WAIT
+    while !@mongolly_dry_run && (Time.now.utc < term_time) && balancer_active?
+      @mongolly_logger.info "Balancer active, sleeping for 10s (#{(term_time - Time.now.utc).round}s remaining)"
+      sleep 10
+    end
+    if !@mongolly_dry_run && balancer_active?
+      raise "Unable to disable balancer within #{MAX_DISABLE_BALANCER_WAIT}s"
+    end
+    @mongolly_logger.debug "With shard balancing disabled..."
+    yield
+  rescue => ex
+    @mongolly_logger.error "Error with disabled balancer: #{ex}"
+  ensure
+    enable_balancing
   end
 
   def with_database_locked
-    begin
-      @mongolly_logger.debug "Locking database..."
-      disable_profiling
-      lock!  unless @mongolly_dry_run || locked?
-      @mongolly_logger.debug "With database locked..."
-      yield
-    rescue => ex
-      @mongolly_logger.error "Error with database locked: #{ex.to_s}"
-    ensure
-      @mongolly_logger.debug "Unlocking database..."
-      unlock!  if !@mongolly_dry_run && locked?
-      enable_profiling
-    end
+    @mongolly_logger.debug "Locking database..."
+    disable_profiling
+    lock! unless @mongolly_dry_run || locked?
+    @mongolly_logger.debug "With database locked..."
+    yield
+  rescue => ex
+    @mongolly_logger.error "Error with database locked: #{ex}"
+  ensure
+    @mongolly_logger.debug "Unlocking database..."
+    unlock! if !@mongolly_dry_run && locked?
+    enable_profiling
   end
 
   def disable_profiling
@@ -156,7 +119,7 @@ protected
         unless self[db].profiling_level == :off
           @mongolly_logger.debug("Disabling profiling for #{db}, level #{self[db].profiling_level}")
           @profiled_dbs[db] = self[db].profiling_level
-          self[db].profiling_level = :off  unless @mongolly_dry_run
+          self[db].profiling_level = :off unless @mongolly_dry_run
         end
       rescue Mongo::InvalidNSName
         @mongolly_logger.debug("Skipping database #{db} due to invalid name")
@@ -169,61 +132,101 @@ protected
       @mongolly_logger.debug("Database locked, can't turn on profiling")
       return false
     end
+
     unless @profiled_dbs
       @monglly_logger.debug("No dbs in @profiled_dbs")
       return true
     end
 
-    @profiled_dbs.each do |db,level|
+    @profiled_dbs.each do |db, level|
       begin
         @mongolly_logger.debug("Enabling profiling for #{db}, level #{level}")
-        self[db].profiling_level = level  unless @mongolly_dry_run
+        self[db].profiling_level = level unless @mongolly_dry_run
       rescue Mongo::InvalidNSName
         @mongolly_logger.debug("Skipping database #{db} due to invalid name")
       end
     end
-    return true
+    true
   end
 
   def shards
     shards = {}
-    self['config']['shards'].find().each do |shard|
-      shards[shard['_id']] = shard['host'].split("/")[1].split(",")
+    self["config"]["shards"].find.each do |shard|
+      shards[shard["_id"]] = shard["host"].split("/")[1].split(",")
     end
     shards
   end
 
   def replica_set_connection(hosts, options)
     db = Mongo::MongoReplicaSetClient.new(hosts)
-    db['admin'].authenticate(options[:db_username], options[:db_password])  if options[:db_username]
-    return db
+    db["admin"].authenticate(options[:db_username], options[:db_password]) if options[:db_username]
+    db
   end
 
   def ssh_command(user, host, command, keypath = nil)
     @mongolly_logger.debug("Running #{command} on #{host} as #{user}")
     return if @mongolly_dry_run
     exit_code = nil
-    output = ''
+    output = ""
     Net::SSH.start(host, user.strip, keys: keypath) do |ssh|
       channel = ssh.open_channel do |ch|
         ch.request_pty
-        ch.exec(command.strip) do |ch, success|
-          raise "Unable to exec #{command.strip} on #{host}"  unless success
+        ch.exec(command.strip) do |_, success|
+          raise "Unable to exec #{command.strip} on #{host}" unless success
         end
       end
-      channel.on_request("exit-status") do |ch,data|
+      channel.on_request("exit-status") do |_, data|
         exit_code = data.read_long
       end
-      channel.on_extended_data do |ch,type,data|
+      channel.on_extended_data do |_, _, data|
         output += data
       end
       ssh.loop
     end
 
     if exit_code != 0
-      raise RuntimeError.new "Unable to exec #{command} on #{host}, #{output}"
+      raise "Unable to exec #{command} on #{host}, #{output}"
     end
   end
 
+  private
+
+  def backup_instance(address, options)
+    host, port = address.split(":")
+    port ||= DEFAULT_MONGO_PORT
+
+    # Ensure we're directly connected to the target node for backup
+    # This prevents a subclassed replica set from still acting against the
+    # primary
+    if options[:strict_connection] && (self.host != host || self.port.to_i != port.to_i)
+      return Mongo::MongoClient.new(host, port.to_i, slave_ok: true).snapshot_ebs(options)
+    end
+
+    instance = @ec2.instances.find_from_address(host, port)
+
+    @mongolly_logger.info("Backing up instance #{instance.id} from #{host}:#{port}")
+
+    volumes = instance.volumes_with_tag(options[:volume_tag])
+
+    @mongolly_logger.debug("Found target volumes #{volumes.map(&:id).join(', ')} ")
+
+    raise "no suitable volumes found" if volumes.empty?
+
+    backup_block = proc do
+      volumes.each do |volume|
+        @mongolly_logger.debug("Snapshotting #{volume.id} with tag #{options[:backup_key]}")
+        next if @mongolly_dry_run
+        snapshot = volume.create_snapshot("#{options[:backup_key]} #{Time.now.utc} mongolly #{host}")
+        snapshot.add_tag("created_at", value: Time.now.utc)
+        snapshot.add_tag("backup_key", value: options[:backup_key])
+      end
+    end
+
+    if volumes.length > 1
+      with_database_locked(&backup_block)
+    else
+      backup_block.call
+    end
+  end
 
 end

data/lib/mongolly/extensions/mongo/mongo_replica_set_client.rb

@@ -1,17 +1,17 @@
-require 'mongo'
+require "mongo"
 
 class Mongo::MongoReplicaSetClient
 
   def most_current_secondary(threshold = 0, prefer_hidden = true)
-    replica = self['admin'].command( replSetGetStatus: 1 )
-    secondaries = replica['members'].select { |m| m['state'] == 2 }.sort_by { |m| [m['optime'], m['name']] }
+    replica = self["admin"].command(replSetGetStatus: 1)
+    secondaries = replica["members"].select { |m| m["state"] == 2 }.sort_by { |m| [m["optime"], m["name"]] }
     most_current = secondaries.first
 
-    hidden = self['local']['system']['replset'].find_one['members'].select { |mem| mem['hidden'] }.map { |mem| mem['host'] }
+    hidden = self["local"]["system"]["replset"].find_one["members"].select { |mem| mem["hidden"] }.map { |mem| mem["host"] }
 
-    if prefer_hidden && !hidden.include?(most_current['name'])
+    if prefer_hidden && !hidden.include?(most_current["name"])
       secondaries[1..-1].each do |secondary|
-        if hidden.include?(secondary['name']) && (most_current['optime'] - secondary['optime']) < threshold
+        if hidden.include?(secondary["name"]) && (most_current["optime"] - secondary["optime"]) < threshold
           most_current = secondary
           break
         end
@@ -19,10 +19,11 @@ class Mongo::MongoReplicaSetClient
     end
 
     @mongolly_logger.debug("Found most current secondary #{most_current['name']}, hidden: #{hidden.include? most_current['name']}")
-    most_current['name']
+    most_current["name"]
   end
 
-protected
+  protected
+
   def snapshot_ebs_target(threshold = 0, prefer_hidden = true)
     most_current_secondary(threshold, prefer_hidden)
   end

data/lib/mongolly/shepherd.rb

@@ -1,34 +1,33 @@
 module Mongolly
   class Shepherd
-
-    def initialize(options={})
+    def initialize(options = {})
       @options           = options
       @access_key_id     = options[:access_key_id]
       @secret_access_key = options[:secret_access_key]
-      @region            = options[:region] || 'us-east-1'
+      @region            = options[:region] || "us-east-1"
       @database          = options[:database]
       @db_username       = options[:db_username]
       @db_password       = options[:db_password]
       @dry_run           = options[:dry_run]
       @logger            = options[:logger] || Logger.new(STDOUT)
       @logger.level = case options[:log_level].strip
-                        when 'fatal'; then Logger::FATAL
-                        when 'error'; then Logger::ERROR
-                        when 'warn' ; then Logger::WARN
-                        when 'debug'; then Logger::DEBUG
-                        else Logger::INFO
+                      when "fatal"; then Logger::FATAL
+                      when "error"; then Logger::ERROR
+                      when "warn"; then Logger::WARN
+                      when "debug"; then Logger::DEBUG
+                      else Logger::INFO
                       end
     end
 
     def backup
       @logger.info "Starting backup..."
-      connection.snapshot_ebs({logger: @logger}.merge(@options))
+      connection.snapshot_ebs({ logger: @logger }.merge(@options))
       @logger.info "Backup complete."
     end
 
     def cleanup(age)
       @logger.info "Starting cleanup..."
-      raise ArgumentError.new("Must provide a Time object to cleanup")  unless age.class <= Time
+      raise ArgumentError, "Must provide a Time object to cleanup" unless age.class <= Time
 
       ec2 = AWS::EC2.new(access_key_id: @access_key_id,
                          secret_access_key: @secret_access_key,
@@ -36,11 +35,10 @@ module Mongolly
 
       @logger.debug "deleting snapshots older than #{age}}"
       ec2.snapshots.with_owner(:self).each do |snapshot|
-        unless snapshot.tags[:created_at].nil? || snapshot.tags[:backup_key].nil?
-          if Time.parse(snapshot.tags[:created_at]) < age
-            @logger.debug "deleting snapshot #{snapshot.id} tagged #{snapshot.tags[:backup_key]} created at #{snapshot.tags[:created_at]}, earlier than #{age}"
-            snapshot.delete  unless @dry_run
-          end
+        next if snapshot.tags[:created_at].nil? || snapshot.tags[:backup_key].nil?
+        if Time.parse.utc(snapshot.tags[:created_at]) < age
+          @logger.debug "deleting snapshot #{snapshot.id} tagged #{snapshot.tags[:backup_key]} created at #{snapshot.tags[:created_at]}, earlier than #{age}"
+          snapshot.delete unless @dry_run
         end
       end
       @logger.info "Cleanup complete."
@@ -48,14 +46,16 @@ module Mongolly
 
     def connection
       db = if @database.is_a? Array
-        @logger.debug "connecting to a replica set #{@database}"
-        Mongo::MongoReplicaSetClient.new(@database)
-      else
-        @logger.debug "connecting to a single instance #{@database}"
-        Mongo::MongoClient.new(*@database.split(':'))
+             @logger.debug "connecting to a replica set #{@database}"
+             Mongo::MongoReplicaSetClient.new(@database)
+           else
+             @logger.debug "connecting to a single instance #{@database}"
+             Mongo::MongoClient.new(*@database.split(":"))
+           end
+      if @db_username && @db_password
+        db["admin"].authenticate(@db_username, @db_password)
       end
-      db['admin'].authenticate(@db_username, @db_password) if @db_username && @db_password
-      return db
+      db
     end
   end
 end

data/lib/mongolly/version.rb

@@ -1,3 +1,3 @@
 module Mongolly
-  VERSION = "0.2.10"
+  VERSION = "0.2.11".freeze
 end

data/mongolly.gemspec

@@ -1,28 +1,27 @@
 # -*- encoding: utf-8 -*-
-lib = File.expand_path('../lib', __FILE__)
+lib = File.expand_path("../lib", __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'mongolly/version'
+require "mongolly/version"
 
 Gem::Specification.new do |gem|
   gem.name          = "mongolly"
   gem.version       = Mongolly::VERSION
   gem.authors       = ["Michael Saffitz"]
   gem.email         = ["m@saffitz.com"]
-  gem.description   = %q{Easy backups for EBS-based MongoDB Databases}
-  gem.summary       = %q{Easy backups for EBS-based MongoDB Databases}
+  gem.description   = "Easy backups for EBS-based MongoDB Databases"
+  gem.summary       = "Easy backups for EBS-based MongoDB Databases"
   gem.homepage      = "http://www.github.com/msaffitz/mongolly"
 
-  gem.files         = `git ls-files`.split($/)
-  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.files         = `git ls-files`.split($INPUT_RECORD_SEPARATOR)
+  gem.executables   = gem.files.grep(%r{^bin/}).map { |f| File.basename(f) }
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
 
   gem.add_dependency("thor")
-  gem.add_dependency("mongo")
+  gem.add_dependency("mongo", "~>1")
   gem.add_dependency("bson_ext")
   gem.add_dependency("aws-sdk", "~>1")
   gem.add_dependency("ipaddress")
   gem.add_dependency("net-ssh")
   gem.add_dependency("retries")
-
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mongolly
 version: !ruby/object:Gem::Version
-  version: 0.2.10
+  version: 0.2.11
 platform: ruby
 authors:
 - Michael Saffitz
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-01-28 00:00:00.000000000 Z
+date: 2017-07-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
@@ -28,16 +28,16 @@ dependencies:
   name: mongo
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1'
 - !ruby/object:Gem::Dependency
   name: bson_ext
   requirement: !ruby/object:Gem::Requirement
@@ -117,6 +117,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".rubocop.yml"
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -151,9 +152,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.3
+rubygems_version: 2.4.5.1
 signing_key: 
 specification_version: 4
 summary: Easy backups for EBS-based MongoDB Databases
 test_files: []
-has_rdoc: