ferry 1.3.3 → 2.0.0

data/lib/ferry/configuration/servers.rb

@@ -0,0 +1,69 @@
+require 'set'
+require 'ferry/configuration'
+require 'ferry/configuration/filter'
+
+module Ferry
+  class Configuration
+    class Servers
+      include Enumerable
+
+      def add_host(host, properties={})
+        new_host = Server[host]
+        if server = servers.find { |s| s.matches? new_host }
+          server.user = new_host.user if new_host.user
+          server.port = new_host.port if new_host.port
+          server.with(properties)
+        else
+          servers << new_host.with(properties)
+        end
+      end
+
+      def add_role(role, hosts, options={})
+        options_deepcopy = Marshal.dump(options.merge(roles: role))
+        Array(hosts).each { |host| add_host(host, Marshal.load(options_deepcopy)) }
+      end
+
+      def roles_for(names)
+        options = extract_options(names)
+        s = Filter.new(:role, names).filter(servers)
+        s.select { |server| server.select?(options) }
+      end
+
+      def role_properties_for(rolenames)
+        roles = rolenames.to_set
+        rps = Set.new unless block_given?
+        roles_for(rolenames).each do |host|
+          host.roles.intersection(roles).each do |role|
+            [host.properties.fetch(role)].flatten(1).each do |props|
+              if block_given?
+                yield host, role, props
+              else
+                rps << (props || {}).merge( role: role, hostname: host.hostname )
+              end
+            end
+          end
+        end
+        block_given? ? nil: rps
+      end
+
+      def fetch_primary(role)
+        hosts = roles_for([role])
+        hosts.find(&:primary) || hosts.first
+      end
+
+      def each
+        servers.each { |server| yield server }
+      end
+
+      private
+
+      def servers
+        @servers ||= []
+      end
+
+      def extract_options(array)
+        array.last.is_a?(::Hash) ? array.pop : {}
+      end
+    end
+  end
+end

data/lib/ferry/defaults.rb

@@ -0,0 +1,3 @@
+# default options for user to replace in the deploy_ferry.rb
+# still not sure what we can put here ...
+# see deploy_ferry.rb.erb for ideas

data/lib/ferry/deploy.rb

@@ -0,0 +1,3 @@
+require 'ferry/framework'
+
+load File.expand_path("../tasks/deploy.rake", __FILE__)

data/lib/ferry/dotfile.rb

@@ -0,0 +1,2 @@
+dotfile = Pathname.new(File.join(Dir.home, '.ferryfile'))
+load dotfile if dotfile.file?

data/lib/ferry/dsl.rb

@@ -0,0 +1,64 @@
+require 'etc'
+require 'ferry/dsl/task_enhancements'
+require 'ferry/dsl/paths'
+require 'ferry/dsl/stages'
+require 'ferry/dsl/env'
+require 'ferry/configuration/filter'
+
+module Ferry
+  module DSL
+    include TaskEnhancements
+    include Env
+    include Paths
+    include Stages
+
+    def invoke(task, *args)
+      Rake::Task[task].invoke(*args)
+    end
+
+    def t(key, options={})
+      I18n.t(key, options.merge(scope: :ferry))
+    end
+
+    def scm
+      fetch(:scm)
+    end
+
+    def sudo(*args)
+      execute :sudo, *args
+    end
+
+    def revision_log_message
+      fetch(:revision_log_message,
+        t(:revision_log_message,
+          branch: fetch(:branch),
+          user: local_user,
+          sha: fetch(:current_revision),
+          release: fetch(:release_timestamp))
+       )
+    end
+
+    def rollback_log_message
+      t(:rollback_log_message, user: local_user, release: fetch(:rollback_timestamp))
+    end
+
+    def local_user
+      fetch(:local_user)
+    end
+
+    def lock(locked_version)
+      VersionValidator.new(locked_version).verify
+    end
+
+    def on(hosts, options={}, &block)
+      subset_copy = Marshal.dump(Configuration.env.filter(hosts))
+      SSHKit::Coordinator.new(Marshal.load(subset_copy)).each(options, &block)
+    end
+
+    def run_locally(&block)
+      SSHKit::Backend::Local.new(&block).run
+    end
+
+  end
+end
+self.extend Ferry::DSL

