wordpress-deploy 1.0.0.alpha1

data/lib/wordpress_deploy/logger.rb

@@ -0,0 +1,152 @@
+# encoding: utf-8
+
+module WordpressDeploy
+  module Logger
+    class << self
+
+      attr_accessor :quiet
+
+      ##
+      # Outputs a messages to the console and writes it to the backup.log
+      def message(string)
+        to_console  loggify(string, :message, :green)
+        to_file     loggify(string, :message)
+      end
+
+      ##
+      # Outputs an error to the console and writes it to the backup.log
+      # Called when an Exception has caused the backup process to abort.
+      def error(string)
+        to_console  loggify(string, :error,   :red), true
+        to_file     loggify(string, :error)
+      end
+
+      ##
+      # Outputs a notice to the console and writes it to the backup.log
+      # Sets #has_warnings? true so :on_warning notifications will be sent
+      def warn(string)
+        @has_warnings = true
+        to_console  loggify(string, :warning, :yellow), true
+        to_file     loggify(string, :warning)
+      end
+
+      # Outputs the data as if it were a regular 'puts' command,
+      # but also logs it to the backup.log
+      def normal(string)
+        to_console  loggify(string)
+        to_file     loggify(string)
+      end
+
+      ##
+      # Silently logs data to the log file
+      def silent(string)
+        to_file     loggify(string, :silent)
+      end
+
+      ##
+      # Returns an Array of all messages written to the log file for this session
+      def messages
+        @messages ||= []
+      end
+
+      ##
+      # Returns true if any warnings have been issued
+      def has_warnings?
+        @has_warnings ||= false
+      end
+
+      def clear!
+        messages.clear
+        @has_warnings = false
+      end
+
+      def truncate!(max_bytes = 500_000)
+        log_file = File.join(Config.log_path, 'backup.log')
+        return unless File.exist?(log_file)
+
+        if File.stat(log_file).size > max_bytes
+          FileUtils.mv(log_file, log_file + '~')
+          File.open(log_file + '~', 'r') do |io_in|
+            File.open(log_file, 'w') do |io_out|
+              io_in.seek(-max_bytes, IO::SEEK_END) && io_in.gets
+              while line = io_in.gets
+                io_out.puts line
+              end
+            end
+          end
+          FileUtils.rm_f(log_file + '~')
+        end
+      end
+
+      private
+
+      ##
+      # Returns the time in [YYYY/MM/DD HH:MM:SS] format
+      def time
+        Time.now.strftime("%Y/%m/%d %H:%M:%S")
+      end
+
+      ##
+      # Receives a String, or an Object that responds to #to_s (e.g. an
+      # Exception), from one of the messaging methods and converts it into an
+      # Array of Strings, split on newline separators. Each line is then
+      # formatted into a log format based on the given options, and the Array
+      # returned to be passed to to_console() and/or to_file().
+      def loggify(string, type = false, color = false)
+        lines = string.to_s.split("\n")
+        if type
+          type = send(color, type) if color
+          time_now = time
+          lines.map {|line| "[#{time_now}][#{type}] #{line}" }
+        else
+          lines
+        end
+      end
+
+      ##
+      # Receives an Array of Strings to be written to the console.
+      def to_console(lines, stderr = false)
+        return if quiet
+        lines.each {|line| stderr ? Kernel.warn(line) : puts(line) }
+      end
+
+      ##
+      # Receives an Array of Strings to be written to the log file.
+      def to_file(lines)
+        File.open(File.join(Config.log_path, 'backup.log'), 'a') do |file|
+          lines.each {|line| file.puts line }
+        end
+        messages.push(*lines)
+      end
+
+      ##
+      # Invokes the #colorize method with the provided string
+      # and the color code "32" (for green)
+      def green(string)
+        colorize(string, 32)
+      end
+
+      ##
+      # Invokes the #colorize method with the provided string
+      # and the color code "33" (for yellow)
+      def yellow(string)
+        colorize(string, 33)
+      end
+
+      ##
+      # Invokes the #colorize method the with provided string
+      # and the color code "31" (for red)
+      def red(string)
+        colorize(string, 31)
+      end
+
+      ##
+      # Wraps the provided string in colorizing tags to provide
+      # easier to view output to the client
+      def colorize(string, code)
+        "\e[#{code}m#{string}\e[0m"
+      end
+
+    end
+  end
+end

