jisota 0.0.1 → 0.0.2

data/lib/jisota/server.rb

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

data/lib/jisota/ssh_engine.rb

@@ -2,8 +2,12 @@ require 'net/ssh'
 
 module Jisota
   class SSHEngine
-    def self.start(user: , host: )
-      Net::SSH.start(host, user) do |ssh_session|
+    def initialize(options = {})
+      @engine = options.fetch(:engine) { Net::SSH }
+    end
+
+    def start(user: , host: , **options)
+      @engine.start(host, user, options) do |ssh_session|
         yield SSHSession.new(ssh_session)
       end
     end

data/lib/jisota/ssh_session.rb

@@ -10,39 +10,34 @@ module Jisota
       @scp_engine = options.fetch(:scp_engine) { Net::SCP }
     end
 
-    def command(command, logger = nil)
+    def command(command, logger = NilOutput.new)
       exit_code = nil
       exit_signal = nil
       error_message = ""
 
-      logger.command(command) if logger
+      logger.system_message("Executing #{command}")
 
       @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_data { |_, data| logger.info(data) }
+          channel.on_extended_data { |_, _, data| logger.warn(data); 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
+      if exit_code > 0
         logger.error("Error running #{command}:")
         logger.error(error_message)
-        false
       end
+
+      exit_code
     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)
+    def upload(from: , to: )
+      raise FileNotFoundError, "Upload file not found: #{from}" unless File.exist?(from)
+      @scp_engine.new(@session).upload!(from, to, recursive: false)
     end
   end
 end

data/lib/jisota/version.rb

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

data/package_files/nginx_passenger/nginx_service

@@ -0,0 +1,65 @@
+#!/bin/bash
+#
+# How-to:
+#
+# Symlink to init.d:
+# ln -s /path/to/nginx_service /etc/init.d/nginx
+#
+# Register service:
+# sudo update-rc.d nginx defaults 99
+# (99 is the boot order of all startup services making sure this boots last)
+#
+
+### BEGIN INIT INFO
+# Provides:          nginx
+# Required-Start:    $local_fs, $syslog
+# Required-Stop:     $local_fs, $syslog
+# Default-Start:     2 3 4 5
+# Default-Stop:      0 1 6
+# Short-Description: Start nginx at boot time
+# Description:       Enable service provided by nginx
+### END INIT INFO
+
+RETVAL=0;
+bin=/opt/nginx/sbin/nginx
+
+start() {
+  echo "Starting nginx"
+  $bin
+}
+
+stop() {
+  echo "Stopping nginx"
+  $bin -s stop
+}
+
+restart() {
+  echo "Restarting nginx"
+  $bin -s reload
+}
+
+reload() {
+  echo "Restarting nginx"
+  $bin -s reload
+}
+
+case "$1" in
+  start)
+    start
+    ;;
+  stop)
+    stop
+    ;;
+  restart)
+    restart
+    ;;
+  reload)
+    reload
+    ;;
+  *)
+
+    echo $"Usage: $0 {start|stop|restart|reload}"
+    exit 1
+esac
+
+exit $RETVAL

data/spec/acceptance/ruby_passenger_nginx_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+require 'open-uri'
+
+module Jisota
+  describe "ruby + passenger", type: :acceptance do
+    example "install ruby and nginx_passenger" do
+      config = Jisota.config do
+        role :app do
+          ruby version: "2.1.1"
+          nginx_passenger config_file: "spec/test_files/nginx_default.conf"
+        end
+
+        server host, user: user, roles: :app, key: key
+      end
+
+      Jisota.run(config, logger: Output.new(verbose: true))
+
+      webpage = URI("http://#{host}").read
+      expect(webpage).to match(/Welcome to nginx!/)
+    end
+  end
+end
+
+

data/spec/acceptance/simple_script_spec.rb

@@ -1,24 +1,8 @@
 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) }
-
+  describe "Execute a simple script", type: :acceptance do
     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
@@ -39,17 +23,17 @@ module Jisota
           upload from: "spec/test_files/foo", to: "uploads/foo"
         end
 
