mina 0.3.8 → 1.0.0.beta1

data/docs/migrating.md

@@ -0,0 +1,30 @@
+Migrating from 0.3.x to 1.0
+--------------------
+# DSL
+
+## old
+* `queue`         -> `command`  # adds command to queue
+* `queue!`        -> `command`  # it will output the command if verbose is true
+* `to`            -> `on`       # changes queue name
+* `in_directory`  -> `in_path`  # wraps commands to be run in specified path
+
+## new
+* `run`                         # runs commands on a specified backend
+* `comment`                     # adds a 'echo -----> #{command}' to queue
+
+**Other commands have been removed!**
+
+# Setting variables
+
+## same
+* `set`                         # remained for setting variables
+
+## new
+* `fetch`                       # **ALL** variables now need to be fetched with `fetch`. Removed `method_missing`
+* `set?`
+* `ensure!`
+
+# Deploy variables
+
+All `*_path` variables (`:current_path`, `:shared_path`, ...) now include `:deploy_to`
+* `#{fetch(:deploy_to)}/#{fetch(:current_path)}` -> `fetch(:current_path)`

data/docs/writing_your_own_tasks.md

@@ -0,0 +1,117 @@
+Writing your own tasks
+--------------------
+
+# Defining tasks
+
+The file `deploy.rb` is simply a Rakefile invoked by Rake. In fact, `mina` is
+mostly an alias that invokes Rake to load `deploy.rb`.
+
+``` ruby
+# Sample config/deploy.rb
+set :domain, 'your.server.com'
+
+task :restart do
+  comment 'Restart application'
+  command "passenger-config restart-app --ignore-app-not-running #{deploy_to}"
+end
+```
+
+As it's all Rake, you can define tasks that you can invoke using `mina`. In this
+example, it provides the `mina restart` command.
+
+The magic of Mina is in the new commands it gives you.
+
+The `command` command queues up Bash commands to be run on the remote server.
+If you invoke `mina restart`, it will invoke the task above and run the queued
+commands on the remote server `your.server.com` via SSH.
+
+# Workflow
+
+WIP
+
+# DSL
+
+## Helpers
+
+### invoke
+Invokes another Rake task.
+
+``` ruby
+invoke :'git:clone'
+invoke :restart
+```
+
+### command
+Adds a command to the command queue.
+
+This queues code to be run on the current queue name (defaults to `:default`).
+
+``` ruby
+command 'ls -al' # => [ls -al]
+```
+
+### comment
+Adds a comment to the command queue.
+
+``` ruby
+comment 'ls -al' # => [echo '-----> ls -al']
+```
+
+### run
+Runs the given block on the defined backend
+
+``` ruby
+run :remote do
+  command 'ls -al'
+end
+```
+
+### on
+Change the queue name for the given block. Use this if you have multiple places where commands need to end up. Mainly used in `deploy` task.
+
+``` ruby
+on :launch do
+  invoke :restart
+end
+```
+
+### in_path
+Change the path the commands in the given block is run.
+
+``` ruby
+in_path('some/new/path') do
+  command 'ls -al' # => cd some/new/path && ls -al
+end
+```
+
+## Configuration
+
+### set
+Sets configuration variable. Can a value or a proc/lambda.
+
+``` ruby
+set :deploy_to -> '/path/to/deploy'
+```
+
+### fetch
+Gets configuration variable. Runs `.call` if callable.
+Returns nil if not set. If default parameter is passed returns default if not set.
+
+``` ruby
+fetch(:deploy_to)
+fetch(:deploy_to, 'some_default')
+```
+
+### set?
+Checks if a variable is set.
+
+``` ruby
+set?(:deploy_to)
+```
+
+### ensure!
+Raises an error if variable is not set
+
+``` ruby
+ensure!(:deploy_to)
+```

data/lib/Minafile

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+
+require 'mina/install'

data/lib/mina.rb

@@ -1,24 +1,36 @@
-module Mina
-  PREFIX = File.dirname(__FILE__)
-  ROOT = File.expand_path('../../', __FILE__)
+require 'rake'
+Rake.application.options.trace = true
 
-  require 'mina/version'
+require 'pry'
+# require 'awesome_print'
 
