jisota 0.0.1 → 0.0.2

data/lib/jisota/nil_output.rb

@@ -0,0 +1,14 @@
+module Jisota
+  class NilOutput < Output
+    class NilIO
+      def write(*); end
+      def flush(*); end
+    end
+
+    def initialize(options = {})
+      super
+      @stdout = NilIO.new
+      @stderr = NilIO.new
+    end
+  end
+end

data/lib/jisota/{logger.rb → output.rb}

@@ -4,7 +4,7 @@ module Jisota
   #
   # Will default to use STDOUT and STDERR, but that can be overwritten in the
   # initializer
-  class Logger
+  class Output
     attr_accessor :stdout, :stderr, :verbose, :prefix, :indent_level
 
     def initialize(options = {})
@@ -15,60 +15,41 @@ module Jisota
       @indent_level = 0
     end
 
-    def command(command)
-      prefixed_message "Executing #{command}"
-    end
-
-    def upload(from: , to: )
-      prefixed_message "Uploading #{from} -> #{to}"
-    end
-
-    def package(package_script)
-      prefixed_message "Package #{package_script}"
-    end
-
-    def package_cancelled_by_verify(package_script)
-      prefixed_message "Package #{package_script} already installed"
-    end
-
-    def prefixed_message(message)
-      stdout.write(create_message(message, true, true))
+    def system_message(message, &block)
+      result = ["", prefix, "  " * indent_level, message, "\n"].join
+      stdout.write(result)
+      stdout.flush
+      indent(&block) if block_given?
     end
 
     def info(message)
       stdout.write(message) if verbose
+      stdout.flush
     end
 
     def warn(message)
       stderr.write(message) if verbose
+      stderr.flush
     end
 
     def error(message)
       stderr.write(message)
+      stderr.flush
     end
 
     def indent
       self.indent_level += 1
+      if block_given?
+        begin
+          yield
+        ensure
+          outdent
+        end
+      end
     end
 
     def outdent
       self.indent_level -= 1
     end
-
-    private
-
-    def create_message(message, newline, use_prefix)
-      result = ""
-      if use_prefix
-        result << prefix
-      else
-        result << " " * prefix.size
-      end
-      result << "  " * indent_level
-      result << message
-      result << "\n" if newline
-      result
-    end
-
   end
 end

data/lib/jisota/package.rb

@@ -5,12 +5,12 @@ module Jisota
     def initialize(name = nil, &block)
       @params = []
       @name = name
-      DSL.new(self).instance_eval(&block) if block_given?
+      DSL.new(self).evaluate(&block) if block_given?
     end
 
     alias_method :key, :name
 
-    class DSL
+    class DSL < DSLBase
       def initialize(target)
         @target = target
       end

data/lib/jisota/package_script.rb

@@ -8,47 +8,55 @@ module Jisota
   # If the package has a `verify_block`, that will be executed first. If the
   # result of verify is success, the `run_block` will not be executed.
   class PackageScript
-    attr_accessor :package, :args, :packages
+    attr_accessor :package, :args
 
-    def initialize(package, args = [], packages = Collection.new)
+    def initialize(package, args = [])
       @package = package
       @args = args
-      @packages = packages
     end
 
-    def execute(ssh_session, logger = nil)
-      logger.package(self) if logger
-      logger.indent if logger
-      result = execute_verify_and_run(ssh_session, logger)
-      logger.outdent if logger
-      result
+    def execute(context)
+      context.param_scope(parse_params) do
+        context.logger.system_message("Package #{self}") do
+          execute_verify_and_run(context)
+        end
+      end
     end
 
     def to_s
-      "#{package.name} #{args.map(&:inspect).join(", ")}"
+      result = ""
+      result << package.name.to_s
+      if args.any?
+        result << " "
+        result << args.map(&:inspect).join(", ")
+      end
+      result
     end
 
     private
 
-    def execute_verify_and_run(ssh_session, logger)
-      parsed_params = ParamParser.new(package.params, args).parse
+    def parse_params
+      ParamParser.new(package.params, args).parse
+    end
+
+    def execute_verify_and_run(context)
       if package.verify_block
-        verify_script = package.verify_block.evaluate(parsed_params, packages)
-        result = verify_script.execute(ssh_session, logger)
+        verify_script = package.verify_block.evaluate(context)
+        result = verify_script.execute(context)
         if result