-        server host, user: user, roles: :app
+        server host, user: user, key: key, 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)
+      create_ssh_session do |ssh_session|
+        expect(ssh_session.command("[ -f foo ]")).to eq(0)
+        expect(ssh_session.command("[ -f bar ]")).to eq(0)
+        expect(ssh_session.command("[ -f baz ]")).to eq(0)
+        expect(ssh_session.command("[ -f uploads/foo ]")).to eq(0)
+        expect(ssh_session.command('[ `cat uploads/foo` = "foo" ]')).to eq(0)
       end
     end
   end

data/spec/acceptance/upload_blocks_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+module Jisota
+  describe 'calling upload blocks', type: :acceptance do
+    example "update and create blocks inside package with params" do
+      config = Jisota.config do
+        package :upload_file do
+          param :file
+          run do
+            upload from: file, to: "foo" do
+              create { cmd %Q{echo "File #{file} created"} }
+              update { cmd %Q{echo "File #{file} updated"} }
+            end
+          end
+        end
+
+        role :app do
+          upload_file "spec/test_files/foo"
+        end
+
+        server host, user: user, roles: :app, key: key
+      end
+
+      create_ssh_session { |ssh_session| ssh_session.command("rm foo") }
+      Jisota.run(config, logger: logger)
+
+      create_ssh_session { |ssh_session| ssh_session.command("echo omg > foo") }
+      Jisota.run(config, logger: logger)
+
+      expect(logger.stdout.writes).to include("File spec/test_files/foo created\n")
+      expect(logger.stdout.writes).to include("File spec/test_files/foo updated\n")
+    end
+  end
+end

data/spec/lib/jisota/collection_spec.rb

@@ -40,5 +40,15 @@ module Jisota
         expect(result.map(&:value)).to eq([1, 2, 4])
       end
     end
+
+    describe "#first" do
+      it "returns the first item in the collection" do
+        collection = Collection.new
+        collection.add(double(key: :foo))
+        collection.add(double(key: :bar))
+
+        expect(collection.first.key).to eq(:foo)
+      end
+    end
   end
 end

data/spec/lib/jisota/command_script_spec.rb

@@ -11,10 +11,11 @@ module Jisota
     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)
+        ssh_session = instance_double(SSHSession, command: 0)
+        context = ScriptContext.new(ssh_session: ssh_session)
+        result = script.execute(context)
 
-        expect(ssh_session).to have_received(:command).with(:foo, nil)
+        expect(ssh_session).to have_received(:command).with(:foo, anything)
         expect(result).to be true
       end
     end

data/spec/lib/jisota/composite_script_spec.rb

@@ -10,15 +10,17 @@ module Jisota
 
     describe "execute" do
       let(:ssh_session) { instance_double(SSHSession) }
+      let(:context) { ScriptContext.new(ssh_session: ssh_session) }
       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)
+        result = script.execute(context)
 
-        expect(inner_1).to have_received(:execute).with(ssh_session, nil)
-        expect(inner_2).to have_received(:execute).with(ssh_session, nil)
+        expect(inner_1).to have_received(:execute).with(context)
+        expect(inner_2).to have_received(:execute).with(context)
         expect(result).to be true
       end
 
@@ -26,10 +28,10 @@ module Jisota
         inner_1 = double(execute: false)
         inner_2 = double(execute: true)
         script.scripts << inner_1 << inner_2
-        result = script.execute(ssh_session)
+        result = script.execute(context)
 
-        expect(inner_1).to have_received(:execute).with(ssh_session, nil)
-        expect(inner_2).to_not have_received(:execute).with(ssh_session, nil)
+        expect(inner_1).to have_received(:execute).with(context)
+        expect(inner_2).to_not have_received(:execute).with(context)
         expect(result).to be false
       end
     end

data/spec/lib/jisota/configuration_spec.rb

@@ -54,9 +54,7 @@ module Jisota
       describe "#role" do
         it "creates a role" do
           config = Configuration.new do
-            role :app do
-              cmd "touch foo"
-            end
+            role(:app) { cmd "touch foo" }
           end
           role = config.roles.first
           expect(role.name).to eq(:app)

