jisota 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 868630ce53b3e30dee642175d2e3f9269c40749c
+  data.tar.gz: 692a72ec3e1df5c55e7c679837548584096c3bb0
+SHA512:
+  metadata.gz: e48e212a2175b404f1cfd1d2b122841051902f3f868509b1321096a9e1315440da686113cf8f7b209b872028ed068d50af947dbf3d8e2c97746f80987dea3b73
+  data.tar.gz: 71963bcbed7a13a30aadd4bc17a2bace65ea8ff694924999213c0a63cdf9e2b72b727d41d515dd69e535212e1fe042d0be28f6a5e26d022a8e3d6fba2398657c

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+sandi_meter/
+examples/

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format documentation

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in jisota.gemspec
+gemspec

data/Guardfile

@@ -0,0 +1,7 @@
+guard :rspec, cmd: "bundle exec rspec" do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+  watch(%r{^spec/shared/.+}) { "spec" }
+end
+

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Lasse Skindstad Ebert
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,254 @@
+# Jisota
+
+Jisota is a simple provisioning tool meant for smaller projects.
+
+Provisioning, in this context, is the act of turning an empty server
+into a working machine tailored to your needs.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'jisota', require: false
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install jisota
+
+## Introduction
+
+A simple example of a Jisota script:
+
+    # config/provision.rb (Or whatever you want to call this file)
+    require 'jisota'
+
+    config = Jisota.config do
+      role :app do
+        ruby version: "2.1.1"
+        nginx config_file: "path/to/nginx.conf"
+      end
+
+      server "mydomain.com", user: "john_doe", roles: :app
+    end
+
+    Jisota.run(config)
+
+Run the script with the ruby executable:
+
+    $ ruby config/provision.rb
+
+## Defining a package
+
+Inside a `Jisota.config` block, use the `package` method to define a package.
+
+Example:
+
+    Jisota.config do
+      package :essentials do
+        description "Installs important stuff"
+        run do
+          apt :curl, :vim, :git
+        end
+      end
+    end
+
+In this simple example we define a package with the name `:essentials`. It has
+a description and runs another package, `:apt`, that it calls with the arguments
+`:curl, :vim, :git`
+
+The DSL you can use inside a package include:
+
+* `description`: Will provide a description for the package.
+* `param`: Specify one or more named parameters for the package. See more in
+the params section below.
+* `run(&block)`: This block will be called when the package is executed.
+* `verify(&block)`: If this block exits with code 0, the run block will not be executed
+
+Inside a run-block, packages can be called by their name, somewhat like a Ruby
+method. See the `apt` example above.
+
+### Defining packages to be used in more than one project
+
+Defining packages with `Jisota.config` as above will only add the package to
+the current configuration. To make packages global they need to be in the
+global package manager. Simply use the `Jisota.global_config` instead:
+
+
+    Jisota.global_config do
+      package :ruby do
+        description "Installs ruby from source"
+        ...
+      end
+    end
+
+This will make the package accessable from all configurations. If a local
+package has the same name, the local package is used.
+
+All build-in packages are defined this way.
+
+## Defining params for a package
+
+Params for a package are defined with the `param` DSL method inside a
+`package`-block. Params are named:
+
+    package :my_package do
+      param :foo
+      param :bar
+      ...
+    end
+
+This package can be called either with named parameters or with sorted parameters.
+The following calls are all equivalent:
+
+    my_package 42, "Baz"
+    my_package 42, bar: "Baz"
+    my_package foo: 42, bar: "Baz"
+    my_package bar: "Baz", foo: 42
+
+### Param options
+
+Params can have the following options:
+
+* `default`: Sets a default value, if no value is passed to that parameter
+* `required`: Validates that the parameter will have a value
+* `splat`: Will assign all the following unnamed arguments to this parameter as an array
+
+Example:
+
+    package :apt do
+      param :packages, splat: true
+      param :command, default: "sudo apt-get install :package"
+      run do
+        cmd command.gsub(/:package/, packages.join(' '))
+      end
+    end
+
+    # And then call params inside another script block:
+    run do
+      apt :vim, :git
+      apt :vim, :git, command: "sudo apt-get install -y :package"
+    end
+
+
+## Atomic script operations
+
+All packages will eventually boil down to these few atomic operations, which
+can be called inside a script block:
+
+### cmd
+
+Will run a script on the server. Example:
+
+    cmd "apt-get install foo"
+
+### upload
+
+Uploads the file to the server. Example:
+
+    upload from: "path/to/nginx.conf", to: "/etc/nginx.conf"
+
+## Complete list of build-in packages
+
+### ruby
+
+    description "Installs ruby from source"
+    param :version, required: true
+    param :tmp_dir, default: "~/tmp"
+
+### apt
+
+    description "Installs packages with apt-get"
+    param :packages, required: true, splat: true
+
+### More packages?
+
+Jisota is a young gem. Please contribute with any packages that you think
+others could benifit from.
+
+## To DSL or not to DSL
+
+The DSL provided by Jisota is just a layer of abstraction. The entire library
+can easily be used without the DSL. This could be useful if you need to e.g.
+dynamically build a configuration.
+
+Example:
+
+    my_package = Jisota::Package.new(:stuff)
+    my_package.params << Jisota::Param.new(:foo, default: 42)
+
+    config = Jisota::Configuration.new
+    config.packages << my_package
+
+is equivalent to:
+
+    config = Jisota.config do
+      package :stuff do
+        param :foo, default: 42
+      end
+    end
+
+## Full example
+
+An example using most of the features of Jisota:
+
+    require 'jisota'
+
+    config = Jisota.config do
+      package :essentials do
+        description "Install essentials"
+        param :extra_packages, splat: true
+        run do
+          packages = %w[git vim curl]
+          packages += extra_packages
+          cmd "sudo apt-get install #{packages.join(" ")}"
+        end
+      end
+
+      package :postgres do
+        description "Installs postgres"
+        run do
+          cmd "some command sequence to install postgres"
+        end
+      end
+
+      package :nginx do
+        description "Install nginx"
+        param :config_file, required: true
+        run do
+          cmd "sudo apt get install nginx"
+          upload from: config_file, to: /etc/nginx.conf
+        end
+      end
+
+      role :app do
+        essentials "libfoo"
+        ruby version: "2.1.1"
+        nginx
+      end
+
+      role :db do
+        essentials
+        postgres
+      end
+
+      server "myapp.com",         user: "deploy", roles: :app
+      server "staging.myapp.com", user: "deploy", roles: :app
+      server "db.myapp.com",      user: "deploy", roles: :db
+      server "standby.myapp.com", user: "deploy", roles: [:app, :db]
+    end
+
+    Jisota.run(config)
+
+## Contributing
+
+Any pull requests, suggestions, bug reports and feedback are most welcome :)
+
+1. Fork it ( http://github.com/lasseebert/jisota/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/jisota.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'jisota/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "jisota"
+  spec.version       = Jisota::VERSION
+  spec.authors       = ["Lasse Skindstad Ebert"]
+  spec.email         = ["lasseebert@gmail.com"]
+  spec.summary       = %q{Easily provision servers}
+  spec.description   = %q{Easily provision servers using ruby, existing packages, your own packages and a nice DSL}
+  spec.homepage      = "https://github.com/lasseebert/jisota"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "net-ssh", "~> 2.8.0"
+  spec.add_dependency "net-scp", "~> 1.1.2"
+
+  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "simplecov"
+  spec.add_development_dependency "byebug"
+  spec.add_development_dependency "rspec", "~> 3.0.0.beta2"
+  spec.add_development_dependency "guard-rspec", "~> 4.2.8"
+end

data/lib/jisota/collection.rb

@@ -0,0 +1,52 @@
+module Jisota
+
+  ##
+  # Stores items with a `:key` attribute
+  # In Jisota, this is used for collections of `Package`, `Role` and `Server`
+  #
+  # Unlike most ruby enumerables, errors are raised when adding duplicate item
+  # or getting non-existent item.
+  class Collection
+    extend Forwardable
+    include Enumerable
+
+    class KeyNotFoundError < StandardError; end
+    class DuplicateKeyError < StandardError; end
+
+    attr_reader :items
+
+    def_delegators :items, :size, :each, :has_key?
+
+    def initialize(items = {})
+      @items = items
+    end
+
+    def add(item_with_key)
+      key = item_with_key.key
+      raise DuplicateKeyError, "Collection already contains an item with key #{key.inspect}" if items.has_key?(key)
+      items[key] = item_with_key
+    end
+    alias_method :<<, :add
+
+    def [](key)
+      items.fetch(key) { raise KeyNotFoundError, "The key #{key.inspect} was not found in the collection" }
+    end
+
+    def first
+      @items.first[1]
+    end
+
+    def last
+      @items.last[1]
+    end
+
+    def each(&block)
+      @items.values.each(&block)
+    end
+
+    def merge(other, &block)
+      Collection.new(items.merge(other.items, &block))
+    end
+
+  end
+end

data/lib/jisota/command_script.rb

@@ -0,0 +1,17 @@
+module Jisota
+  ##
+  # Part of the Script duck type
+  #
+  # Stores a single shell command that can be executed
+  class CommandScript
+    attr_accessor :command
+
+    def initialize(command)
+      @command = command
+    end
+
+    def execute(ssh_session, logger = nil)
+      ssh_session.command(command, logger)
+    end
+  end
+end

data/lib/jisota/composite_script.rb

@@ -0,0 +1,23 @@
+module Jisota
+  ##
+  # Part of the Script duck type
+  #
+  # Contains a list of Scripts and can execute them consectutive.
+  # If one script fails, the following will not be executed and the combined
+  # result of this script will also be failed (`false`)
+  class CompositeScript
+    attr_accessor :scripts
+
+    def initialize
+      @scripts = []
+    end
+
+    def execute(ssh_session, logger = nil)
+      scripts.each do |inner|
+        result = inner.execute(ssh_session, logger)
+        return false unless result
+      end
+      true
+    end
+  end
+end

data/lib/jisota/configuration.rb

@@ -0,0 +1,60 @@
+module Jisota
+  ##
+  # Stores all information required to run a provision against one or multiple
+  # servers (Except for the global package manager, which is stored in the Jisota module).
+  #
+  # Uses DSL methods in the initializer for convenient definition of packages, roles and servers
+  class Configuration
+    attr_accessor :packages, :roles, :servers, :ssh_engine
+
+    def initialize(options = {}, &block)
+      @packages   = options.fetch(:packages) { Collection.new }
+      @roles      = options.fetch(:role) { Collection.new }
+      @servers    = options.fetch(:servers) { [] }
+      @ssh_engine = options.fetch(:ssh_engine) { SSHEngine }
+      DSL.new(self).instance_eval(&block) if block_given?
+    end
+
+    def add_package(package)
+      packages.add(package)
+    end
+
+    def get_package(name)
+      packages[name]
+    end
+
+    def add_role(role)
+      roles.add(role)
+    end
+
+    def get_role(name)
+      roles[name]
+    end
+
+    def add_server(server)
+      servers << server
+    end
+
+    def each_server(&block)
+      servers.each(&block)
+    end
+
+    class DSL
+      def initialize(target)
+        @target = target
+      end
+
+      def package(name, &block)
+         @target.packages << Package.new(name, &block)
+      end
+
+      def role(name, &block)
+        @target.roles << Role.new(name, &block)
+      end
+
+      def server(host, options = {})
+        @target.servers << Server.new(host, options)
+      end
+    end
+  end
+end

data/lib/jisota/errors.rb

@@ -0,0 +1,3 @@
+module Jisota
+  class ParameterError < StandardError; end
+end

data/lib/jisota/file_script.rb

@@ -0,0 +1,21 @@
+module Jisota
+  ##
+  # Part of the Script duck type
+  #
+  # Uploads a file on execution
+  class FileScript
+    attr_accessor :file
+
+    def initialize(file)
+      @file = file
+    end
+
+    def execute(ssh_session, logger = nil)
+      logger.prefixed_message("File #{file.from} -> #{file.to}") if logger
+      logger.indent if logger
+      result = ssh_session.upload(file, logger)
+      logger.outdent if logger
+      result
+    end
+  end
+end

data/lib/jisota/logger.rb

@@ -0,0 +1,74 @@
+module Jisota
+  ##
+  # Responsible for outputting to the user / log file / whatever
+  #
+  # Will default to use STDOUT and STDERR, but that can be overwritten in the
+  # initializer
+  class Logger
+    attr_accessor :stdout, :stderr, :verbose, :prefix, :indent_level
+
+    def initialize(options = {})
+      @stdout  = options.fetch(:stdout) { $stdout }
+      @stderr  = options.fetch(:stderr) { $stderr }
+      @verbose = options.fetch(:verbose) { false }
+      @prefix = options.fetch(:prefix) { "-----> " }
+      @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))
+    end
+
+    def info(message)
+      stdout.write(message) if verbose
+    end
+
+    def warn(message)
+      stderr.write(message) if verbose
+    end
+
+    def error(message)
+      stderr.write(message)
+    end
+
+    def indent
+      self.indent_level += 1
+    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

@@ -0,0 +1,35 @@
+module Jisota
+  class Package
+    attr_accessor :name, :description, :params, :run_block, :verify_block
+
+    def initialize(name = nil, &block)
+      @params = []
+      @name = name
+      DSL.new(self).instance_eval(&block) if block_given?
+    end
+
+    alias_method :key, :name
+
+    class DSL
+      def initialize(target)
+        @target = target
+      end
+
+      def description(value)
+        @target.description = value
+      end
+
+      def param(name, options = {})
+        @target.params << Param.new(name, options)
+      end
+
+      def run(&block)
+        @target.run_block = ScriptBlock.new(&block)
+      end
+
+      def verify(&block)
+        @target.verify_block = ScriptBlock.new(&block)
+      end
+    end
+  end
+end