propro 0.1.0

data/lib/propro/cli.rb

@@ -0,0 +1,125 @@
+require 'thor'
+
+module Propro
+  class CLI < Thor
+    include Thor::Actions
+
+    INIT_TEMPLATES = {
+      db: {
+        paths: %w[ vps db ],
+        desc: 'backend database server'
+      },
+      app: {
+        paths: %w[ vps app ],
+        desc: 'frontend application server'
+      },
+      web: {
+        paths: %w[ vps app db ],
+        desc: 'standalone web server'
+      },
+      vagrant: {
+        paths: %w[ vagrant ],
+        desc: 'standalone Vagrant development VM'
+      }
+    }
+
+    def self.source_root
+      File.join(File.dirname(__FILE__), 'cli/templates')
+    end
+
+    desc 'init NAME', 'Creates a Propro script with the file name NAME'
+    option :template, aliases: '-t', enum: %w[ db app web vagrant ], default: 'web'
+    def init(outname = nil)
+      key      = options[:template].to_sym
+      outfile  = absolute_path(outname || "#{key}.propro")
+      type     = INIT_TEMPLATES[key]
+      @paths   = type[:paths]
+      @desc    = type[:desc]
+      @sources = Package.sources_for_paths('lib', *@paths)
+      template 'init.tt', outfile
+    end
+
+    desc 'build INPUT', 'Takes a Propro script INPUT and generates a Bash provisioner OUTPUT'
+    option :output, aliases: '-o', banner: '<output file name>'
+    def build(input)
+      infile = absolute_path(input)
+      script = Script.load(input).to_bash
+      if (output = options[:output])
+        File.write(absolute_path(output), script)
+      else
+        STDOUT << script
+      end
+    end
+
+    desc 'deploy SCRIPT', 'Builds a Propro script and then executes it remotely'
+    option :server,   aliases: '-s', banner: '<server address>'
+    option :password, aliases: '-p', banner: '<server password>'
+    option :user,     aliases: '-u', banner: '<server user>', default: 'root'
+    def deploy(script_path)
+      require 'net/ssh'
+      require 'net/scp'
+      require 'io/console'
+
+      puts Propro.color_banner
+      puts
+
+      script   = Script.load(script_path)
+      address  = (options[:server] || script.get_server)
+      password = (options[:password] || script.get_password || ask_password)
+      user     = (options[:user] || script.get_user)
+      remote_home = (user == 'root' ? '/root' : "/home/#{user}")
+      remote_log_path    = "#{remote_home}/provision.log"
+      remote_script_path = "#{remote_home}/provision.sh"
+      remote_script_url  = address + remote_script_path
+
+      say_event 'build', script_path
+      script_data = StringIO.new(script.to_bash)
+
+      raise ArgumentError, 'no server address has been provided'  if !address
+      raise ArgumentError, 'no server password has been provided' if !password
+
+      say_event 'connect', "#{user}@#{address}"
+      Net::SSH.start(address, user, password: password) do |session|
+        say_event 'upload', "#{script_path} -> #{remote_script_url}"
+        session.scp.upload!(script_data, remote_script_path)
+        session.exec!("chmod +x #{remote_script_path}")
+        session.exec!("touch #{remote_log_path}")
+        tail = session.exec("tail -f #{remote_log_path}") do |ch|
+          ch.on_data do |ch, data|
+            STDOUT.write(data)
+            STDOUT.flush
+          end
+        end
+
+        sleep 1 # ughhhhhh
+        say_event 'run', remote_script_url
+        puts
+        session.exec(remote_script_path)
+      end
+    rescue IOError # uggghhhhhhhhhh
+      say_event 'done', "#{address} is rebooting"
+    end
+
+    private
+
+    def say_event(event, msg)
+      pad = (7 - event.length)
+      label = "#{event.upcase}" + (" " * pad)
+      puts "\e[36m\e[1m#{label}\e[0m #{msg}"
+    end
+
+    def ask_password
+      STDIN.noecho do
+        ask 'password:'
+      end
+    end
+
+    def absolute_path(path)
+      if path[0] == '/'
+        path
+      else
+        File.join(Dir.pwd, path)
+      end
+    end
+  end
+end

data/lib/propro/command.rb