data/spec/lib/jisota/dsl_base_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+module Jisota
+
+  class SomeDSL < DSLBase
+    def set(value)
+      @value = value
+    end
+
+    def get
+      @value
+    end
+  end
+
+  describe DSLBase do
+    describe "#evaluate" do
+      it "evaluates like a true closure" do
+        foo = "bar"
+        dsl = SomeDSL.new
+        dsl.evaluate do
+          set foo
+        end
+
+        expect(dsl.get).to eq("bar")
+      end
+
+      it "handles method_missing" do
+        dsl = SomeDSL.new
+        expect {
+          dsl.evaluate do
+            foo
+          end
+        }.to raise_exception(NameError)
+      end
+    end
+  end
+end

data/spec/lib/jisota/file_script_spec.rb

@@ -2,21 +2,76 @@ require 'spec_helper'
 
 module Jisota
   describe FileScript do
-    describe "#file" do
-      it "initializes with one" do
-        expect(FileScript.new(:foo).file).to eq(:foo)
+    describe "#initialization" do
+      it "initializes with from and to" do
+        script = FileScript.new(from: "foo", to: "bar")
+        expect(script.from).to eq("foo")
+        expect(script.to).to eq("bar")
+      end
+
+      it "accepts create and update args" do
+        script = FileScript.new(from: "foo", to: "bar", create: true, update: :foo)
+        expect(script.create).to be true
+        expect(script.update).to eq(:foo)
       end
     end
 
     describe "#execute" do
-      it "asks ssh_session to upload file" do
-        script = FileScript.new(:foo)
-        ssh_session = instance_double(SSHSession, upload: true)
-        result = script.execute(ssh_session)
+      let(:script) { FileScript.new(from: "foo", to: "bar") }
+      let(:ssh_session) { instance_double(SSHSession, upload: nil, command: 0) }
+      let(:context) { ScriptContext.new(ssh_session: ssh_session) }
+
+      it "uploads and moves the file" do
+        allow(ssh_session).to receive(:command).with(a_string_starting_with("cmp")) { 1 }
+        result = script.execute(context)
 
-        expect(ssh_session).to have_received(:upload).with(:foo, nil)
+        expect(ssh_session).to have_received(:command).with("mkdir -p tmp/jisota", anything)
+        expect(ssh_session).to have_received(:upload) do |options|
+          expect(options[:from]).to eq("foo")
+          expect(options[:to]).to start_with("tmp/jisota/")
+        end
+        expect(ssh_session).to have_received(:command).with(a_string_matching(/sudo mkdir -p .* sudo mv .* bar/), anything)
         expect(result).to be true
       end
+
+      it "does not move file if it already exists and is identical" do
+        allow(ssh_session).to receive(:command).with(a_string_starting_with("cmp")) { 0 }
+        result = script.execute(context)
+
+        expect(ssh_session).to_not have_received(:command).with(a_string_matching(/sudo mv/), anything)
+      end
+
+      it "does not move file when target does not exist and create is false" do
+        script.create = false
+        allow(ssh_session).to receive(:command).with(a_string_starting_with("cmp")) { 2 }
+        result = script.execute(context)
+
+        expect(ssh_session).to_not have_received(:command).with(a_string_matching(/sudo mv/), anything)
+      end
+
+      it "does not move file when target exists and update is false" do
+        script.update = false
+        allow(ssh_session).to receive(:command).with(a_string_starting_with("cmp")) { 1 }
+        result = script.execute(context)
+
+        expect(ssh_session).to_not have_received(:command).with(a_string_matching(/sudo mv/), anything)
+      end
+
+      it "runs the callbacks" do
+        allow(ssh_session).to receive(:command).with(a_string_starting_with("cmp")) { 2 }
+        script.create = ScriptBlock.new { cmd "foo" }
+        result = script.execute(context)
+        expect(ssh_session).to have_received(:command).with("foo", anything)
+      end
+    end
+
+    describe "DSL" do
+      it "can set simple values on callback" do
+        script = FileScript.new(from: "foo", to: "bar") do
+          create false
+        end
+        expect(script.create).to be false
+      end
     end
   end
 end