jisota 0.0.1

data/lib/jisota/package_script.rb

@@ -0,0 +1,54 @@
+module Jisota
+  ##
+  # Part of the Script duck type
+  #
+  # Executes an entire package, which in turn might execute other packages.
+  # The args are parsed with the ParamParser to match args with params.
+  #
+  # 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
+
+    def initialize(package, args = [], packages = Collection.new)
+      @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
+    end
+
+    def to_s
+      "#{package.name} #{args.map(&:inspect).join(", ")}"
+    end
+
+    private
+
+    def execute_verify_and_run(ssh_session, logger)
+      parsed_params = ParamParser.new(package.params, args).parse
+      if package.verify_block
+        verify_script = package.verify_block.evaluate(parsed_params, packages)
+        result = verify_script.execute(ssh_session, logger)
+        if result
+          logger.package_cancelled_by_verify(self) if logger
+          true
+        else
+          execute_run(parsed_params, ssh_session, logger)
+        end
+      else
+        execute_run(parsed_params, ssh_session, logger)
+      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)
+    end
+  end
+end

data/lib/jisota/packages/apt.rb

@@ -0,0 +1,17 @@
+require 'jisota'
+
+Jisota.global_config do
+  package :apt do
+    description "Installs packages with apt-get"
+    param :packages, required: true, splat: true
+
+    run do
+      cmd "sudo apt-get install -y #{packages.join(" ")}"
+    end
+
+    verify do
+      cmd "dpkg -s #{packages.join(" ")}"
+    end
+  end
+end
+

data/lib/jisota/packages/ruby.rb

@@ -0,0 +1,29 @@
+require 'jisota'
+
+Jisota.global_config do
+  package :ruby do
+    description "Installs ruby from source"
+    param :version, required: true
+    param :tmp_dir, default: "~/tmp"
+
+    run do
+      minor_version = version.match(/\d+\.\d+/)[0]
+
+      apt *%w(libffi-dev libssl-dev zlib1g-dev libreadline-dev)
+      cmd %Q{
+        mkdir -p #{tmp_dir} &&
+        cd #{tmp_dir} &&
+        wget --continue --no-verbose http://cache.ruby-lang.org/pub/ruby/#{minor_version}/ruby-#{version}.tar.gz &&
+        tar -zxvf ruby-#{version}.tar.gz &&
+        cd ruby-#{version} &&
+        ./configure &&
+        make &&
+        sudo make install &&
+      }
+    end
+
+    verify do
+      cmd "ruby -v | grep #{version}"
+    end
+  end
+end

data/lib/jisota/param.rb

@@ -0,0 +1,34 @@
+module Jisota
+  ##
+  # A package param
+  #
+  # Options:
+  #
+  # [default] Provide a default value for the param
+  # [required] If true, an error is raised unless the param has a value
+  # [splat] Will get remaining unnamed arguments
+  class Param
+    attr_reader :name, :options
+
+    def initialize(name, options = {})
+      @name = name
+      @options = options
+    end
+
+    def default?
+      options.has_key?(:default)
+    end
+
+    def default
+      options[:default]
+    end
+
+    def required?
+      !!options[:required]
+    end
+
+    def splat?
+      !!options[:splat]
+    end
+  end
+end

data/lib/jisota/param_parser.rb

@@ -0,0 +1,70 @@
+module Jisota
+  class ParamParser
+    attr_reader :params, :args
+
+    def initialize(params, args)
+      @original_params = params.dup
+      @params = params.dup
+      @args = args.dup
+    end
+
+    def parse
+      Hash.new.tap do |result|
+        init_splat_params(result)
+        add_implicit_args(result)
+        add_hash_args(result)
+        set_remaining_params(result)
+      end
+    end
+
+    private
+
+    def init_splat_params(result)
+      params.select(&:splat?).each do |param|
+        result[param.name] = []
+      end
+    end
+
+    def add_implicit_args(result)
+      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
+        if param.splat?
+          result[param.name] << arg
+        else
+          result[param.name] = arg
+        end
+      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
+        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"
+          end
+        end
+        result[key] = value
+      end
+    end
+
+    def set_remaining_params(result)
+      params.each do |param|
+        unless result.has_key?(param.name)
+          if param.required? && !param.default?
+            raise ParameterError, "Parameter #{param.name.inspect} is required"
+          end
+          result[param.name] = param.default? ? param.default : nil
+        end
+      end
+    end
+  end
+end