@@ -0,0 +1,17 @@
+module Propro
+  class Command
+    attr_reader :name
+
+    def initialize(name)
+      @name = name.to_s
+    end
+
+    def function_name
+      @function_name ||= "provision-#{name.gsub(/\/|\_/, '-')}"
+    end
+
+    def to_bash
+      function_name
+    end
+  end
+end

data/lib/propro/export.rb

@@ -0,0 +1,119 @@
+module Propro
+  class Export
+    TAG_SPECIFY   = '@specify'
+    TAG_REQUIRE   = '@require'
+    EXPORT_BEGIN  = 'export '
+    COMMENT_RANGE = /#(.*)\Z/
+    DQUO          = '"'
+    SQUO          = '\''
+    EQ            = '='
+    ZERO_STRING   = ''
+    INTEGER_RE    = /\A\-{0,1}[0-9]+\Z/
+    DECIMAL_RE    = /\A\-{0,1}[0-9]+\.[0-9]+\Z/
+    SPACE_RE      = / /
+    YES           = 'yes'
+    NO            = 'no'
+
+    def self.parse(line)
+      is_literal   = false
+      is_specified = false
+      is_required  = false
+      comment      = nil
+      line         = line.sub(EXPORT_BEGIN, ZERO_STRING)
+      name, value  = line.split(EQ, 2)
+
+      if value =~ COMMENT_RANGE
+        metacomment = $1
+        is_specified = true if metacomment.sub!(TAG_SPECIFY, ZERO_STRING)
+        is_required  = true if metacomment.sub!(TAG_REQUIRE, ZERO_STRING)
+        metacomment.strip!
+
+        if metacomment != ZERO_STRING
+          comment = metacomment
+        end
+      end
+
+      value.sub!(COMMENT_RANGE, ZERO_STRING)
+      value.strip!
+
+      case value[0]
+      when DQUO
+        value[0]  = ZERO_STRING
+        value[-1] = ZERO_STRING
+      when SQUO
+        is_literal = true
+        value[0]   = ZERO_STRING
+        value[-1]  = ZERO_STRING
+      end
+
+      new name,
+        default:      value,
+        is_literal:   is_literal,
+        is_specified: is_specified,
+        is_required:  is_required,
+        comment:      comment
+    end
+
+    def initialize(name, opts = {})
+      @name         = name.to_s.upcase
+      @default      = opts[:default]
+      @is_literal   = opts[:is_literal]
+      @is_specified = opts[:is_specified]
+      @is_required  = opts[:is_required]
+      @comment      = opts[:comment]
+    end
+
+    def key
+      @key ||= @name.downcase.to_sym
+    end
+
+    def to_ruby
+      args = []
+      args << key.inspect
+      args << default.inspect
+      args << "lit: true" if @is_literal
+      if @comment
+        "set #{args.join(', ')} # #{@comment}"
+      else
+        "set #{args.join(', ')}"
+      end
+    end
+
+    def default
+      cast(@default)
+    end
+
+    def is_literal?
+      @is_literal
+    end
+
+    def is_specified?
+      @is_specified
+    end
+
+    def is_required?
+      @is_required
+    end
+
+    protected
+
+    def cast(val)
+      case val
+      when INTEGER_RE
+        val.to_i
+      when DECIMAL_RE
+        val.to_f
+      when ZERO_STRING
+        nil
+      when SPACE_RE
+        val.split(' ')
+      when YES
+        true
+      when NO
+        false
+      else
+        val
+      end
+    end
+  end
+end

data/lib/propro/option.rb

@@ -0,0 +1,36 @@
+module Propro
+  class Option
+    attr_reader :name
+
+    def initialize(key, value, opts = {})
+      @key        = key.to_s.downcase.to_sym
+      @value      = value
+      @is_literal = opts[:lit] ? true : false
+    end
+
+    def name
+      @name ||= @key.to_s.upcase
+    end
+
+    def value=(val)
+      @value = val
+    end
+
+    def value
+      case @value
+      when Array
+        %{"#{@value.join(' ')}"}
+      when true
+        %{"yes"}
+      when false
+        %{"no"}
+      else
+        @is_literal ? %{'#{@value}'} : %{"#{@value}"}
+      end
+    end
+
+    def to_bash
+      "#{name}=#{value}"
+    end
+  end
+end

data/lib/propro/package.rb