data/lib/wordpress_deploy/pipeline.rb

@@ -0,0 +1,110 @@
+# encoding: utf-8
+
+module WordpressDeploy
+  class Pipeline
+    include WordpressDeploy::CLI::Helpers
+
+    attr_reader :stderr, :errors
+
+    def initialize
+      @commands = []
+      @errors = []
+      @stderr = ''
+    end
+
+    ##
+    # Adds a command to be executed in the pipeline.
+    # Each command will be run in the order in which it was added,
+    # with it's output being piped to the next command.
+    def <<(command)
+      @commands << command
+    end
+
+    ##
+    # Runs the command line from `#pipeline` and collects STDOUT/STDERR.
+    # STDOUT is then parsed to determine the exit status of each command.
+    # For each command with a non-zero exit status, a SystemCallError is
+    # created and added to @errors. All STDERR output is set in @stderr.
+    #
+    # Note that there is no accumulated STDOUT from the commands themselves.
+    # Also, the last command should not attempt to write to STDOUT.
+    # Any output on STDOUT from the final command will be sent to STDERR.
+    # This in itself will not cause #run to fail, but will log warnings
+    # when all commands exit with non-zero status.
+    #
+    # Use `#success?` to determine if all commands in the pipeline succeeded.
+    # If `#success?` returns `false`, use `#error_messages` to get an error report.
+    def run
+      Open4.popen4(pipeline) do |pid, stdin, stdout, stderr|
+        pipestatus = stdout.read.gsub("\n", '').split(':').sort
+        pipestatus.each do |status|
+          index, exitstatus = status.split('|').map(&:to_i)
+          if exitstatus > 0
+            command = command_name(@commands[index])
+            @errors << SystemCallError.new(
+              "'#{ command }' returned exit code: #{ exitstatus }", exitstatus
+            )
+          end
+        end
+        @stderr = stderr.read.strip
+      end
+      Logger.warn(stderr_messages) if success? && stderr_messages
+    rescue Exception => e
+      raise Errors::Pipeline::ExecutionError.wrap(e)
+    end
+
+    def success?
+      @errors.empty?
+    end
+
+    ##
+    # Returns a multi-line String, reporting all STDERR messages received
+    # from the commands in the pipeline (if any), along with the SystemCallError
+    # (Errno) message for each command which had a non-zero exit status.
+    #
+    # Each error is wrapped by WordpressDeploy::Errors to provide formatting.
+    def error_messages
+      @error_messages ||= (stderr_messages || '') +
+          "The following system errors were returned:\n" +
+          @errors.map {|err| Errors::Error.wrap(err).message }.join("\n")
+    end
+
+    private
+
+    ##
+    # Each command is added as part of the pipeline, grouped with an `echo`
+    # command to pass along the command's index in @commands and it's exit status.
+    # The command's STDERR is redirected to FD#4, and the `echo` command to
+    # report the "index|exit status" is redirected to FD#3.
+    # Each command's STDOUT will be connected to the STDIN of the next subshell.
+    # The entire pipeline is run within a container group, which redirects
+    # FD#3 to STDOUT and FD#4 to STDERR so these can be collected.
+    # FD#1 is redirected to STDERR so that any output from the final command
+    # on STDOUT will generate warnings, since the final command should not
+    # attempt to write to STDOUT, as this would interfere with collecting
+    # the exit statuses.
+    #
+    # There is no guarantee as to the order of this output, which is why the
+    # command's index in @commands is passed along with it's exit status.
+    # And, if multiple commands output messages on STDERR, those messages
+    # may be interleaved. Interleaving of the "index|exit status" outputs
+    # should not be an issue, given the small byte size of the data being written.
+    def pipeline
+      parts = []
+      @commands.each_with_index do |command, index|
+        parts << %Q[{ #{ command } 2>&4 ; echo "#{ index }|$?:" >&3 ; }]
+      end
+      %Q[{ #{ parts.join(' | ') } } 3>&1 1>&2 4>&2]
+    end
+
+    def stderr_messages
+      @stderr_messages ||= @stderr.empty? ? false : <<-EOS.gsub(/^ +/, '  ')
+        Pipeline STDERR Messages:
+        (Note: may be interleaved if multiple commands returned error messages)
+
+        #{ @stderr }
+      EOS
+    end
+
+  end
+end

data/lib/wordpress_deploy/storage/base.rb

@@ -0,0 +1,99 @@
+# encoding: utf-8
+
+module WordpressDeploy
+  module Storage
+    class Base
+      include WordpressDeploy::Configuration::Helpers
+
+      ##
+      # Sets the limit to how many backups to keep in the remote location.
+      # If exceeded, the oldest will be removed to make room for the newest
+      attr_accessor :keep
+
+      ##
+      # (Optional)
+      # User-defined string used to uniquely identify multiple storages of the
+      # same type. This will be appended to the YAML storage file used for
+      # cycling backups.
+      attr_accessor :storage_id
+
+      ##
+      # Creates a new instance of the storage object
+      # * Called with super(model, storage_id) from each subclass
+      def initialize(model, storage_id = nil)
+        load_defaults!
+        @model = model
+        @storage_id = storage_id
+      end
+
+      ##
+      # Performs the backup transfer
+      def perform!
+        @package = @model.package
+        transfer!
+        cycle!
+      end
+
+      private
+
+      ##
+      # Provider defaults to false. Overridden when using a service-based
+      # storage such as Amazon S3, Rackspace Cloud Files or Dropbox
+      def provider
+        false
+      end
+
+      ##
+      # Each subclass must define a +path+ where remote files will be stored
+      def path; end
+
+      ##
+      # Return the storage name, with optional storage_id
+      def storage_name
+        self.class.to_s.sub('WordpressDeploy::', '') +
+            (storage_id ? " (#{storage_id})" : '')
+      end
+
+      ##
+      # Returns the local path
+      # This is where any Package to be transferred is located.
+      def local_path
+        Config.tmp_path
+      end
+
+      ##
+      # Returns the remote path for the given Package
+      # This is where the Package will be stored, or was previously stored.
+      def remote_path_for(package)
+        File.join(path, package.trigger, package.time)
+      end
+
+      ##
+      # Yields two arguments to the given block: "local_file, remote_file"
+      # The local_file is the full file name:
+      # e.g. "2011.08.30.11.00.02.backup.tar.enc"
+      # The remote_file is the full file name, minus the timestamp:
+      # e.g. "backup.tar.enc"
+      def files_to_transfer_for(package)
+        package.filenames.each do |filename|
+          yield filename, filename[20..-1]
+        end
+      end
+      alias :transferred_files_for :files_to_transfer_for
+
+      ##
+      # Adds the current package being stored to the YAML cycle data file
+      # and will remove any old Package file(s) when the storage limit
+      # set by #keep is exceeded. Any errors raised while attempting to
+      # remove older packages will be rescued and a warning will be logged
+      # containing the original error message.
+      def cycle!
+        return unless keep.to_i > 0
+        Logger.message "#{ storage_name }: Cycling Started..."
+        Cycler.cycle!(self, @package)
+        Logger.message "#{ storage_name }: Cycling Complete!"
+      end
+
+    end
+  end
+end

data/lib/wordpress_deploy/storage/ftp.rb

@@ -0,0 +1,133 @@
+# encoding: utf-8
+
+##
+# Only load the Net::FTP library/gem when the WordpressDeploy::Storage::FTP class is loaded
+require 'net/ftp'
+require 'pathname'
+require 'action_view'
+
+module WordpressDeploy
+  module Storage
+    class FTP < Base
+      include ActionView::Helpers::NumberHelper
+
+      ##
+      # Server credentials
+      attr_accessor :username, :password
+
+      ##
+      # Server IP Address and FTP port
+      attr_accessor :ip, :port
+      alias :hostname :ip
+
+      ##
+      # Path to store backups to
+      attr_accessor :path
+
+      ##
+      # use passive mode?
+      attr_accessor :passive_mode
+
+      ##
+      # the remote path
+      attr_accessor :remote_path
+
+      ##
+      # Creates a new instance of the storage object
+      def initialize(model, storage_id = nil, &block)
+        super(model, storage_id)
+
+        @hostname = hostname
+        @username = username
+        @password = password
+        @remote_path = remote_path
+        @remote_directores = []
+
+        @port         ||= 21
+        @path         ||= 'backups'
+        @passive_mode ||= false
+
+        instance_eval(&block) if block_given?
+
+        @path = path.sub(/^\~\//, '')
+      end
+
+      private
+
+      ##
+      # Establishes a connection to the remote server
+      #
+      # Note:
+      # Since the FTP port is defined as a constant in the Net::FTP class, and
+      # might be required to change by the user, we dynamically remove and
+      # re-add the constant with the provided port value
+      def connection
+        if Net::FTP.const_defined?(:FTP_PORT)
+          Net::FTP.send(:remove_const, :FTP_PORT)
+        end; Net::FTP.send(:const_set, :FTP_PORT, port)
+
+        Net::FTP.open(ip, username, password) do |ftp|
+          ftp.passive = true if passive_mode
+          yield ftp
+        end
+      end
+
+      ##
+      # Transfers the archived file to the specified remote server
+      def transfer!
+        remote_path = remote_path_for(@package)
+
+        connection do |ftp|
+          create_remote_path(remote_path, ftp)
+
+          files_to_transfer_for(@package) do |local_file, remote_file|
+            Logger.message "#{storage_name} started transferring " +
+                "'#{ local_file }' to '#{ ip }'."
+            ftp.put(
+              File.join(local_path, local_file),
+              File.join(remote_path, remote_file)
+            )
+          end
+        end
+      end
+
+      ##
+      # Removes the transferred archive file(s) from the storage location.
+      # Any error raised will be rescued during Cycling
+      # and a warning will be logged, containing the error message.
+      def remove!(package)
+        remote_path = remote_path_for(package)
+
+        connection do |ftp|
+          transferred_files_for(package) do |local_file, remote_file|
+            Logger.message "#{storage_name} started removing " +
+                "'#{ local_file }' from '#{ ip }'."
+
+            ftp.delete(File.join(remote_path, remote_file))
+          end
+
+          ftp.rmdir(remote_path)
+        end
+      end
+
+      ##
+      # Creates (if they don't exist yet) all the directories on the remote
+      # server in order to upload the backup file. Net::FTP does not support
+      # paths to directories that don't yet exist when creating new
+      # directories. Instead, we split the parts up in to an array (for each
+      # '/') and loop through that to create the directories one by one.
+      # Net::FTP raises an exception when the directory it's trying to create
+      # already exists, so we have rescue it
+      def create_remote_path(remote_path, ftp)
+        path_parts = Array.new
+        remote_path.split('/').each do |path_part|
+          path_parts << path_part
+          begin
+            ftp.mkdir(path_parts.join('/'))
+          rescue Net::FTPPermError; end
+        end
+      end
+
+    end
+  end
+end

data/lib/wordpress_deploy/storage/local.rb

@@ -0,0 +1,82 @@
+# encoding: utf-8
+
+module WordpressDeploy
+  module Storage
+    class Local < Base
+
+      ##
+      # Path where the backup will be stored.
+      attr_accessor :path
+
+      ##
+      # Creates a new instance of the storage object
+      def initialize(model, storage_id = nil, &block)
+        super(model, storage_id)
+
+        @path ||= File.join(
+          File.expand_path(ENV['HOME'] || ''),
+          'backups'
+        )
+
+        instance_eval(&block) if block_given?
+
+        @path = File.expand_path(@path)
+      end
+
+      private
+
+      ##
+      # Transfers the archived file to the specified path
+      def transfer!
+        remote_path = remote_path_for(@package)
+        FileUtils.mkdir_p(remote_path)
+
+        files_to_transfer_for(@package) do |local_file, remote_file|
+          Logger.message "#{storage_name} started transferring '#{ local_file }'."
+
+          src_path = File.join(local_path, local_file)
+          dst_path = File.join(remote_path, remote_file)
+          FileUtils.send(transfer_method, src_path, dst_path)
+        end
+      end
+
+      ##
+      # Removes the transferred archive file(s) from the storage location.
+      # Any error raised will be rescued during Cycling
+      # and a warning will be logged, containing the error message.
+      def remove!(package)
+        remote_path = remote_path_for(package)
+
+        messages = []
+        transferred_files_for(package) do |local_file, remote_file|
+          messages << "#{storage_name} started removing '#{ local_file }'."
+        end
+        Logger.message messages.join("\n")
+
+        FileUtils.rm_r(remote_path)
+      end
+
+      ##
+      # Set and return the transfer method.
+      # If this Local Storage is not the last Storage for the Model,
+      # force the transfer to use a *copy* operation and issue a warning.
+      def transfer_method
+        return @transfer_method if @transfer_method
+
+        if self == @model.storages.last
+          @transfer_method = :mv
+        else
+          Logger.warn Errors::Storage::Local::TransferError.new(<<-EOS)
+            Local File Copy Warning!
+            The final backup file(s) for '#{@model.label}' (#{@model.trigger})
+            will be *copied* to '#{remote_path_for(@package)}'
+            To avoid this, when using more than one Storage, the 'Local' Storage
+            should be added *last* so the files may be *moved* to their destination.
+          EOS
+          @transfer_method = :cp
+        end
+      end
+
+    end
+  end
+end

data/lib/wordpress_deploy/storage/scp.rb

@@ -0,0 +1,99 @@
+# encoding: utf-8
+
+##
+# Only load the Net::SSH and Net::SCP library/gems
+# when the WordpressDeploy::Storage::SCP class is loaded
+WordpressDeploy::Dependency.load('net-ssh')
+WordpressDeploy::Dependency.load('net-scp')
+
+module WordpressDeploy
+  module Storage
+    class SCP < Base
+
+      ##
+      # Server credentials
+      attr_accessor :username, :password
+
+      ##
+      # Server IP Address and SCP port
+      attr_accessor :ip, :port
+
+      ##
+      # Path to store backups to
+      attr_accessor :path
+
+      ##
+      # Creates a new instance of the storage object
+      def initialize(model, storage_id = nil, &block)
+        super(model, storage_id)
+
+        @port ||= 22
+        @path ||= 'backups'
+
+        instance_eval(&block) if block_given?
+
+        @path = path.sub(/^\~\//, '')
+      end
+
+      private
+
+      ##
+      # Establishes a connection to the remote server
+      # and yields the Net::SSH connection.
+      # Net::SCP will use this connection to transfer backups
+      def connection
+        Net::SSH.start(
+          ip, username, :password => password, :port => port
+        ) {|ssh| yield ssh }
+      end
+
+      ##
+      # Transfers the archived file to the specified remote server
+      def transfer!
+        remote_path = remote_path_for(@package)
+
+        connection do |ssh|
+          ssh.exec!("mkdir -p '#{ remote_path }'")
+
+          files_to_transfer_for(@package) do |local_file, remote_file|
+            Logger.message "#{storage_name} started transferring " +
+                "'#{local_file}' to '#{ip}'."
+
+            ssh.scp.upload!(
+              File.join(local_path, local_file),
+              File.join(remote_path, remote_file)
+            )
+          end
+        end
+      end
+
+      ##
+      # Removes the transferred archive file(s) from the storage location.
+      # Any error raised will be rescued during Cycling
+      # and a warning will be logged, containing the error message.
+      def remove!(package)
+        remote_path = remote_path_for(package)
+
+        messages = []
+        transferred_files_for(package) do |local_file, remote_file|
+          messages << "#{storage_name} started removing " +
+              "'#{local_file}' from '#{ip}'."
+        end
+        Logger.message messages.join("\n")
+
+        errors = []
+        connection do |ssh|
+          ssh.exec!("rm -r '#{remote_path}'") do |ch, stream, data|
+            errors << data if stream == :stderr
+          end
+        end
+        unless errors.empty?
+          raise Errors::Storage::SCP::SSHError,
+            "Net::SSH reported the following errors:\n" +
+              errors.join("\n")
+        end
+      end
+
+    end
+  end
+end