data/lib/jisota/provisioner.rb

@@ -0,0 +1,24 @@
+module Jisota
+  ##
+  # Reads configuration and runs it
+  class Provisioner
+    def run(configuration, logger)
+      packages = configuration.packages.merge(Jisota.global_packages) { |_, left, _| left }
+      configuration.each_server do |server|
+        run_server(server, configuration.ssh_engine, configuration.roles, packages, logger)
+      end
+    end
+
+    private
+
+    def run_server(server, ssh, roles, packages, logger)
+      ssh.start(user: server.user, host: server.host) do |ssh_session|
+        server.roles.each do |role_name|
+          role = roles[role_name]
+          script = role.script_block.evaluate({}, packages)
+          script.execute(ssh_session, logger)
+        end
+      end
+    end
+  end
+end

data/lib/jisota/role.rb

@@ -0,0 +1,13 @@
+module Jisota
+  class Role
+    attr_accessor :name, :script_block
+    alias_method :key, :name
+
+    def initialize(name = nil, &block)
+      @name = name
+      @script_block = ScriptBlock.new(&block) if block_given?
+    end
+
+  end
+end
+

data/lib/jisota/script_block.rb

@@ -0,0 +1,66 @@
+module Jisota
+  ##
+  # DSL for creating a CompositeScript
+  #
+  # Methods in the DSL:
+  #
+  # [cmd] Add a CommandScript
+  # [upload] Add a FileScript
+  # [<arg name>]  The value of the argument
+  # [<package name>] Add a PackageScript
+  class ScriptBlock
+    attr_accessor :block
+
+    def initialize(options = {}, &block)
+      @block = block
+    end
+
+    def evaluate(args = {}, packages = Collection.new)
+      CompositeScript.new.tap do |script|
+        dsl = DSL.new(script, args, packages)
+        dsl.instance_eval(&block)
+      end
+    end
+
+    class DSL
+      def initialize(script, args, packages)
+        @script = script
+        @args = args
+        @packages = packages
+      end
+
+      def cmd(command)
+        @script.scripts << CommandScript.new(command)
+      end
+
+      def upload(from:, to: )
+        @script.scripts << FileScript.new(UploadFile.new(from, to))
+      end
+
+      def method_missing(method, *args, &block)
+        if has_argument?(method)
+          get_argument(method)
+        else
+          add_package_script(method, args) || super
+        end
+      end
+
+      private
+
+      def has_argument?(name)
+        @args.has_key?(name)
+      end
+
+      def get_argument(name)
+        @args.fetch(name)
+      end
+
+      def add_package_script(name, args)
+        if @packages.has_key?(name)
+          package = @packages[name]
+          @script.scripts << PackageScript.new(package, args, @packages)
+        end
+      end
+    end
+  end
+end

data/lib/jisota/server.rb

@@ -0,0 +1,12 @@
+module Jisota
+  class Server
+    attr_accessor :host, :user, :roles
+
+    def initialize(host = nil, options = {})
+      @roles = []
+      @host = host
+      @user = options[:user]
+      @roles = Array(options[:roles]) if options[:roles]
+    end
+  end
+end

data/lib/jisota/ssh_engine.rb

@@ -0,0 +1,11 @@
+require 'net/ssh'
+
+module Jisota
+  class SSHEngine
+    def self.start(user: , host: )
+      Net::SSH.start(host, user) do |ssh_session|
+        yield SSHSession.new(ssh_session)
+      end
+    end
+  end
+end

data/lib/jisota/ssh_session.rb