data/lib/ferry/dsl/env.rb

@@ -0,0 +1,81 @@
+module Ferry
+  module DSL
+    module Env
+
+      def configure_backend
+        env.configure_backend
+      end
+
+      def fetch(key, default=nil, &block)
+        env.fetch(key, default, &block)
+      end
+
+      def any?(key)
+        value = fetch(key)
+        if value && value.respond_to?(:any?)
+          value.any?
+        else
+          !fetch(key).nil?
+        end
+      end
+
+      def set(key, value)
+        env.set(key, value)
+      end
+
+      def set_if_empty(key, value)
+        env.set_if_empty(key, value)
+      end
+
+      def delete(key)
+        env.delete(key)
+      end
+
+      def ask(key, value, options={})
+        env.ask(key, value, options)
+      end
+
+      def role(name, servers, options={})
+        env.role(name, servers, options)
+      end
+
+      def server(name, properties={})
+        env.server(name, properties)
+      end
+
+      def roles(*names)
+        env.roles_for(names.flatten)
+      end
+
+      def role_properties(*names, &block)
+        env.role_properties_for(names, &block)
+      end
+
+      def release_roles(*names)
+        if names.last.is_a? Hash
+          names.last.merge!({ :exclude => :no_release })
+        else
+          names << { exclude: :no_release }
+        end
+        roles(*names)
+      end
+
+      def primary(role)
+        env.primary(role)
+      end
+
+      def env
+        Configuration.env
+      end
+
+      def release_timestamp
+        env.timestamp.strftime("%Y%m%d%H%M%S")
+      end
+
+      def asset_timestamp
+        env.timestamp.strftime("%Y%m%d%H%M.%S")
+      end
+
+    end
+  end
+end

data/lib/ferry/dsl/paths.rb

@@ -0,0 +1,103 @@
+require 'pathname'
+module Ferry
+  module DSL
+    module Paths
+
+      def deploy_to
+        fetch(:deploy_to)
+      end
+
+      def deploy_path
+        Pathname.new(deploy_to)
+      end
+
+      def current_path
+        deploy_path.join('current')
+      end
+
+      def releases_path
+        deploy_path.join('releases')
+      end
+
+      def release_path
+        fetch(:release_path, current_path)
+      end
+
+      def set_release_path(timestamp=now)
+        set(:release_timestamp, timestamp)
+        set(:release_path, releases_path.join(timestamp))
+      end
+
+      def stage_config_path
+        Pathname.new fetch(:stage_config_path, 'config/deploy')
+      end
+
+      def deploy_config_path
+        Pathname.new fetch(:deploy_config_path, 'config/deploy.rb')
+      end
+
+      def repo_url
+        require 'cgi'
+        require 'uri'
+        if fetch(:git_http_username) and fetch(:git_http_password)
+          URI.parse(fetch(:repo_url)).tap do |repo_uri|
+            repo_uri.user     = fetch(:git_http_username)
+            repo_uri.password = CGI.escape(fetch(:git_http_password))
+          end.to_s
+        elsif fetch(:git_http_username)
+          URI.parse(fetch(:repo_url)).tap do |repo_uri|
+            repo_uri.user = fetch(:git_http_username)
+          end.to_s
+        else
+          fetch(:repo_url)
+        end
+      end
+
+      def repo_path
+        Pathname.new(fetch(:repo_path, ->(){deploy_path.join('repo')}))
+      end
+
+      def shared_path
+        deploy_path.join('shared')
+      end
+
+      def revision_log
+        deploy_path.join('revisions.log')
+      end
+
+      def now
+        env.timestamp.strftime("%Y%m%d%H%M%S")
+      end
+
+      def asset_timestamp
+        env.timestamp.strftime("%Y%m%d%H%M.%S")
+      end
+
+      def linked_dirs(parent)
+        paths = fetch(:linked_dirs)
+        join_paths(parent, paths)
+      end
+
+      def linked_files(parent)
+        paths = fetch(:linked_files)
+        join_paths(parent, paths)
+      end
+
+      def linked_file_dirs(parent)
+        map_dirnames(linked_files(parent))
+      end
+
+      def linked_dir_parents(parent)
+        map_dirnames(linked_dirs(parent))
+      end
+
+      def join_paths(parent, paths)
+        paths.map { |path| parent.join(path) }
+      end
+
+      def map_dirnames(paths)
+        paths.map { |path| path.dirname }
+      end
+    end
+  end
+end

