wordpress-deploy 1.0.0.alpha1 → 1.0.0.alpha2

data/lib/wordpress_deploy/config.rb

@@ -1,68 +0,0 @@
-# encoding: utf-8
-
-module WordpressDeploy
-  module Config
-    DEFAULTS = {
-      :config_file  => 'config.rb',
-      :data_path    => 'data',
-      :log_path     => 'log',
-      :cache_path   => '.cache',
-      :tmp_path     => '.tmp'
-    }
-
-    class << self
-      # These paths are the basis for all scripts
-      attr_reader :base_dir
-      def base_dir
-        @base_dir   ||= Dir.pwd
-      end
-      attr_reader :config_dir
-      def config_dir
-        @config_dir ||= File.join(base_dir, "config")
-      end
-      attr_reader :sites_dir
-      def sites_dir
-        @sites_dir  ||= File.join(base_dir, "site")
-      end
-
-      attr_reader :ftp_config
-      def ftp_config
-        @ftp_config ||= YAML.load_file(File.join(config_dir, "ftp.yml"))
-      end
-
-      attr_reader :wp_config
-      def wp_config
-        @wp_config ||= YAML.load_file(File.join(config_dir, "wp-config.yml"))
-      end
-
-      attr_reader :wp_config_sample
-      def wp_config_sample
-        @wp_config_sample ||= File.join(sites_dir, "wp-config-sample.php")
-      end
-      attr_reader :wp_config_output
-      def wp_config_output
-        @wp_config_output ||= File.join(sites_dir, "wp-config.php")
-      end
-
-      attr_reader :environment
-      def environment
-        @environment ||= "production"
-      end
-      alias :env :environment
-
-      def environment=(new_env)
-        @environment = new_env.downcase
-      end
-
-      # The Salting array
-      def salt_array
-        @salt_array ||= %w{0 1 2 3 4 5 6 7 8 9 a b c d e f g h i j k l m n o p q r s t u v w x y z A B C D E F G H I J K L M N O P Q R S T U V W X Y Z ! @ # $ % ^ & * ( ) - ~ + = | / { } : ; , . ? < > [ ]}
-      end
-
-      def salt_keys
-        @salt_keys ||= %w{AUTH_KEY SECURE_AUTH_KEY LOGGED_IN_KEY NONCE_KEY AUTH_SALT SECURE_AUTH_SALT LOGGED_IN_SALT NONCE_SALT}
-      end
-
-    end
-  end
-end

data/lib/wordpress_deploy/database/base.rb

@@ -1,53 +0,0 @@
-# encoding: utf-8
-
-module WordpressDeploy
-  module Database
-    class Base
-      include WordpressDeploy::CLI::Helpers
-      include WordpressDeploy::Configuration::Helpers
-
-      ##
-      # Creates a new instance of the MongoDB database object
-      # * Called using super(model) from subclasses *
-      def initialize(model)
-        @model = model
-        load_defaults!
-      end
-
-      ##
-      # Super method for all child (database) objects. Every database object's #perform!
-      # method should call #super before anything else to prepare
-      def perform!
-        prepare!
-        log!
-      end
-
-      private
-
-      ##
-      # Defines the @dump_path and ensures it exists by creating it
-      def prepare!
-        @dump_path = File.join(
-          Config.tmp_path,
-          @model.trigger,
-          'databases',
-          self.class.name.split('::').last
-        )
-        FileUtils.mkdir_p(@dump_path)
-      end
-
-      ##
-      # Return the database name, with WordpressDeploy namespace removed
-      def database_name
-        self.class.to_s.sub('WordpressDeploy::', '')
-      end
-
-      ##
-      # Logs a message to the console and log file to inform
-      # the client that WordpressDeploy is dumping the database
-      def log!
-        Logger.message "#{ database_name } started dumping and archiving '#{ name }'."
-      end
-    end
-  end
-end

data/lib/wordpress_deploy/pipeline.rb

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

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

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