statistrano 1.2.0

data/lib/statistrano/config/configurable.rb

@@ -0,0 +1,53 @@
+module Statistrano
+  class Config
+    module Configurable
+
+      def configuration
+        @_configuration ||= Config.new()
+      end
+
+      def option key, value=nil, proc=nil
+        if proc
+          configuration.options[key] = { call: proc }
+        else
+          configuration.options[key] = value
+        end
+      end
+
+      def options *args
+        args.each { |a| option(a) }
+      end
+
+      def task name, method, description
+        configuration.tasks[name] = {
+          method: method,
+          desc: description
+        }
+      end
+
+      # add a config method to objects that
+      # extend Configurable
+      #
+      def self.extended extending_obj
+        extending_obj.send :define_method,
+                           :config,
+                           -> {
+                              @_config ||= Config.new( self.class.configuration.options,
+                                                       self.class.configuration.tasks )
+                           }
+      end
+
+      # make sure that classes that inherit from
+      # classes that have been configured also inherit
+      # the configuration of the parent class
+      #
+      def inherited subclass
+        subclass.superclass.class_eval do
+          subclass.configuration.options.merge!  subclass.superclass.configuration.options
+          subclass.configuration.tasks.merge! subclass.superclass.configuration.tasks
+        end
+      end
+
+    end
+  end
+end

data/lib/statistrano/config/rake_task_with_context_creation.rb

@@ -0,0 +1,43 @@
+module Statistrano
+  class Config
+
+    module RakeTaskWithContextCreation
+
+      def self.included base
+        base.module_eval do
+          def user_task_namespaces
+            @_user_task_namespaces ||= []
+          end
+
+          def user_tasks
+            @_user_tasks ||= []
+          end
+        end
+      end
+
+      def namespace namespace, &block
+        context = Context.new (user_task_namespaces + [namespace])
+        context.instance_eval &block
+        user_tasks.push *context.user_tasks
+      end
+
+      def task name, desc=nil, &block
+        task = { name: name,
+                 namespaces: user_task_namespaces,
+                 block: block }
+        task.merge!(desc: desc) if desc
+
+        user_tasks.push task
+      end
+
+      class Context
+        include RakeTaskWithContextCreation
+
+        def initialize namespaces=[]
+          @_user_task_namespaces = namespaces
+        end
+      end
+    end
+
+  end
+end

data/lib/statistrano/config.rb

@@ -0,0 +1,52 @@
+require_relative 'config/configurable'
+require_relative 'config/rake_task_with_context_creation'
+
+module Statistrano
+  class Config
+    include RakeTaskWithContextCreation
+
+    attr_reader :options
+    attr_reader :tasks
+
+    # initalize with the potential for seed options
+    # this is required so that when config'd classes
+    # are extended we can pass that configuration along
+    def initialize options=nil, tasks=nil
+      @options = options.nil? ? {} : options.clone
+      @tasks   = tasks.nil?   ? {} : tasks.clone
+
+      @options.each do |key,val|
+        define_option_accessor key.to_sym
+      end
+    end
+
+    private
+
+      def define_option_accessor name
+        define_singleton_method(name) do |*args, &block|
+          if block
+            if args.first == :call
+              @options[name] = { call: block }
+            else
+              @options[name] = block
+            end
+            return
+          end
+
+          if args.length == 1
+            @options[name] = args[0]
+          elsif args.empty?
+            if @options[name].respond_to? :fetch
+              @options[name].fetch( :call, -> { @options[name] } ).call
+            else
+              @options[name]
+            end
+          else
+            raise ArgumentError, "wrong number of arguments (#{args.length} for 0..1)"
+          end
+        end
+        define_singleton_method("#{name}=") { |arg| @options[name] = arg }
+      end
+
+  end
+end

data/lib/statistrano/deployment/log_file.rb

@@ -0,0 +1,44 @@
+module Statistrano
+  module Deployment
+    class LogFile
+
+      attr_reader :resolved_path, :remote, :file
+
+      def initialize path, remote
+        @remote        = remote
+        @resolved_path = resolve_path path
+        @file          = Remote::File.new @resolved_path, remote
+      end
+
+      def append! log_entry
+        file.append_content! log_entry.to_json
+      end
+
+      def last_entry
+        entries(1).last || {}
+      end
+
+      def tail length=10
+        entries(length)
+      end
+
+      private
+
+        def entries length=10
+          entries = file.content.split("\n") || []
+          entries.reverse[0...length].map do |e|
+            Util.symbolize_hash_keys( JSON.parse(e) )
+          end
+        end
+
+        def resolve_path path
+          if path.start_with? '/'
+            path
+          else
+            File.join( remote.config.remote_dir, path )
+          end
+        end
+
+    end
+  end
+end

data/lib/statistrano/deployment/manifest.rb

