do_snapshot 0.0.6 → 0.0.7

data/lib/do_snapshot/cli.rb

@@ -1,31 +1,31 @@
+# -*- encoding : utf-8 -*-
+require 'thor'
 require 'do_snapshot'
 require 'do_snapshot/command'
+require 'do_snapshot/mail'
+require 'do_snapshot/log'
 
 module DoSnapshot
   # CLI is here
   #
-  class CLI < Thor
+  class CLI < Thor # rubocop:disable ClassLength
     default_task :snap
 
     map %w( c s create )  => :snap
     map %w( -V ) => :version
 
+    # Overriding Thor method for custom initialization
+    #
     def initialize(*args)
       super
 
-      Log.quiet = options['quiet']
-      # Use Thor shell
-      Log.shell = shell unless Log.quiet
-      Log.verbose = options['trace']
-
-      logger if options.include?('log')
-
-      Log.mail = options['mail']
-      Log.smtp = options['smtp']
+      set_logger
+      set_mailer
 
       # Check for keys via options
-      ENV['DIGITAL_OCEAN_CLIENT_ID'] = options['digital_ocean_client_id'] if options.include? 'digital_ocean_client_id'
-      ENV['DIGITAL_OCEAN_API_KEY']   = options['digital_ocean_api_key'] if options.include? 'digital_ocean_api_key'
+      %w( digital_ocean_client_id digital_ocean_api_key ).each do |key|
+        ENV[key.upcase] = options[key] if options.include? key
+      end
 
       try_keys_first
     end
@@ -66,33 +66,86 @@ module DoSnapshot
 
     VERSION: #{DoSnapshot::VERSION}
     LONGDESC
-
-    method_option :only,    type: :array,   default: [], aliases: %w( -o ), banner: '123456 123456 123456', desc: 'Select some droplets.'
-    method_option :exclude, type: :array,   default: [], aliases: %w( -e ), banner: '123456 123456 123456', desc: 'Except some droplets.'
-    method_option :keep,    type: :numeric, default: 10, aliases: %w( -k ), banner: '5', desc: 'How much snapshots you want to keep?'
-    method_option :delay,   type: :numeric, default: 10, aliases: %w( -d ), banner: '5', desc: 'Delay between snapshot operation status requests.'
-    method_option :mail,    type: :hash,    aliases: %w( -m ), banner: 'to:yourmail@example.com', desc: 'Receive mail if fail or maximum is reached.'
-    method_option :smtp,    type: :hash,    aliases: %w( -t ), banner: 'user_name:yourmail@example.com password:password', desc: 'SMTP options.'
-    method_option :log,     type: :string,  aliases: %w( -l ), banner: '/Users/someone/.do_snapshot/main.log', desc: 'Log file path. By default logging is disabled.'
-    method_option :clean,   type: :boolean, aliases: %w( -c ), desc: 'Cleanup snapshots after create. If you have more images than you want to `keep`, older will be deleted.'
-    method_option :stop,    type: :boolean, aliases: %w( -s),  desc: 'Stop creating snapshots if maximum is reached.'
-    method_option :trace,   type: :boolean, aliases: %w( -v ), desc: 'Verbose mode.'
-    method_option :quiet,   type: :boolean, aliases: %w( -q ), desc: 'Quiet mode. If don\'t need any messages and in console.'
-
-    method_option :digital_ocean_client_id, type: :string, banner: 'YOURLONGAPICLIENTID', desc: 'DIGITAL_OCEAN_CLIENT_ID. if you can\'t use environment.'
-    method_option :digital_ocean_api_key,   type: :string, banner: 'YOURLONGAPIKEY',      desc: 'DIGITAL_OCEAN_API_KEY. if you can\'t use environment.'
+    method_option :only,
+                  type: :array,
+                  default: [],
+                  aliases: %w( -o ),
+                  banner: '123456 123456 123456',
+                  desc: 'Select some droplets.'
+    method_option :exclude,
+                  type: :array,
+                  default: [],
+                  aliases: %w( -e ),
+                  banner: '123456 123456 123456',
+                  desc: 'Except some droplets.'
+    method_option :keep,
+                  type: :numeric,
+                  default: 10,
+                  aliases: %w( -k ),
+                  banner: '5',
+                  desc: 'How much snapshots you want to keep?'
+    method_option :delay,
+                  type: :numeric,
+                  default: 10,
+                  aliases: %w( -d ),
+                  banner: '5',
+                  desc: 'Delay between snapshot operation status requests.'
+    method_option :timeout,
+                  type: :numeric,
+                  default: 180,
+                  banner: '250',
+                  desc: 'Timeout in sec\'s for events like Power Off or Create Snapshot.'
+    method_option :mail,
+                  type: :hash,
+                  aliases: %w( -m ),
+                  banner: 'to:yourmail@example.com',
+                  desc: 'Receive mail if fail or maximum is reached.'
+    method_option :smtp,
+                  type: :hash,
+                  aliases: %w( -t ),
+                  banner: 'user_name:yourmail@example.com password:password',
+                  desc: 'SMTP options.'
+    method_option :log,
+                  type: :string,
+                  aliases: %w( -l ),
+                  banner: '/Users/someone/.do_snapshot/main.log',
+                  desc: 'Log file path. By default logging is disabled.'
+    method_option :clean,
+                  type: :boolean,
+                  aliases: %w( -c ),
+                  desc: 'Cleanup snapshots after create. If you have more images than you want to `keep`, older will be deleted.'
+    method_option :stop,
+                  type: :boolean,
+                  aliases: %w( -s),
+                  desc: 'Stop creating snapshots if maximum is reached.'
+    method_option :trace,
+                  type: :boolean,
+                  aliases: %w( -v ),
+                  desc: 'Verbose mode.'
+    method_option :quiet,
+                  type: :boolean,
+                  aliases: %w( -q ),
+                  desc: 'Quiet mode. If don\'t need any messages and in console.'
+
+    method_option :digital_ocean_client_id,
+                  type: :string,
+                  banner: 'YOURLONGAPICLIENTID',
+                  desc: 'DIGITAL_OCEAN_CLIENT_ID. if you can\'t use environment.'
+    method_option :digital_ocean_api_key,
+                  type: :string,
+                  banner: 'YOURLONGAPIKEY',
+                  desc: 'DIGITAL_OCEAN_API_KEY. if you can\'t use environment.'
 
     def snap
