vps 0.1.1

data/lib/vps/cli/playbook.rb

@@ -0,0 +1,110 @@
+require "vps/cli/playbook/state"
+require "vps/cli/playbook/tasks"
+
+module VPS
+  class CLI < Thor
+    class Playbook
+
+      class NotFoundError < VPS::CLI::Error; end
+
+      YML = ".yml"
+
+      attr_reader :command
+
+      def self.all
+        Dir["#{VPS::PLAYBOOKS}/*#{YML}"].collect do |playbook|
+          command = File.basename(playbook, YML)
+          new(playbook, command)
+        end
+      end
+
+      def self.run(playbook, state)
+        playbook = File.expand_path(playbook, VPS::PLAYBOOKS)
+
+        if File.directory?(playbook)
+          playbook += "/#{state.server_version}"
+        end
+        unless File.extname(playbook) == YML
+          playbook += YML
+        end
+
+        new(playbook).run(state)
+      end
+
+      def initialize(playbook, command = nil)
+        unless File.exists?(playbook)
+          raise NotFoundError, "Could not find playbook #{playbook.inspect}"
+        end
+
+        @playbook = {"constants" => {}}.merge(YAML.load_file(playbook))
+        unless (playbooks = Dir[playbook.gsub(/\.\w+$/, "/*")].collect{|yml| File.basename(yml, ".yml")}).empty?
+          @playbook["constants"]["playbooks"] = playbooks
+        end
+
+        @command = command
+      end
+
+      def description
+        playbook["description"]
+      end
+
+      def usage
+        playbook["usage"] || arguments.collect(&:upcase).unshift(@command).join(" ")
+      end
+
+      def arguments
+        playbook["arguments"] || []
+      end
+
+      def constants
+        playbook["constants"] || {}
+      end
+
+      def options
+        options = playbook["options"] || {}
+        options[%w(-d --dry-run)] = :boolean
+        options
+      end
+
+      def tasks
+        @tasks ||= begin
+          tasks = [playbook["tasks"]].flatten.compact
+
+          if requires_confirmation?
+            tasks.unshift({
+              "task" => :confirm,
+              "question" => playbook["confirm"],
+              "indent" => false,
+              "n" => :abort
+            })
+          end
+
+          Tasks.new(tasks)
+        end
+      end
+
+      def run!(args, options)
+        hash = Hash[arguments.zip(args)]
+        state = State.new(hash.merge(options))
+        run(state)
+      end
+
+      def run(state)
+        state.scope(constants) do
+          tasks.run(state)
+        end
+      end
+
+    private
+
+      def playbook
+        @playbook
+      end
+
+      def requires_confirmation?
+        playbook["confirm"].to_s.strip != ""
+      end
+
+    end
+  end
+end

data/lib/vps/cli/playbook/state.rb