-  autoload :DeployHelpers, 'mina/deploy_helpers'
-  autoload :OutputHelpers, 'mina/output_helpers'
-  autoload :SshHelpers, 'mina/ssh_helpers'
-  autoload :LocalHelpers, 'mina/local_helpers'
-  autoload :ExecHelpers, 'mina/exec_helpers'
-  autoload :Helpers, 'mina/helpers'
-  autoload :Settings, 'mina/settings'
-  autoload :Tools, 'mina/tools'
+require 'forwardable'
+require 'shellwords'
+require 'singleton'
+require 'open4'
 
-  Error = Class.new(Exception)
-  class Failed < Error
-    attr_accessor :exitstatus
-  end
+require 'mina/version'
+require 'mina/configuration'
+require 'mina/dsl'
+require 'mina/helpers/output'
+require 'mina/helpers/internal'
+require 'mina/commands'
+require 'mina/runner'
+require 'mina/runner/pretty'
+require 'mina/runner/system'
+require 'mina/runner/exec'
+require 'mina/runner/printer'
+require 'mina/backend/local'
+require 'mina/backend/remote'
+require 'mina/application'
 
-  def self.root_path(*a)
-    File.join ROOT, *a
+module Mina
+  # Error = Class.new(Exception)
+  # class Failed < Error
+  #   attr_accessor :exitstatus
+  # end
+  #
+  def self.root_path(*args)
+    File.join File.expand_path('../../', __FILE__), *args
   end
 end

data/lib/mina/application.rb

@@ -0,0 +1,74 @@
+module Mina
+  class Application < Rake::Application
+    def initialize
+      super
+      @rakefiles = ['config/deploy.rb', minafile]
+    end
+
+    def name
+      'mina'
+    end
+
+    def run
+      Rake.application = self
+      super
+    end
+
+    def sort_options(options)
+      not_applicable_to_mina = %w(quiet silent verbose dry-run)
+      options.reject! do |(switch, *)|
+        switch =~ /--#{Regexp.union(not_applicable_to_mina)}/
+      end
+
+      super.push(version, verbose, simulate, debug_configuration_variables)
+    end
+
+    def top_level_tasks
+      @top_level_tasks << :debug_configuration_variables
+      @top_level_tasks << :run_commands
+    end
+
+    private
+
+    def minafile
+      File.expand_path(File.join(File.dirname(__FILE__), '..', 'Minafile'))
+    end
+
+    def version
+      ['--version', '-V',
+       'Display the program version.',
+       lambda do |_value|
+         puts "Mina, version v#{Mina::VERSION}"
+         exit
+       end
+      ]
+    end
+
+    def verbose
+      ['--verbose', '-v',
+       'Print more info',
+       lambda do |_value|
+         Mina::Configuration.instance.set(:verbose, true)
+       end
+      ]
+    end
+
+    def simulate
+      ['--simulate', '-s',
+       'Do a simulate run without executing actions',
+       lambda do |_value|
+         Mina::Configuration.instance.set(:simulate, true)
+       end
+      ]
+    end
+
+    def debug_configuration_variables
+      ['--debug-configuration-variables', '-d',
+       'Display the defined config variables before runnig the tasks.',
+       lambda do |_value|
+         Mina::Configuration.instance.set(:debug_configuration_variables, true)
+       end
+      ]
+    end
+  end
+end

data/lib/mina/backend/local.rb

@@ -0,0 +1,22 @@
+module Mina
+  module Backend
+    class Local
+      attr_reader :commands, :configuration
+      extend Forwardable
+      def_delegators :configuration, :fetch, :set?
+
+      def initialize(commands)
+        @configuration = Mina::Configuration.instance
+        @commands = commands
+      end
+
+      def prepare
+        if fetch(:simulate)
+          ['#!/usr/bin/env bash', '# Executing the following:', '#', commands, ' '].join("\n")
+        else
+          Shellwords.escape(commands)
+        end
+      end
+    end
+  end
+end

data/lib/mina/backend/remote.rb