data/lib/ferry/dsl/stages.rb

@@ -0,0 +1,19 @@
+module Ferry
+  module DSL
+    module Stages
+
+      def stages
+        Dir[stage_definitions].map { |f| File.basename(f, '.rb') }
+      end
+
+      def stage_definitions
+        stage_config_path.join('*.rb')
+      end
+
+      def stage_set?
+        !!fetch(:stage, false)
+      end
+
+    end
+  end
+end

data/lib/ferry/dsl/task_enhancements.rb

@@ -0,0 +1,65 @@
+require 'ferry/upload_task'
+
+module Ferry
+  module TaskEnhancements
+    def before(task, prerequisite, *args, &block)
+      prerequisite = Rake::Task.define_task(prerequisite, *args, &block) if block_given?
+      Rake::Task[task].enhance [prerequisite]
+    end
+
+    def after(task, post_task, *args, &block)
+      Rake::Task.define_task(post_task, *args, &block) if block_given?
+      Rake::Task[task].enhance do
+        Rake::Task[post_task].invoke
+      end
+    end
+
+    def remote_file(task)
+      target_roles = task.delete(:roles) { :all }
+      define_remote_file_task(task, target_roles)
+    end
+
+    def define_remote_file_task(task, target_roles)
+      Ferry::UploadTask.define_task(task) do |t|
+        prerequisite_file = t.prerequisites.first
+        file = shared_path.join(t.name)
+
+        on roles(target_roles) do
+          unless test "[ -f #{file.to_s.shellescape} ]"
+            info "Uploading #{prerequisite_file} to #{file}"
+            upload! File.open(prerequisite_file), file
+          end
+        end
+
+      end
+    end
+
+    def ensure_stage
+      Rake::Task.define_task(:ensure_stage) do
+        unless stage_set?
+          puts t(:stage_not_set)
+          exit 1
+        end
+      end
+    end
+
+    def tasks_without_stage_dependency
+      stages + default_tasks
+    end
+
+    def default_tasks
+      %w{install}
+    end
+
+    def exit_deploy_because_of_exception(ex)
+      warn t(:deploy_failed, ex: ex.message)
+      invoke 'deploy:failed'
+      exit(false)
+    end
+
+    def deploying?
+      fetch(:deploying, false)
+    end
+
+  end
+end

data/lib/ferry/framework.rb

@@ -0,0 +1,2 @@
+load File.expand_path("../tasks/framework.rake", __FILE__)
+require 'ferry/install'

data/lib/ferry/i18n.rb

@@ -0,0 +1,18 @@
+require 'i18n'
+
+en = {
+  starting: 'Starting',
+  installing: 'Installing',
+  set_sail: 'Set Sail!',
+  moving: 'Moving',
+  completed: 'Completed'
+  },
+  error: 'Some error'
+  }
+}
+
+I18n.backend.store_translations(:en, { ferry: en })
+
+if I18n.respond_to?(:enforce_available_locales=)
+  I18n.enforce_available_locales = true
+end

data/lib/ferry/install.rb

@@ -0,0 +1 @@
+load File.expand_path(File.join(File.dirname(__FILE__),'tasks/install.rake'))