@@ -0,0 +1,68 @@
+module Propro
+  module Package
+    EXTRACT_NAME_RE = %r{/ext/bash/([a-z0-9_\-/]+)\.sh}
+    SORTED_NAMES = %w[
+      lib/propro
+      lib/ubuntu
+      lib/system
+      lib/pg
+      lib/rvm
+      lib/nginx
+      lib/node
+      lib/redis
+      vps/system
+      app
+      app/rvm
+      app/pg
+      app/nginx
+      app/sidekiq
+      app/puma
+      app/puma/nginx
+      app/node
+      db/pg
+      db/redis
+      vagrant
+      vagrant/system
+      vagrant/pg
+      vagrant/redis
+      vagrant/rvm
+      vagrant/node
+      vagrant/nginx
+      lib/extras
+    ]
+
+    module_function
+
+    def root
+      File.join(Propro.root, 'ext/bash')
+    end
+
+    def source_files
+      @source_files ||= Dir[File.join(root, '**/*.sh')]
+    end
+
+    def sources
+      @sources ||= begin
+        names = SORTED_NAMES.dup
+        source_files.each do |file|
+          name = EXTRACT_NAME_RE.match(file)[1]
+          names.push(name) unless names.include?(name)
+        end
+        names.map { |name| Source.new(name) }
+      end
+    end
+
+    def sources_for_path(path)
+      resort! sources.select { |source| /\A#{path}/ =~ source.name }
+    end
+
+    def sources_for_paths(*paths)
+      resort! paths.flatten.map { |path| sources_for_path(path) }.flatten
+    end
+
+    def resort!(ary)
+      ary.sort_by! { |source| SORTED_NAMES.index(source.name) }
+      ary
+    end
+  end
+end

data/lib/propro/script.rb

@@ -0,0 +1,95 @@
+module Propro
+  class Script
+    def self.load(file)
+      script = new
+      script.load_file(file)
+      script
+    end
+
+    def initialize
+      @sources  = []
+      @options  = []
+      @commands = []
+      @server   = nil
+      @password = nil
+      source :lib
+    end
+
+    def load_file(file)
+      @file = file
+      @file_name = File.basename(@file)
+      instance_eval(File.read(file))
+    end
+
+    def server(host, opts = {})
+      @server   = host
+      @password = opts[:password]
+      @user     = opts[:user] || 'root'
+    end
+
+    def get_server
+      @server
+    end
+
+    def get_password
+      @password
+    end
+
+    def get_user
+      @user
+    end
+
+    def source(src)
+      @sources.concat(Package.sources_for_path(src))
+    end
+
+    def set(key, value)
+      @options << Option.new(key, value)
+    end
+
+    def provision(*commands)
+      @commands.concat(commands.flatten.map { |c| Command.new(c) })
+    end
+
+    def to_bash
+      <<-SH
+#!/usr/bin/env bash
+#{Propro.comment_banner}
+#
+# Built from: #{@file_name}
+
+unset UCF_FORCE_CONFFOLD
+export UCF_FORCE_CONFFNEW="YES"
+export DEBIAN_FRONTEND="noninteractive"
+
+#{sources_bash}
+
+# Options from: #{@file_name}
+#{options_bash}
+
+function main {
+  #{commands_bash}
+  finished
+  reboot-system
+}
+
+main
+
+SH
+    end
+
+    private
+
+    def options_bash
+      @options.map(&:to_bash).join("\n").strip
+    end
+
+    def sources_bash
+      @sources.map(&:to_bash).join("\n").strip
+    end
+
+    def commands_bash
+      @commands.map(&:to_bash).join("\n  ")
+    end
+  end
+end

data/lib/propro/source.rb

@@ -0,0 +1,86 @@
+module Propro
+  class Source
+    attr_reader :name, :provisioner
+
+    EXPORT_BEGIN         = 'export '
+    COMMENT_BEGIN        = '#'
+    IS_LIBRARY_BEGIN     = 'lib/'
+    FUNC_PROVISION_BEGIN = 'function provision-'
+    FUNC_PROVISION_NAME_RANGE = /\Afunction provision\-([a-z\-]+)/
+
+    def initialize(name)
+      @name          = name.to_s
+      @exports       = []
+      @can_provision = false
+      @is_library    = name.start_with?(IS_LIBRARY_BEGIN)
+      @src           = ''
+      load
+    end
+
+    def file_name
+      "#{@name}.sh"
+    end
+
+    def file_path
+      File.join(Propro::Package.root, file_name)
+    end
+
+    def load
+      File.open(file_path) do |file|
+        file.each_line { |line| load_line(line) }
+      end
+    end
+
+    def can_provision?
+      @can_provision
+    end
+
+    def is_library?
+      @is_library
+    end
+
+    def specified_exports
+      @specified_exports ||= begin
+        exports.select { |e| e.is_required? || e.is_specified? }
+      end
+    end
+
+    def exports
+      @exports.sort { |a, b|
+        case
+          when b.is_required? then 1
+          when b.is_specified? then 0
+          else -1
+        end
+      }
+    end
+
+    def to_bash
+      <<-SH
+# Propro package: #{file_name}
+#{@src}
+      SH
+    end
+
+    protected
+
+    def load_line(line)
+      case
+      when line.start_with?(COMMENT_BEGIN)
+        # skip comments
+      when line.start_with?(EXPORT_BEGIN)
+        # collect exported variables from bash modules
+        @exports << Export.parse(line)
+        @src << line.sub(EXPORT_BEGIN, '')
+      when line.start_with?(FUNC_PROVISION_BEGIN)
+        @can_provision = true
+        path = line.match(FUNC_PROVISION_NAME_RANGE)[1]
+        @provisioner = path.gsub('-', '/')
+        @src << line
+      else
+        # pass-through
+        @src << line
+      end
+    end
+  end
+end

data/lib/propro/version.rb

@@ -0,0 +1,3 @@
+module Propro
+  VERSION = '0.1.0'
+end

data/lib/propro.rb

@@ -0,0 +1,57 @@
+require 'propro/version'
+require 'propro/package'
+require 'propro/export'
+require 'propro/source'
+require 'propro/script'
+require 'propro/command'
+require 'propro/option'
+
+module Propro
+  class Error < StandardError; end
+
+  BANNER = <<'DOC'.chomp
+    ____  _________  ____  _________
+   / __ \/ ___/ __ \/ __ \/ ___/ __ \
+  / /_/ / /  / /_/ / /_/ / /  / /_/ /
+ / .___/_/   \____/ .___/_/   \____/
+/_/              /_/
+DOC
+
+  module_function
+
+  def banner
+    BANNER
+  end
+
+  # <3 <3 <3 Lifted from Minitest::Pride <3 <3 <3
+  # https://github.com/seattlerb/minitest/blob/master/lib/minitest/pride_plugin.rb
+  def color_banner
+    @color_banner ||= begin
+      if /^xterm|-256color$/ =~ ENV['TERM']
+        pi3    = Math::PI / 3
+        colors = (0...(6 * 7)).map { |n|
+          n *= 1.0 / 6
+          r  = (3 * Math.sin(n          ) + 3).to_i
+          g  = (3 * Math.sin(n + 2 * pi3) + 3).to_i
+          b  = (3 * Math.sin(n + 4 * pi3) + 3).to_i
+          36 * r + 6 * g + b + 16
+        }
+        banner.each_line.map { |line|
+          line.each_char.with_index.map { |chr, i|
+            "\e[38;5;#{colors[i]}m#{chr}\e[0m"
+          }.join
+        }.join
+      else
+        "\e[2m#{banner}\e[0m"
+      end
+    end
+  end
+
+  def comment_banner
+    @comment_banner ||= banner.each_line.map { |l| '# ' + l }.join
+  end
+
+  def root
+    File.expand_path(File.join(File.dirname(__FILE__), '..'))
+  end
+end

data/propro.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'propro/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'propro'
+  spec.version       = Propro::VERSION
+  spec.authors       = ['Carsten Nielsen']
+  spec.email         = ['heycarsten@gmail.com']
+  spec.summary       = 'A standalone server provisioning tool'
+  spec.description   = 'Propro is a tool for provisioning remote servers.'
+  spec.homepage      = 'http://github.com/heycarsten/propro'
+  spec.license       = 'GNU v2'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(/^bin\//) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(/^test\//)
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'thor',    '~> 0.18'
+  spec.add_dependency 'net-scp', '~> 1.1'
+
+  spec.add_development_dependency 'bundler', '~> 1.5'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'minitest'
+end