@@ -0,0 +1,88 @@
+module Statistrano
+  module Deployment
+    class Manifest
+
+      attr_reader :remote_dir, :remote, :file
+
+      def initialize remote_dir, remote
+        @remote_dir = remote_dir
+        @remote     = remote
+        @file       = Remote::File.new remote_path, remote
+      end
+
+      # return an array of records from the manifest
+      # they are processed to all have symbolized keys
+      #
+      def data
+        @_data ||= Array( JSON.parse(raw) ).map { |h| Util.symbolize_hash_keys(h) }
+      rescue JSON::ParserError => e
+        Log.error "manifest on #{remote.config.hostname} had invalid JSON\n",
+                  e.message
+      end
+
+      # push data into the manifest array updating a
+      # record if it matches with the `match_key`
+      #
+      # not that if you have used the `push` method previously
+      # all duplicates with the matching key **will** be removed
+      #
+      def put data, match_key
+        remove_if { |i| i[match_key] == data[match_key] }
+        push data
+      end
+
+      # pushes a data has into the manifest's array
+      #
+      def push new_data
+        unless new_data.respond_to? :to_json
+          raise ArgumentError, "data must be serializable as JSON"
+        end
+
+        data << Util.symbolize_hash_keys(new_data)
+      end
+
+      # pass a condition to remove records from the
+      # manifest if it returns true
+      #
+      # example:
+      #   to remove all records with the name "name"
+      #
+      #   manifest.remove_if |release|
+      #     release[:name] == "name"
+      #   end
+      #
+      def remove_if &condition
+        data.delete_if do |item|
+          condition.call item
+        end
+      end
+
+      # update the manifest using the data
+      # currently stored on the object
+      #
+      def save!
+        file.update_content! serialize
+      end
+
+      private
+
+        def raw
+          content = file.content
+          if content.empty?
+            return "[]"
+          else
+            return content
+          end
+        end
+
+        def serialize data=data
+          data.to_json
+        end
+
+        def remote_path
+          File.join( remote_dir, 'manifest.json' )
+        end
+
+    end
+  end
+end

data/lib/statistrano/deployment/rake_tasks.rb

@@ -0,0 +1,74 @@
+module Statistrano
+  module Deployment
+
+      module RakeTasks
+        class << self
+
+          # Add rake tasks
+          include ::Rake::DSL
+
+          # Register the rake tasks for the deployment
+          # @return [Void]
+          def register deployment
+            deployment.config.tasks.each do |task_name, task_attrs|
+              in_namespace rake_namespace(deployment) do
+                register_task deployment, task_name, task_attrs
+              end
+            end
+
+            deployment.config.user_tasks.each do |task_obj|
+              in_namespace rake_namespace(deployment) do
+                register_in_namespace_recursive deployment,
+                                                task_obj[:name],
+                                                task_obj[:desc],
+                                                task_obj[:namespaces],
+                                                task_obj[:block]
+              end
+            end
+          end
+
+          private
+
+            def rake_namespace deployment
+              deployment.name.to_sym
+            end
+
+            def in_namespace namespace, &block
+              namespace namespace do
+                yield
+              end
+            end
+
+            def register_task deployment, task_name, attrs={}
+              desc attrs[:desc]
+              task task_name do
+                deployment.public_send attrs[:method]
+              end
+            end
+
+            def register_in_namespace_recursive deployment, task_name, task_desc, task_space, block
+              if task_space.empty?
+                register_user_task deployment, task_name, task_desc, block
+              else
+                in_namespace task_space.first do
+                  register_in_namespace_recursive deployment, task_name, task_desc, task_space[1..-1], block
+                end
+              end
+            end
+
+            def register_user_task deployment, task_name, task_desc, block
+              t = task task_name do
+                if block.arity == 1
+                  block.call deployment
+                else
+                  block.call
+                end
+              end
+              t.add_description(task_desc) if task_desc
+            end
+
+        end
+      end
+
+  end
+end

data/lib/statistrano/deployment/registerable.rb

@@ -0,0 +1,11 @@
+module Statistrano
+  module Deployment
+
+    module Registerable
+      def register_strategy name
+        Strategy.register( self, name )
+      end
+    end
+
+  end
+end

data/lib/statistrano/deployment/releaser/revisions.rb