@@ -0,0 +1,48 @@
+require 'net/scp'
+
+module Jisota
+  class SSHSession
+
+    class FileNotFoundError < StandardError; end
+
+    def initialize(session = nil, options = {})
+      @session = session
+      @scp_engine = options.fetch(:scp_engine) { Net::SCP }
+    end
+
+    def command(command, logger = nil)
+      exit_code = nil
+      exit_signal = nil
+      error_message = ""
+
+      logger.command(command) if logger
+
+      @session.open_channel do |channel|
+        channel.exec(command) do
+          channel.on_data { |_, data| logger.info(data) if logger }
+          channel.on_extended_data { |_, _, data| logger.warn(data) if logger; error_message << data }
+          channel.on_request("exit-status") { |_, data| exit_code = data.read_long }
+          channel.on_request("exit-signal") { |_, data| exit_signal = data.read_long }
+        end
+      end
+      @session.loop
+
+      if exit_code == 0
+        true
+      else
+        logger.error("Error running #{command}:")
+        logger.error(error_message)
+        false
+      end
+    end
+
+    def upload(file, logger = nil)
+      raise FileNotFoundError, "Upload file not found: #{file.from}" unless File.exist?(file.from)
+      tmp_file = "tmp/jisota/#{SecureRandom.hex}"
+      command("mkdir -p tmp/jisota", logger)
+      logger.upload(from: file.from, to: tmp_file) if logger
+      @scp_engine.new(@session).upload!(file.from, tmp_file, recursive: false)
+      command("sudo mkdir -p `dirname #{file.to}` && sudo mv #{tmp_file} #{file.to}", logger)
+    end
+  end
+end

data/lib/jisota/upload_file.rb

@@ -0,0 +1,3 @@
+module Jisota
+  UploadFile = Struct.new(:from, :to)
+end

data/lib/jisota/version.rb

@@ -0,0 +1,3 @@
+module Jisota
+  VERSION = "0.0.1"
+end

data/lib/jisota.rb

@@ -0,0 +1,63 @@
+module Jisota
+
+  ##
+  # Runs a provision with the given configuration
+  #
+  # Options allow default depenedencies to be overridden. Example:
+  #
+  #     Jisota.run(config, logger: Jisota::Logger.new(verbose: true))
+  #
+  def self.run(configuration, options = {})
+    provisioner = options.fetch(:provisioner) { Provisioner.new }
+    logger      = options.fetch(:logger) { Logger.new }
+    provisioner.run(configuration, logger)
+  end
+
+  ##
+  # Shorthand for defining a new configuration
+  #
+  # Example:
+  #
+  #     config = Jisota.config do
+  #       role :app do
+  #         ruby version: "2.1.1"
+  #         postgresql
+  #       end
+  #       server "123.456.789.000", user: "john", roles: :app
+  #     end
+  def self.config(&block)
+    Configuration.new(&block)
+  end
+
+  ##
+  # Shorthand for defining packages in the global package manager
+  # The global package manager is useful when sharing a package between
+  # multiple projects or configurations
+  #
+  # Example:
+  #
+  #     Jisota.global_config do
+  #       package :apt do
+  #         param :packages, splat: true, required: true
+  #         run { cmd "sudo apt-get install -y #{packages.join(" ")}" }
+  #       end
+  #     end
+  def self.global_config(&block)
+    config = config(&block)
+    config.packages.each do |package|
+      global_packages << package
+    end
+  end
+
+  ##
+  # The global package manager
+  #
+  # All build-in packages also live here
+  # Local packages with the same name will have precedence over these.
+  def self.global_packages
+    @global_packages ||= Collection.new
+  end
+end
+
+Dir[File.expand_path("../jisota/*.rb", __FILE__)].each { |file| require file }
+Dir[File.expand_path("../jisota/packages/*.rb", __FILE__)].each { |file| require file }