-          logger.package_cancelled_by_verify(self) if logger
+          context.logger.system_message("Package #{self} already installed")
           true
         else
-          execute_run(parsed_params, ssh_session, logger)
+          execute_run(context)
         end
       else
-        execute_run(parsed_params, ssh_session, logger)
+        execute_run(context)
       end
     end
 
-    def execute_run(parsed_params, ssh_session, logger)
-      run_script = package.run_block.evaluate(parsed_params, packages)
-      run_script.execute(ssh_session, logger)
+    def execute_run(context)
+      run_script = package.run_block.evaluate(context)
+      run_script.execute(context)
     end
   end
 end

data/lib/jisota/packages/gem_install.rb

@@ -0,0 +1,17 @@
+require 'jisota'
+
+Jisota.global_config do
+  package :gem_install do
+    description "Installs a gem"
+    param :gem_name, required: true
+    param :sudo, default: true
+
+    run do
+      cmd "#{sudo ? "sudo " : ""}gem install #{gem_name} --no-document"
+    end
+
+    verify do
+      cmd "#{sudo ? "sudo " : ""}gem list #{gem_name} --installed"
+    end
+  end
+end

data/lib/jisota/packages/nginx_passenger.rb

@@ -0,0 +1,34 @@
+require 'jisota'
+
+Jisota.global_config do
+  package :nginx_passenger do
+    description "Install nginx with passenger module"
+    param :config_file, required: true
+
+    run do
+      gem_install :passenger
+      apt "libcurl4-openssl-dev"
+      nginx_passenger_install
+
+      upload from: config_file, to: '/opt/nginx/conf/nginx.conf' do
+        update { cmd "sudo service nginx restart" }
+      end
+
+      upload from: "package_files/nginx_passenger/nginx_service", to: "/etc/init.d/nginx" do
+        create { cmd 'sudo update-rc.d nginx defaults 99' }
+      end
+
+      nginx_passenger_start
+    end
+  end
+
+  package :nginx_passenger_install do
+    run { cmd 'sudo passenger-install-nginx-module --auto --auto-download --prefix=/opt/nginx' }
+    verify { cmd 'which /opt/nginx/sbin/nginx' }
+  end
+
+  package :nginx_passenger_start do
+    run { cmd "sudo service nginx start" }
+    verify { cmd "ps -C nginx" }
+  end
+end

data/lib/jisota/packages/ruby.rb

@@ -9,7 +9,7 @@ Jisota.global_config do
     run do
       minor_version = version.match(/\d+\.\d+/)[0]
 
-      apt *%w(libffi-dev libssl-dev zlib1g-dev libreadline-dev)
+      apt *%w(libffi-dev libssl-dev zlib1g-dev libreadline-dev build-essential)
       cmd %Q{
         mkdir -p #{tmp_dir} &&
         cd #{tmp_dir} &&
@@ -18,7 +18,7 @@ Jisota.global_config do
         cd ruby-#{version} &&
         ./configure &&
         make &&
-        sudo make install &&
+        sudo make install
       }
     end
 

data/lib/jisota/param_parser.rb

@@ -3,17 +3,17 @@ module Jisota
     attr_reader :params, :args
 
     def initialize(params, args)
-      @original_params = params.dup
-      @params = params.dup
-      @args = args.dup
+      @params = params
+      @args = args
     end
 
     def parse
+      params_work_list = params.dup
       Hash.new.tap do |result|
         init_splat_params(result)
-        add_implicit_args(result)
-        add_hash_args(result)
-        set_remaining_params(result)
+        add_unnamed_args(result, params_work_list)
+        add_named_args(result)
+        handle_remaining_params(result, params_work_list)
       end
     end
 
@@ -25,12 +25,11 @@ module Jisota
       end
     end
 
-    def add_implicit_args(result)
+    def add_unnamed_args(result, params_work_list)
       param = nil
-      while args.first && !args.first.is_a?(Hash)
-        param = params.shift unless param && param.splat?
-        arg = args.shift
-        raise ParameterError, "No parameter for implicit argument #{arg}" unless param
+      unnamed_args.each do |arg|
+        param = params_work_list.shift unless param && param.splat?
+        raise ParameterError, "No parameter for unnamed argument #{arg}" unless param
         if param.splat?
           result[param.name] << arg
         else
@@ -39,25 +38,37 @@ module Jisota
       end
     end
 