-      Command.execute options, %w( log trace digital_ocean_client_id digital_ocean_api_key )
+      Command.snap options, %w( log trace digital_ocean_client_id digital_ocean_api_key )
     rescue => e
-
-      Command.fail_power_on(e.id) if e && e.class == SnapshotCreateError && e.respond_to?('id')
+      Command.fail_power_off(e) if [SnapshotCreateError, DropletShutdownError].include?(e.class)
       Log.error e.message
       backtrace(e) if options.include? 'trace'
-      if Log.mail
-        Log.mail[:subject] = 'Digital Ocean: Error.'
-        Log.mail[:body] = 'Please check your droplets.'
-        Log.notify
+      if Mail.opts
+        Mail.opts[:subject] = 'Digital Ocean: Error.'
+        Mail.opts[:body] = 'Please check your droplets.'
+        Mail.notify
       end
     end
 
@@ -101,24 +154,38 @@ module DoSnapshot
       puts DoSnapshot::VERSION
     end
 
-    protected
+    no_commands do
+      def set_mailer
+        Mail.opts = options['mail']
+        Mail.smtp = options['smtp']
+      end
+
+      def set_logger
+        Log.quiet = options['quiet']
+        Log.verbose = options['trace']
+        # Use Thor shell
+        Log.shell = shell unless options['quiet']
+        init_logger if options.include?('log')
+      end
 
-    def logger
-      Log.logger = Logger.new(options['log'])
-      Log.logger.level = Log.verbose ? Logger::DEBUG : Logger::INFO
-    end
+      def init_logger
+        Log.logger = Logger.new(options['log'])
+        Log.logger.level = Log.verbose ? Logger::DEBUG : Logger::INFO
+      end
 
-    def backtrace(e)
-      e.backtrace.each do |t|
-        Log.error t
+      def backtrace(e)
+        e.backtrace.each do |t|
+          Log.error t
+        end
       end
-    end
 
-    # Check for DigitalOcean API keys
-    def try_keys_first
-      Log.debug 'Checking DigitalOcean Id\'s.'
-      fail Thor::Error, 'You must have DIGITAL_OCEAN_CLIENT_ID in environment or set via options.' if !ENV['DIGITAL_OCEAN_CLIENT_ID'] || ENV['DIGITAL_OCEAN_CLIENT_ID'].empty?
-      fail Thor::Error, 'You must have DIGITAL_OCEAN_API_KEY in environment or set via options.' if !ENV['DIGITAL_OCEAN_API_KEY'] || ENV['DIGITAL_OCEAN_API_KEY'].empty?
+      # Check for DigitalOcean API keys
+      def try_keys_first
+        Log.debug 'Checking DigitalOcean Id\'s.'
+        %w( DIGITAL_OCEAN_CLIENT_ID DIGITAL_OCEAN_API_KEY ).each do |key|
+          Log.fail Thor::Error, "You must have #{key} in environment or set it via options." if !ENV[key] || ENV[key].empty?
+        end
+      end
     end
   end
 end