@@ -0,0 +1,42 @@
+module Mina
+  module Backend
+    class Remote
+      attr_reader :commands, :configuration
+
+      extend Forwardable
+      def_delegators :configuration, :fetch, :set?
+
+      def initialize(commands)
+        @configuration = Mina::Configuration.instance
+        @commands = commands
+      end
+
+      def prepare
+        if fetch(:simulate)
+          [
+            '#!/usr/bin/env bash', "# Executing the following via '#{ssh}':",
+            '#', commands, ' '
+          ].join("\n")
+        else
+          command = Shellwords.escape(commands)
+          [ssh, '--', command].join(' ')
+        end
+      end
+
+      private
+
+      def ssh
+        fail 'No domain set' unless set?(:domain)
+        args = fetch(:domain)
+        args = "#{fetch(:user)}@#{fetch(:domain)}" if set?(:user)
+        args << " -i #{fetch(:identity_file)}" if set?(:identity_file)
+        args << " -p #{fetch(:port)}" if set?(:port)
+        args << ' -A' if set?(:forward_agent)
+        args << " #{fetch(:ssh_options)}" if set?(:ssh_options)
+        args << ' -tt'
+        "ssh #{args}"
+      end
+
+    end
+  end
+end

data/lib/mina/commands.rb

@@ -0,0 +1,45 @@
+module Mina
+  class Commands
+    extend Forwardable
+    include Helpers::Internal
+
+    attr_reader :queue
+    attr_accessor :stage
+    def_delegators :queue, :find, :fetch, :process
+
+    def initialize(stage = :default)
+      @stage = stage
+      @queue = Hash.new { |hash, key| hash[key] = [] }
+    end
+
+    def command(code, quiet: false, indent: nil)
+      code = indent(indent, code) if indent
+      queue[stage] << (quiet ? code : echo_cmd(code))
+    end
+
+    def comment(code, indent: nil)
+      if indent
+        queue[stage] << indent(indent, "echo '-----> #{code}'")
+      else
+        queue[stage] << "echo '-----> #{code}'"
+      end
+    end
+
+    def fetch(stage)
+      queue.delete(stage) || []
+    end
+
+    def process(path = nil)
+      if path
+        queue[stage].unshift("echo '$ cd #{path}'") if Mina::Configuration.instance.fetch(:verbose)
+        "(cd #{path} && #{queue[stage].join(' && ')})"
+      else
+        fetch(stage).join("\n")
+      end
+    end
+
+    def run(backend)
+      Mina::Runner.new(process, backend).run
+    end
+  end
+end

data/lib/mina/configuration.rb

@@ -0,0 +1,36 @@
+module Mina
+  class Configuration
+    include Singleton
+
+    attr_reader :variables
+
+    def initialize
+      @variables ||= {}
+    end
+
+    def set(key, value = nil, &block)
+      variables[key] = block || value
+    end
+
+    def fetch(key, default = nil)
+      value = ENV[key.to_s] || variables.fetch(key, default)
+      value.respond_to?(:call) ? value.call : value
+    end
+
+    def remove(key)
+      variables.delete(key)
+    end
+
+    def set?(key)
+      !variables.fetch(key, nil).nil?
+    end
+
+    def ensure!(key)
+      fail "#{key} must be defined!" unless set?(key)
+    end
+
+    def reset!
+      @variables = {}
+    end
+  end
+end

data/lib/mina/dsl.rb

@@ -0,0 +1,47 @@
+module Mina
+  module DSL
+    attr_reader :commands
+
+    extend Forwardable
+    def_delegators :configuration, :fetch, :set, :set?, :ensure!
+    def_delegators :commands, :command, :comment
+
+    def configuration
+      Configuration.instance
+    end
+
+    def invoke(task, *args)
+      Rake::Task[task].invoke(*args)
+      Rake::Task[task].reenable
+    end
+
+    def commands
+      @commands ||= Commands.new
+    end
+
+    def run(backend)
+      @commands = Commands.new
+      yield
+      commands.run(backend)
+    end
+
+    def on(stage)
+      old_stage, commands.stage = commands.stage, stage
+      yield
+      commands.stage = old_stage
+    end
+
+    def in_path(path, indent: nil)
+      real_commands = commands
+      @commands = Commands.new
+      yield
+      real_commands.command(commands.process(path), quiet: true, indent: indent)
+      @commands = real_commands
+    end
+
+    def deploy(&block)
+      command deploy_script(&block), quiet: true
+    end
+  end
+end
+extend Mina::DSL