-    def add_hash_args(result)
-      return if args.empty?
-      raise ParameterError, "Hash parameters must be last in argument list" if args.size > 1
-      args.first.each do |key, value|
-        param = @original_params.select { |p| p.name == key }.first
+    def add_named_args(result)
+      named_args.each do |key, value|
+        param = params.select { |p| p.name == key }.first
         raise ParameterError, "No parameter with name #{key.inspect}" unless param
         if result.has_key?(key)
           if param.splat?
             raise ParameterError, "Splat parameter #{key.inspect} only accepts unnamed arguments"
           else
-            raise ParameterError, "Parameter #{key.inspect} already set with an implicit argument"
+            raise ParameterError, "Parameter #{key.inspect} already set with an unnamed argument"
           end
         end
         result[key] = value
       end
     end
 
-    def set_remaining_params(result)
-      params.each do |param|
+    def unnamed_args
+      args.dup.tap do |result|
+        result.pop if named_args?
+      end
+    end
+
+    def named_args
+      named_args? ? args.last : {}
+    end
+
+    def named_args?
+      args.last.is_a?(Hash)
+    end
+
+    def handle_remaining_params(result, params_work_list)
+      params_work_list.each do |param|
         unless result.has_key?(param.name)
           if param.required? && !param.default?
             raise ParameterError, "Parameter #{param.name.inspect} is required"

data/lib/jisota/provisioner.rb

@@ -12,11 +12,15 @@ module Jisota
     private
 
     def run_server(server, ssh, roles, packages, logger)
-      ssh.start(user: server.user, host: server.host) do |ssh_session|
+      ssh_options = { user: server.user, host: server.host }
+      ssh_options[:keys] = [server.key] if server.key
+
+      ssh.start(ssh_options) do |ssh_session|
         server.roles.each do |role_name|
           role = roles[role_name]
-          script = role.script_block.evaluate({}, packages)
-          script.execute(ssh_session, logger)
+          context = ScriptContext.new(ssh_session: ssh_session, logger: logger, packages: packages)
+          script = role.script_block.evaluate(context)
+          script.execute(context)
         end
       end
     end

data/lib/jisota/script_block.rb

@@ -15,26 +15,25 @@ module Jisota
       @block = block
     end
 
-    def evaluate(args = {}, packages = Collection.new)
+    def evaluate(context = ScriptContext.new)
       CompositeScript.new.tap do |script|
-        dsl = DSL.new(script, args, packages)
-        dsl.instance_eval(&block)
+        dsl = DSL.new(script, context)
+        dsl.evaluate(&block)
       end
     end
 
-    class DSL
-      def initialize(script, args, packages)
+    class DSL < DSLBase
+      def initialize(script, context)
         @script = script
-        @args = args
-        @packages = packages
+        @context = context
       end
 
       def cmd(command)
         @script.scripts << CommandScript.new(command)
       end
 
-      def upload(from:, to: )
-        @script.scripts << FileScript.new(UploadFile.new(from, to))
+      def upload(**options, &block)
+        @script.scripts << FileScript.new(**options, &block)
       end
 
       def method_missing(method, *args, &block)
@@ -48,17 +47,17 @@ module Jisota
       private
 
       def has_argument?(name)
-        @args.has_key?(name)
+        @context.params.has_key?(name)
       end
 
       def get_argument(name)
-        @args.fetch(name)
+        @context.params.fetch(name)
       end
 
       def add_package_script(name, args)
-        if @packages.has_key?(name)
-          package = @packages[name]
-          @script.scripts << PackageScript.new(package, args, @packages)
+        if @context.packages.has_key?(name)
+          package = @context.packages[name]
+          @script.scripts << PackageScript.new(package, args)
         end
       end
     end

data/lib/jisota/script_context.rb

@@ -0,0 +1,24 @@
+module Jisota
+  class ScriptContext
+    attr_accessor :ssh_session, :logger, :params, :packages
+
+    def initialize(options = {})
+      @ssh_session = options.fetch(:ssh_session) { nil }
+      @logger      = options.fetch(:logger) { NilOutput.new }
+      @params      = options.fetch(:params) { Hash.new }
+      @packages    = options.fetch(:packages) { Collection.new }
+    end
+
+    def command(cmd)
+      ssh_session.command(cmd, logger)
+    end
+
+    def param_scope(scope_params)
+      old_params = params
+      self.params = scope_params
+      result = yield if block_given?
+      self.params = old_params
+      result
+    end
+  end
+end