data/lib/do_snapshot/command.rb

@@ -1,12 +1,13 @@
-require 'digitalocean'
-require 'thread'
+# -*- encoding : utf-8 -*-
+# require 'thread'
+require 'do_snapshot/api'
 
 module DoSnapshot
   # Our commands live here :)
   #
-  class Command
+  class Command # rubocop:disable ClassLength
     class << self
-      def execute(options, skip)
+      def snap(options, skip)
         return unless options
 
         options.each_pair do |key, option|
@@ -14,32 +15,29 @@ module DoSnapshot
         end
 
         Log.info 'Start performing operations'
-        work_droplets
+        work_with_droplets
         Log.info 'All operations has been finished.'
 
-        Log.notify if notify && !quiet
+        Mail.notify if notify && !quiet
       end
 
-      def fail_power_on(id)
-        return unless id
-
-        set_id
-        instance = Digitalocean::Droplet.find(id)
-        fail instance.message unless instance.status.include? 'OK'
-        if instance.droplet.status.include? 'active'
-          Log.info "Droplet id: #{id} failed to snapshot. But it still running."
-        else
-          Digitalocean::Droplet.power_on(id)
-          Log.info "Droplet id: #{id} failed to snapshot. POWER ON has been requested."
-        end
+      def fail_power_off(e)
+        return unless e && e.id
+        api.start_droplet(e.id)
+      rescue
+        raise DropletFindError, e.message, e.backtrace
       end
 
       protected
 
       attr_accessor :droplets, :mail, :smtp, :exclude, :only
-      attr_accessor :delay, :keep, :quiet, :stop, :clean
+      attr_accessor :delay, :timeout, :keep, :quiet, :stop, :clean
 
-      attr_writer :notify, :threads
+      attr_writer :notify, :threads, :api
+
+      def api
+        @api ||= API.new(delay: delay, timeout: timeout)
+      end
 
       def notify
         @notify ||= false
@@ -49,111 +47,101 @@ module DoSnapshot
         @threads ||= []
       end
 
+      # Working with list of droplets.
+      #
+      def work_with_droplets
+        load_droplets
+        dispatch_droplets
+        Log.debug 'Working with list of DigitalOcean droplets'
+        thread_chain
+      end
+
       # Getting droplets list from API.
       # And store into object.
       #
       def load_droplets
-        set_id
         Log.debug 'Loading list of DigitalOcean droplets'
-        droplets = Digitalocean::Droplet.all
-        fail droplets.message unless droplets.status.include? 'OK'
-        self.droplets = droplets.droplets
+        self.droplets = api.droplets.droplets
       end
 
-      # Working with received list of droplets.
+      # Dispatch received droplets, each by each.
       #
-      def work_droplets
-        load_droplets
-        Log.debug 'Working with list of DigitalOcean droplets'
+      def dispatch_droplets
         droplets.each do |droplet|
           id = droplet.id.to_s
           next if exclude.include? id
           next if !only.empty? && !only.include?(id)
 
-          instance = Digitalocean::Droplet.find(id)
-          fail instance.message unless instance.status.include? 'OK'
+          instance = api.droplet id
 
           prepare_instance instance.droplet
         end
-        thread_chain
       end
 
-      # Threads review
+      # Join threads
       #
       def thread_chain
         threads.each { |t| t.join }
       end
 
+      # Run threads
+      #
+      def thread_runner(instance)
+        threads << Thread.new do
+          Log.debug 'Shutting down droplet.'
+          stop_droplet instance
+          create_snapshot instance
+        end
+      end
+
       # Preparing instance to take snapshot.
       # Instance must be powered off first!
       #
       def prepare_instance(instance)
         return unless instance
         Log.info "Preparing droplet id: #{instance.id} name: #{instance.name} to take snapshot."
+        return if too_much_snapshots(instance)
+        thread_runner(instance)
+      end
 
-        warning_size = "For droplet with id: #{instance.id} and name: #{instance.name} the maximum number #{keep} of snapshots is reached."
-
-        if instance.snapshots.size >= keep && stop
-          Log.warning warning_size
-          self.notify = true
-          return
+      def too_much_snapshots(instance)
+        # noinspection RubyResolve
+        if instance.snapshots.size >= keep
+          warning_size(instance.id, instance.name, keep)
+          return true if stop
         end