@@ -0,0 +1,163 @@
+module Statistrano
+  module Deployment
+    module Releaser
+
+      class Revisions
+        include Strategy::InvokeTasks
+
+        attr_reader :release_name
+
+        def initialize
+          @release_name = Time.now.to_i.to_s
+        end
+
+        def create_release remote, build_data={}
+          setup_release_path      remote
+          rsync_to_remote         remote
+          invoke_pre_symlink_task remote
+          symlink_release         remote
+          add_release_to_manifest remote, build_data
+          prune_releases          remote
+        end
+
+        def setup_release_path remote
+          current_release = current_release remote
+          remote.create_remote_dir releases_path(remote)
+
+          if current_release.empty?
+            remote.create_remote_dir release_path(remote)
+          else
+            remote.run "cp -a #{release_path(remote, current_release)} #{release_path(remote)}"
+          end
+        end
+
+        def rsync_to_remote remote
+          resp = remote.rsync_to_remote local_path(remote), release_path(remote)
+          unless resp.success?
+            abort()
+          end
+        end
+
+        def symlink_release remote, release=nil
+          remote.run "ln -nfs #{release_path(remote, release)} #{public_path(remote)}"
+        end
+
+        def prune_releases remote
+          remove_untracked_releases remote
+          remove_releases_beyond_release_count remote
+        end
+
+        def list_releases remote
+          manifest = new_manifest remote
+          manifest.data.keep_if do |rel|
+            rel.has_key?(:release)
+          end.sort_by do |rel|
+            rel[:release]
+          end.reverse
+        end
+
+        # merge of manifest & log data (if a log)
+        def current_release_data remote
+          release_data = new_manifest(remote).data.last
+
+          if remote.config.log_file_path
+            release_data.merge! log_file(remote).last_entry 
+          end
+
+          release_data
+        end
+
+        def rollback_release remote
+          manifest = new_manifest remote
+          releases = tracked_releases remote, manifest
+
+          unless releases.length > 1
+            return Log.error "There is only one release, best not to remove it"
+          end
+
+          symlink_release remote, releases[1]
+          remove_release releases[0], remote, manifest
+          manifest.save!
+        end
+
+        def add_release_to_manifest remote, build_data={}
+          manifest = new_manifest remote
+          manifest.push build_data.merge(release: release_name)
+          manifest.save!
+        end
+
+        private
+
+          def new_manifest remote
+            Deployment::Manifest.new remote.config.remote_dir, remote
+          end
+
+          def log_file remote
+            Deployment::LogFile.new remote.config.log_file_path, remote
+          end
+
+          def remove_releases_beyond_release_count remote
+            manifest = new_manifest remote
+            beyond   = tracked_releases(remote, manifest)[remote.config.release_count..-1]
+            Array(beyond).each do |beyond|
+              remove_release beyond, remote, manifest
+            end
+            manifest.save!
+          end
+
+          def remove_release release_name, remote, manifest
+            if release_name == current_release(remote)
+              Log.warn "did not remove release '#{release_name}' because it is current"
+              return
+            end
+
+            manifest.remove_if { |r| r[:release] == release_name }
+            remote.run("rm -rf #{File.join(releases_path(remote), release_name)}")
+          end
+
+          def remove_untracked_releases remote
+            manifest = new_manifest remote
+            (remote_releases(remote) - tracked_releases(remote)).each do |untracked_release|
+              remove_release untracked_release, remote, manifest
+            end
+          end
+
+          def current_release remote
+            resp = remote.run("readlink #{public_path(remote)}")
+            resp.stdout.sub( /#{releases_path(remote)}\/?/, '' ).strip
+          end
+
+          def remote_releases remote
+            remote.run("ls -m #{releases_path(remote)}").stdout
+                  .split(',').map(&:strip)
+          end
+
+          def tracked_releases remote, manifest=nil
+            manifest ||= new_manifest remote
+            manifest.data.map do |data|
+              data.fetch(:release, nil)
+            end.compact.sort.reverse
+          end
+
+          def local_path remote=nil
+            File.join( Dir.pwd, remote.config.local_dir )
+          end
+
+          def releases_path remote=nil
+            File.join( remote.config.remote_dir, remote.config.release_dir )
+          end
+
+          def release_path remote=nil, release=nil
+            release ||= release_name
+            File.join( releases_path(remote), release )
+          end
+
+          def public_path remote=nil
+            File.join( remote.config.remote_dir, remote.config.public_dir )
+          end
+
+      end
+
+    end
+  end
+end

data/lib/statistrano/deployment/releaser/single.rb

@@ -0,0 +1,48 @@
+module Statistrano
+  module Deployment
+    module Releaser
+
+      class Single
+
+        attr_reader :release_name
+
+        def initialize
+          @release_name = Time.now.to_i.to_s
+        end
+
+        def create_release remote, build_data={}
+          setup remote
+          rsync_to_remote remote
+        end
+
+        def setup remote
+          Log.info   "Setting up the remote"
+          remote.run "mkdir -p #{remote_path(remote)}"
+        end
+
+        def rsync_to_remote remote
+          resp = remote.rsync_to_remote local_path(remote), remote_path(remote)
+          unless resp.success?
+            abort()
+          end
+        end
+
+        private
+
+          def local_path remote
+            File.join( Dir.pwd, remote.config.local_dir )
+          end
+
+          def remote_path remote=nil
+            if remote.config.respond_to?(:public_dir) && remote.config.public_dir
+              return File.join( remote.config.remote_dir, remote.config.public_dir )
+            else
+              return remote.config.remote_dir
+            end
+          end
+
+      end
+
+    end
+  end
+end

data/lib/statistrano/deployment/releaser.rb

@@ -0,0 +1,2 @@
+require_relative 'releaser/single'
+require_relative 'releaser/revisions'