data/spec/acceptance/simple_script_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+module Jisota
+  describe "Execute a simple script" do
+    let(:ssh_engine) do
+      class_double(SSHEngine).tap do |ssh_engine|
+        allow(ssh_engine).to receive(:start).and_yield(ssh_session)
+      end
+    end
+
+    let(:ssh_session) { instance_double(SSHSession, command: true, upload: true) }
+
+    example "Simple script with a package" do
+      run_for_real = ENV["ACCEPTANCE_TEST"] == "run_for_real"
+
+      host = run_for_real ? ENV["ACCEPTANCE_HOST"] : "test.jisota"
+      raise "Must set host with ACCEPTANCE_HOST=<host>" unless host
+
+      user = run_for_real ? ENV["ACCEPTANCE_USER"] : "john_doe"
+      raise "Must set user with ACCEPTANCE_USER=<user>" unless user
+
+      Jisota.global_config do
+        package :touch_global do
+          param :target
+          run { cmd "touch #{target}" }
+        end
+      end
+
+      config = Jisota.config do
+        package :touch do
+          param :target
+          run { cmd "touch #{target}" }
+        end
+
+        role :app do
+          cmd "touch foo"
+          touch "bar"
+          touch_global "baz"
+          upload from: "spec/test_files/foo", to: "uploads/foo"
+        end
+
+        server host, user: user, roles: :app
+      end
+
+      config.ssh_engine = ssh_engine unless run_for_real
+      Jisota.run(config)
+
+      unless run_for_real
+        expect(ssh_engine).to have_received(:start).with(user: "john_doe", host: "test.jisota")
+        expect(ssh_session).to have_received(:command).with("touch foo", anything)
+        expect(ssh_session).to have_received(:command).with("touch bar", anything)
+        expect(ssh_session).to have_received(:upload).with(UploadFile.new("spec/test_files/foo", "uploads/foo"), anything)
+      end
+    end
+  end
+end

data/spec/lib/jisota/collection_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+module Jisota
+  describe Collection do
+    describe "#add" do
+      it "adds the item" do
+        collection = Collection.new
+        item = double(key: :foo)
+        collection.add(item)
+
+        expect(collection[:foo]).to eq(item)
+        expect(collection.size).to eq(1)
+      end
+
+      it "will not allow duplicate key" do
+        collection = Collection.new
+        item = double(key: :foo)
+        collection.add(item)
+
+        expect { collection.add(item) }.to raise_error(Collection::DuplicateKeyError)
+      end
+    end
+
+    describe "#merge" do
+      it "returns a new collection with all items" do
+        collection_1 = Collection.new
+        collection_1.add(double(key: :foo, value: 1))
+        collection_1.add(double(key: :bar, value: 2))
+
+        collection_2 = Collection.new
+        collection_2.add(double(key: :bar, value: 3))
+        collection_2.add(double(key: :baz, value: 4))
+
+        result = collection_1.merge(collection_2) { |_, left, _| left }
+
+        expect(collection_1.size).to eq(2)
+        expect(collection_2.size).to eq(2)
+        expect(result.size).to eq(3)
+
+        expect(result.map(&:value)).to eq([1, 2, 4])
+      end
+    end
+  end
+end

data/spec/lib/jisota/command_script_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+module Jisota
+  describe CommandScript do
+    describe "#command" do
+      it "initializes with a command" do
+        expect(CommandScript.new(:foo).command).to eq(:foo)
+      end
+    end
+
+    describe "#execute" do
+      it "asks ssh_session to execute" do
+        script = CommandScript.new(:foo)
+        ssh_session = instance_double(SSHSession, command: true)
+        result = script.execute(ssh_session)
+
+        expect(ssh_session).to have_received(:command).with(:foo, nil)
+        expect(result).to be true
+      end
+    end
+  end
+end

data/spec/lib/jisota/composite_script_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+module Jisota
+  describe CompositeScript do
+    describe "#scripts" do
+      it "initializes to empty array" do
+        expect(CompositeScript.new.scripts).to eq([])
+      end
+    end
+
+    describe "execute" do
+      let(:ssh_session) { instance_double(SSHSession) }
+      let(:script) { CompositeScript.new }
+      it "executes all scripts" do
+        inner_1 = double(execute: true)
+        inner_2 = double(execute: true)
+        script.scripts << inner_1 << inner_2
+        result = script.execute(ssh_session)
+
+        expect(inner_1).to have_received(:execute).with(ssh_session, nil)
+        expect(inner_2).to have_received(:execute).with(ssh_session, nil)
+        expect(result).to be true
+      end
+
+      it "stops execution if one script fails" do
+        inner_1 = double(execute: false)
+        inner_2 = double(execute: true)
+        script.scripts << inner_1 << inner_2
+        result = script.execute(ssh_session)
+
+        expect(inner_1).to have_received(:execute).with(ssh_session, nil)
+        expect(inner_2).to_not have_received(:execute).with(ssh_session, nil)
+        expect(result).to be false
+      end
+    end
+  end
+end