+        false
+      end
 
-        # Stopping instance.
-        Log.debug 'Shutting down droplet.'
-        threads << Thread.new do
-          begin
-            unless instance.status.include? 'off'
-              event = Digitalocean::Droplet.power_off(instance.id)
-              if event.status.include? 'OK'
-                sleep delay until get_event_status(event.event_id)
-              end
-            end
-          rescue => e
-            raise DropletShutdownError.new(instance.id), e.message, e.backtrace
-          end
-
-          # Create snapshot.
-          create_snapshot instance, warning_size
-        end
+      def stop_droplet(instance)
+        api.stop_droplet(instance.id) unless instance.status.include? 'off'
       end
 
       # Trying to create a snapshot.
       #
-      def create_snapshot(instance, warning_size)
+      def create_snapshot(instance) # rubocop:disable MethodLength
         Log.info "Start creating snapshot for droplet id: #{instance.id} name: #{instance.name}."
 
         today         = DateTime.now
         name          = "#{instance.name}_#{today.strftime('%Y_%m_%d')}"
-        event         = Digitalocean::Droplet.snapshot(instance.id, name: name)
+        # noinspection RubyResolve
         snapshot_size = instance.snapshots.size
 
-        if !event
-          fail 'Something wrong with DigitalOcean or with your connection :)'
-        elsif event && !event.status.include?('OK')
-          fail event.message
-        end
-
         Log.debug 'Wait until snapshot will be created.'
 
-        sleep delay until get_event_status(event.event_id)
+        api.create_snapshot instance.id, name
 
         snapshot_size += 1
 
         Log.info "Snapshot name: #{name} created successfully."
         Log.info "Droplet id: #{instance.id} name: #{instance.name} snapshots: #{snapshot_size}."
 
-        if snapshot_size > keep
-          Log.warning warning_size if snapshot_size > keep
-          self.notify = true
-
-          # Cleanup snapshots.
-          cleanup_snapshots instance, (snapshot_size - keep - 1) if clean
-        end
+        # Cleanup snapshots.
+        cleanup_snapshots instance, snapshot_size if clean
       rescue => e
-        case e.class
-        when SnapshotCleanupError
-          raise
+        case e.class.to_s
+        when 'DoSnapshot::SnapshotCleanupError'
+          raise e.class, e.message, e.backtrace
         else
           raise SnapshotCreateError.new(instance.id), e.message, e.backtrace
         end
@@ -162,40 +150,21 @@ module DoSnapshot
       # Cleanup our snapshots.
       #
       def cleanup_snapshots(instance, size)
-        Log.debug "Cleaning up snapshots for droplet id: #{instance.id} name: #{instance.name}."
+        return unless size > keep
 
-        (0..size).each do |i|
-          snapshot = instance.snapshots[i]
-          event = Digitalocean::Image.destroy(snapshot.id)
+        warning_size(instance.id, instance.name, size)
 
-          if !event
-            fail 'Something wrong with DigitalOcean or with your connection :)'
-          elsif event && !event.status.include?('OK')
-            fail event.message
-          end
+        Log.debug "Cleaning up snapshots for droplet id: #{instance.id} name: #{instance.name}."
 
-          Log.info "Snapshot name: #{snapshot.name} delete requested."
-        end
+        api.cleanup_snapshots(instance, size - keep - 1)
       rescue => e
-        raise SnapshotCleanupError.new(instance.id), e.message, e.backtrace
+        raise SnapshotCleanupError, e.message, e.backtrace
       end
 
-      # Looking for event status.
-      #
-      # Before snapshot we to know that machine has powered off.
-      #
-      def get_event_status(id)
-        event = Digitalocean::Event.find(id)
-        fail event.message unless event.status.include?('OK')
-        event.event.percentage && event.event.percentage.include?('100') ? true : false
-      end
-
-      # Set id's of Digital Ocean API.
-      #
-      def set_id
-        Log.debug 'Setting DigitalOcean Id\'s.'
-        Digitalocean.client_id = ENV['DIGITAL_OCEAN_CLIENT_ID']
-        Digitalocean.api_key = ENV['DIGITAL_OCEAN_API_KEY']
+      def warning_size(id, name, keep)
+        message = "For droplet with id: #{id} and name: #{name} the maximum number #{keep} of snapshots is reached."
+        Log.warning message
+        self.notify = true
       end
     end
   end