@@ -0,0 +1,170 @@
+module VPS
+  class CLI < Thor
+    class Playbook
+      class State
+
+        class AuthenticationFailedError < VPS::CLI::Error; end
+        class SSHMock
+          def initialize
+            puts "🏄‍♀️ ~> ".gray + "Mocking SSH connection with Ubuntu 18.04.2 LTS server".cyan
+          end
+          def exec!(command)
+            case command
+            when "cat /etc/lsb-release"
+              <<-LSB
+              DISTRIB_ID=Ubuntu
+              DISTRIB_RELEASE=18.04
+              DISTRIB_CODENAME=bionic
+              DISTRIB_DESCRIPTION="Ubuntu 18.04.2 LTS"
+              LSB
+            when "pwd"
+              "/home/myapp"
+            else
+              raise "Encountered unexpected command: #{command}"
+            end
+          end
+        end
+
+        SERVER_VERSION = "SERVER_VERSION"
+
+        def initialize(hash = {})
+          @stack = [hash.with_indifferent_access]
+        end
+
+        def dry_run?
+          !!fetch(:d)
+        end
+
+        def scope(constants = {})
+          stack.unshift(constants.with_indifferent_access)
+          constants.keys.each do |key|
+            self[key] = resolve(self[key])
+          end
+          yield
+          stack.shift
+        end
+
+        def fetch(key, default = nil)
+          stack.each do |hash|
+            return hash[key] if hash.key?(key)
+          end
+          default
+        end
+
+        def [](path)
+          to_domain = !!(path = path.dup).gsub!("domain:", "") if path.is_a?(String)
+          path.to_s.split(".").inject(self) do |hash, key|
+            (hash || {}).fetch(key)
+          end.tap do |value|
+            if to_domain && value
+              if (domain = value[:domains].first)
+                return domain.gsub(/https?:\/\//, "")
+              end
+            end
+          end
+        end
+
+        def []=(key, value)
+          stack.first[key] = value
+        end
+
+        def to_binding(object = self)
+          case object
+          when State
+            keys = stack.collect(&:keys).flatten.uniq
+            keys.inject({state: object}) do |hash, key|
+              hash[key] = to_binding(self[key])
+              hash
+            end
+          when Hash
+            hash = object.inject({}) do |hash, (key, value)|
+              hash[key] = to_binding(resolve(value))
+              hash
+            end
+            OpenStruct.new(hash)
+          when Array
+            object.collect{|object| to_binding(object)}
+          else
+            object
+          end
+        end
+
+        def resolve(arg)
+          if arg.is_a?(String)
+            if arg.match(/^<<\s*(.*?)\s*>>$/)
+              self[$1]
+            else
+              arg.gsub(/\{\{(\{?)\s*(.*?)\s*\}\}\}?/) do
+                value = self[$2]
+                ($1 == "{") ? value.inspect : value
+              end
+            end
+          else
+            arg
+          end
+        end
+
+        def execute(command, user = nil)
+          if user
+            command = "sudo -u #{user} -H sh -c #{command.inspect}"
+          end
+          puts "🏄‍♀️ ~> ".gray + command.yellow
+          unless dry_run?
+            start = Time.now
+            result = []
+
+            channel = ssh.open_channel do |ch|
+              ch.exec(command) do |ch|
+                ch.on_data do |_, data|
+                  unless data.blank?
+                    data = data.split("\n").reject(&:blank?)
+                    puts "   " + data.join("\n   ")
+                    result.concat data
+                  end
+                end
+              end
+            end
+            channel.wait
+
+            puts "   #{(Time.now - start).round(3)}s".gray
+            result.join("\n")
+          end
+        end
+
+        def home_directory
+          @home_directory ||= ssh.exec!("pwd").strip
+        end
+
+        def server_version
+          @server_version ||= begin
+            release = ssh.exec!("cat /etc/lsb-release")
+
+            distribution = release.match(/DISTRIB_ID=(.*)/)[1].underscore
+            release = release.match(/DISTRIB_RELEASE=(.*)/)[1]
+
+            [distribution, release].join("-")
+          end
+        end
+
+      private
+
+        def stack
+          @stack
+        end
+
+        def ssh
+          @ssh ||= begin
+            if dry_run?
+              SSHMock.new
+            else
+              Net::SSH.start(fetch(:host), fetch(:user))
+            end
+          end
+        rescue StandardError => e
+          raise AuthenticationFailedError, e.message
+        end
+
+      end
+    end
+  end
+end

data/lib/vps/cli/playbook/tasks.rb

@@ -0,0 +1,262 @@
+module VPS
+  class CLI < Thor
+    class Playbook
+      class Tasks
+
+        class InvalidTaskError < VPS::CLI::Error; end
+
+        def self.available
+          public_instance_methods(false) - [:run]
+        end
+
+        def initialize(tasks)
+          @tasks = [tasks].flatten.compact
+        end
+
+        def run(state)
+          @tasks.collect do |task|
+            case task
+            when :continue # next
+            when :abort
+              raise Interrupt
+            else
+              run_task(state, task)
+            end
+          end
+        end
+
+        def run_tasks(state, options)
+          tasks = (state.resolve(options[:tasks]) || []).compact
+          Tasks.new(tasks).run(state)
+        end
+
+        def ensure(state, options)
+          argument = state.resolve(options[:argument])
+
+          if state[argument].blank?
+            options[:fallbacks].each do |task|
+              unless (value = run_task(state, task.merge(as: argument))).blank?
+                set(state, argument, value)
+                break
+              end
+            end
+          end
+        end
+
+        def obtain_config(state, options)
+          VPS.read_config(state[:host]).tap do |config|
+            config.each do |key, value|
+              set(state, key, value)
+            end
+          end
+        end
+
+        def read_config(state, options)
+          VPS.read_config(state[:host], state.resolve(options[:key]))
+        end
+
+        def write_config(state, options)
+          config = {}
+
+          options[:config].each do |key, spec|
+            spec = spec.with_indifferent_access if spec.is_a?(Hash)
+
+            if spec.is_a?(Hash) && spec[:task]
+              config[key] = run_task(state, spec)
+            else
+              config[key] = state.resolve(spec)
+            end
+          end
+
+          unless state.dry_run?
+            VPS.write_config(state[:host], config)
+          end
+        end
+
+        def loop(state, options)
+          if (collection = (state.resolve(options[:through]) || []).compact).any?
+            puts_description(state, options)
+            as = state.resolve(options[:as])
+            collection.each do |item|
+              state.scope({as => item}) do
+                run_tasks(state, {:tasks => options[:run]})
+              end
+            end
+          end
+        end
+
+        def when(state, options)
+          if state[options[:boolean]]
+            puts_description(state, options)
+            run_tasks(state, {:tasks => options[:run]})
+          end
+        end
+
+        def confirm(state, options)
+          answer = Ask.confirm(question(options)) ? "y" : "n"
+          tasks = options[answer]
+          set(state, options, answer)
+          run_tasks(state, {:tasks => tasks})
+        end
+
+        def select(state, options)
+          list = state.resolve(options[:options])
+          index = Ask.list(question(options), list)
+          set(state, options, list[index])
+        end
+
+        def multiselect(state, options)
+          names, labels, defaults = [], [], []
+
+          options[:options].inject([names, labels, defaults]) do |_, (name, label)|
+            default = true
+            label = label.gsub(/ \[false\]$/) do
+              default = false
+              ""
+            end
+            names.push(name)
+            labels.push(label)
+            defaults.push(default)
+          end
+
+          selected = Ask.checkbox(question(options), labels, default: defaults)
+          selected.each_with_index do |value, index|
+            name = names[index]
+            state[name] = value
+          end
+        end
+
+        def input(state, options)
+          answer = Ask.input(question(options), default: state.resolve(options[:default]))
+          set(state, options, answer)
+        end
+
+        def generate_file(state, options)
+          erb = VPS.read_template(state.resolve(options[:template]))
+          template = Erubis::Eruby.new(erb)
+          content = template.result(state.to_binding)
+
+          unless state.dry_run?
+            if target = state.resolve(options[:target])
+              target = File.expand_path(target)
+              FileUtils.mkdir_p(File.dirname(target))
+              File.open(target, "w") do |file|
+                file.write(content)
+              end
+            end
+          end
+
+          content
+        end
+
+        def execute(state, options)
+          output = [options[:command]].flatten.inject(nil) do |_, command|
+            command = state.resolve(command)
+            puts "☕ ~> ".gray + command.yellow
+            unless state.dry_run?
+              start = Time.now
+              result = []
+
+              IO.popen(command).each do |data|
+                unless data.blank?
+                  data = data.split("\n").reject(&:blank?)
+                  puts "   " + data.join("\n   ")
+                  result.concat data
+                end
+              end
+
+              puts "   #{(Time.now - start).round(3)}s".gray
+              result.join("\n")
+            end
+          end
+          set(state, options, output)
+        end
+
+        def remote_execute(state, options)
+          user = state.resolve(options[:user])
+          output = [options[:command]].flatten.inject(nil) do |_, command|
+            command = state.resolve(command)
+            state.execute(command, user)
+          end
+          set(state, options, output)
+        end
+
+        def upload(state, options)
+          host = state[:host]
+
+          file = state.resolve(options[:file])
+          remote_path = options[:remote_path] ? state.resolve(options[:remote_path]) : file
+          file = "-r #{file}" if File.directory?(file)
+
+          return if file.blank?
+
+          remote_path = remote_path.gsub("~", state.home_directory)
+
+          remote_execute(state, {:command => "mkdir -p #{File.dirname(remote_path)}"})
+          execute(state, {:command => "scp #{file} #{host}:#{remote_path} > /dev/tty"})
+        end
+
+        def sync(state, options)
+          host = state[:host]
+
+          directory = state.resolve(options[:directory])
+          remote_path = options[:remote_path] ? state.resolve(options[:remote_path]) : directory
+
+          return if directory.blank?
+
+          remote_path = remote_path.gsub("~", state.home_directory)
+
+          remote_execute(state, {:command => "mkdir -p #{File.dirname(remote_path)}"})
+          execute(state, {:command => "rsync #{options[:options]} #{directory} #{host}:#{remote_path} > /dev/tty"})
+        end
+
+        def playbook(state, options)
+          Playbook.run(state.resolve(options[:playbook]), state)
+        end
+
+        def print(state, options)
+          puts state.resolve(options[:message])
+        end
+
+      private
+
+        def run_task(state, task)
+          name, options = derive_task(task)
+          if name
+            puts_description(state, options) unless [:when, :loop].include?(name)
+            send(name, state, options)
+          else
+            raise InvalidTaskError, "Invalid task #{task.inspect}"
+          end
+        end
+
+        def derive_task(task)
+          if task.is_a?(Hash)
+            task = task.with_indifferent_access
+            name = task.delete(:task).to_sym
+            if Tasks.available.include?(name)
+              [name, task]
+            end
+          end
+        end
+
+        def puts_description(state, options)
+          if description = state.resolve(options[:description])
+            puts "\n== ".yellow + description.green
+          end
+        end
+
+        def question(options)
+          (options[:indent] == false ? "" : "   ") + options[:question]
+        end
+
+        def set(state, as, value)
+          if key = (as.is_a?(Hash) ? as[:as] : as)
+            state[key] = value
+          end
+        end
+
+      end
+    end
+  end
+end