simple_infrastructure 0.1.0

data/lib/simple_infrastructure/cli.rb

@@ -0,0 +1,306 @@
+# frozen_string_literal: true
+
+module SimpleInfrastructure
+  class Cli
+    SPINNER_FRAMES = %w[⠋ ⠙ ⠹ ⠸ ⠼ ⠴ ⠦ ⠧ ⠇ ⠏].freeze
+    RED = "\e[31m"
+    GREEN = "\e[1;92m"
+    YELLOW = "\e[33m"
+    RESET = "\e[0m"
+    CLEAR_LINE = "\r\e[K"
+
+    def initialize(argv)
+      @argv = argv
+      @results = []
+      @dry_run = false
+      @verbose = false
+      @args = []
+      parse_options!
+    end
+
+    def run
+      if @args.empty?
+        usage
+        exit 1
+      end
+
+      command = @args.shift
+
+      case command
+      when "new"
+        generate_change(@args.first)
+      when "status"
+        run_status
+      when /\./
+        run_hostname(command)
+      else
+        run_environment(command)
+      end
+    end
+
+    private
+
+    def parse_options!
+      @argv.each do |arg|
+        case arg
+        when "--dry-run", "-n"
+          @dry_run = true
+        when "--verbose", "-v"
+          @verbose = true
+        when "--help", "-h"
+          usage
+          exit 0
+        else
+          @args << arg
+        end
+      end
+    end
+
+    def usage
+      puts <<~USAGE
+        Usage: #{$0} [options] <command>
+
+        Commands:
+          <environment>     Run pending changes on all servers in environment
+          <hostname>        Run pending changes on specific server
+          status            Show change status for all servers
+          new <name>        Generate a new change file
+
+        Options:
+          --dry-run, -n     Show what would be done without executing
+          --verbose, -v     Show detailed output (e.g., list pending changes in status)
+          --help, -h        Show this help
+
+        Examples:
+          #{$0} status
+          #{$0} status -v
+          #{$0} new setup_redis
+          #{$0} --dry-run staging
+          #{$0} production
+          #{$0} web1.production.example.com
+      USAGE
+    end
+
+    def generate_change(name)
+      unless name
+        puts "Usage: #{$0} new <change_name>"
+        puts "Example: #{$0} new setup_redis"
+        exit 1
+      end
+
+      timestamp = Time.now.strftime("%Y%m%d%H%M%S")
+      filename = "#{timestamp}_#{name}.rb"
+      path = File.join(SimpleInfrastructure.configuration.changes_dir, filename)
+
+      FileUtils.mkdir_p(File.dirname(path))
+
+      template = <<~RUBY
+        target env: :production
+
+        # run "command", sudo: true
+
+        # file "/path/to/file", sudo: true do
+        #   contains "line that must exist"
+        #   remove "line that must not exist"
+        #   on_change { run "systemctl restart service", sudo: true }
+        # end
+
+        # yaml "/path/to/config.yml", sudo: true do
+        #   set "key.path", "value"
+        #   remove "old.key"
+        # end
+
+        # toml "/path/to/config.toml", sudo: true do
+        #   set "key.path", "value"
+        #   remove "old.key"
+        # end
+
+        # upload "config/backup/script.sh", "/root/bin/script.sh", sudo: true, mode: "700"
+      RUBY
+
+      File.write(path, template)
+      puts "Created: #{path}"
+    end
+
+    def run_status
+      runner = SimpleInfrastructure::Runner.new(dry_run: @dry_run)
+      by_env = runner.inventory.servers.group_by(&:env)
+
+      puts "🔧 Infrastructure Status -------------------------------------------------------\n\n"
+
+      by_env.keys.sort.each_with_index do |env, env_index|
+        servers = by_env[env]
+
+        title = env.to_s.split("_").map(&:capitalize).join(" ")
+        divider = "-" * (72 - title.length - 1)
+        puts "#{title} #{divider}"
+
+        servers.each do |server|
+          pending, error = with_spinner(server.hostname) do
+            runner.check_server_status(server)
+          end
+
+          if error
+            puts "  #{YELLOW}?#{RESET} #{server.hostname} (unable to connect)"
+          elsif pending.empty?
+            puts "  #{GREEN}✔︎#{RESET} #{server.hostname} (up to date)"
+          else
+            puts "  #{RED}✗#{RESET} #{server.hostname} (#{pending.count} pending)"
+            if @verbose
+              pending.each { |c| puts "      #{c.name}" }
+            end
+          end
+        end
+
+        puts if env_index < by_env.keys.length - 1
+      end
+    end
+
+    def run_hostname(hostname)
+      runner = SimpleInfrastructure::Runner.new(dry_run: @dry_run)
+      server = runner.inventory.find_by_hostname(hostname)
+
+      unless server
+        puts "#{RED}Server not found: #{hostname}#{RESET}"
+        exit 1
+      end
+
+      puts "🔧 Infrastructure Run#{@dry_run ? ' (DRY RUN)' : ''} " \
+           "-------------------------------------------------------\n\n"
+
+      step(server.to_s, show_output: @dry_run) do
+        runner.run_for_server(server)
+      end
+
+      puts
+
+      if passed?
+        puts "🎉 All changes applied successfully"
+        exit 0
+      else
+        puts "💥 #{failure_count} server#{'s' if failure_count != 1} failed"
+        exit 1
+      end
+    end
+
+    def run_environment(env)
+      runner = SimpleInfrastructure::Runner.new(dry_run: @dry_run)
+      servers = runner.inventory.find_by_env(env)
+
+      if servers.empty?
+        puts "#{RED}No servers found for environment: #{env}#{RESET}"
+        exit 1
+      end
+
+      puts "🔧 Infrastructure Run — #{env}#{@dry_run ? ' (DRY RUN)' : ''} " \
+           "-------------------------------------------------------\n\n"
+
+      servers.each do |server|
+        step(server.to_s, show_output: @dry_run) do
+          runner.run_for_server(server)
+        end
+      end
+
+      puts
+
+      if passed?
+        puts "🎉 All servers updated successfully"
+        exit 0
+      else
+        puts "💥 #{failure_count} server#{'s' if failure_count != 1} failed"
+        exit 1
+      end
+    end
+
+    def with_spinner(label)
+      frame_index = 0
+      done = false
+      result = nil
+      error = nil
+
+      thread = Thread.new do
+        result = yield
+      rescue => e
+        error = e
+      ensure
+        done = true
+      end
+
+      until done
+        print "#{CLEAR_LINE}#{SPINNER_FRAMES[frame_index % SPINNER_FRAMES.size]} #{label}"
+        $stdout.flush
+        frame_index += 1
+        sleep 0.08
+      end
+
+      thread.join
+      print CLEAR_LINE
+
+      [result, error]
+    end
+
+    def step(label, show_output: false)
+      output_capture = StringIO.new
+      captured_logger = ::Logger.new(output_capture)
+      captured_logger.formatter = proc { |_sev, _time, _prog, msg| "#{msg}\n" }
+
+      original_logger = SimpleInfrastructure.configuration.logger
+      SimpleInfrastructure.configuration.logger = captured_logger
+
+      frame_index = 0
+      done = false
+      success = false
+      error = nil
+
+      thread = Thread.new do
+        success = yield
+      rescue => e
+        error = e
+      ensure
+        done = true
+      end
+
+      until done
+        print "#{CLEAR_LINE}#{SPINNER_FRAMES[frame_index % SPINNER_FRAMES.size]} #{label}"
+        $stdout.flush
+        frame_index += 1
+        sleep 0.08
+      end
+
+      thread.join
+      SimpleInfrastructure.configuration.logger = original_logger
+
+      output = output_capture.string
+                 .gsub(/\e\[[0-9;]*[A-Za-z]/, "")
+                 .gsub(/\r/, "")
+                 .lines
+                 .reject { |l| l.strip.empty? || l.include?("connecting...") || l.include?(": up to date") }
+                 .join
+                 .strip
+
+      if error || !success
+        print "#{CLEAR_LINE}#{RED}⚠️  #{label}#{RESET}\n"
+        puts output unless output.empty?
+        puts "    #{error.message}" if error
+        puts
+        @results << false
+      elsif show_output && !output.empty?
+        print "#{CLEAR_LINE}⏳ #{label}\n"
+        puts output
+        puts
+        @results << true
+      else
+        print "#{CLEAR_LINE}✅ #{label}\n"
+        @results << true
+      end
+    end
+
+    def passed?
+      @results.all?
+    end
+
+    def failure_count
+      @results.count(false)
+    end
+  end
+end

data/lib/simple_infrastructure/configuration.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "logger"
+
+module SimpleInfrastructure
+  class Configuration
+    attr_accessor :project_root, :logger
+    attr_writer :config_dir
+
+    def initialize
+      @project_root = Dir.pwd
+      @logger = default_logger
+      @config_dir = nil
+    end
+
+    def config_dir
+      @config_dir || File.join(project_root, "config", "infrastructure")
+    end
+
+    def changes_dir
+      File.join(config_dir, "changes")
+    end
+
+    def inventory_path
+      File.join(config_dir, "inventory.yml")
+    end
+
+    private
+
+    def default_logger
+      logger = ::Logger.new($stdout)
+      logger.formatter = proc { |_sev, _time, _prog, msg| "#{msg}\n" }
+      logger
+    end
+  end
+end

data/lib/simple_infrastructure/dry_run_connection.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module SimpleInfrastructure
+  # For dry-run mode
+  class DryRunConnection
+    attr_reader :server
+
+    def initialize(server)
+      @server = server
+    end
+
+    def connect
+      self
+    end
+
+    def disconnect; end
+
+    def exec(_command)
+      { stdout: "", stderr: "", exit_code: 0, success: true }
+    end
+
+    def read_file(_path, sudo: false) # rubocop:disable Lint/UnusedMethodArgument
+      ""
+    end
+
+    def write_file(path, content, sudo: false)
+      SimpleInfrastructure.logger.debug "    Would write #{content.lines.count} lines to #{path}#{' (sudo)' if sudo}"
+    end
+
+    def file_exists?(_path, sudo: false) # rubocop:disable Lint/UnusedMethodArgument
+      false
+    end
+  end
+end

data/lib/simple_infrastructure/dsl.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module SimpleInfrastructure
+  module Dsl
+    class ChangeBuilder
+      attr_reader :change
+
+      def initialize(name)
+        @change = Change.new(name)
+      end
+
+      def target(...)
+        change.target(...)
+      end
+
+      def run(command, sudo: false)
+        change.add_step(RunStep.new(command, sudo: sudo))
+      end
+
+      def file(path, sudo: false, &block)
+        step = FileStep.new(path, sudo: sudo)
+        step.instance_eval(&block) if block_given?
+        change.add_step(step)
+      end
+
+      def yaml(path, sudo: false, &block)
+        step = YamlStep.new(path, sudo: sudo)
+        step.instance_eval(&block) if block_given?
+        change.add_step(step)
+      end
+
+      def toml(path, sudo: false, &block)
+        step = TomlStep.new(path, sudo: sudo)
+        step.instance_eval(&block) if block_given?
+        change.add_step(step)
+      end
+
+      def upload(local_path, remote_path, sudo: false, mode: nil)
+        change.add_step(UploadStep.new(local_path, remote_path, sudo: sudo, mode: mode))
+      end
+    end
+
+    class << self
+      def load_file(path)
+        # Extract change name from filename: 20250120143000_setup_nginx.rb -> 20250120143000_setup_nginx
+        name = File.basename(path, ".rb")
+        builder = ChangeBuilder.new(name)
+        builder.instance_eval(File.read(path), path)
+        builder.change
+      end
+    end
+  end
+end

data/lib/simple_infrastructure/file_operations.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module SimpleInfrastructure
+  class FileOperations
+    def initialize(connection, path, sudo: false, dry_run: false)
+      @connection = connection
+      @path = path
+      @sudo = sudo
+      @dry_run = dry_run
+    end
+
+    def apply(operations)
+      content = @connection.read_file(@path, sudo: @sudo)
+      lines = content.lines.map(&:chomp)
+      modified = false
+
+      operations.each do |op, *args|
+        case op
+        when :contains
+          line = args[0]
+          unless lines.include?(line.chomp)
+            SimpleInfrastructure.logger.debug "    + #{line}"
+            lines << line.chomp
+            modified = true
+          end
+        when :remove
+          line = args[0].chomp
+          if lines.include?(line)
+            SimpleInfrastructure.logger.debug "    - #{line}"
+            lines.delete(line)
+            modified = true
+          end
+        end
+      end
+
+      if modified
+        new_content = "#{lines.join("\n")}\n"
+        unless @dry_run
+          @connection.write_file(@path, new_content, sudo: @sudo)
+        end
+      else
+        SimpleInfrastructure.logger.debug "    (no changes needed)"
+      end
+
+      modified
+    end
+  end
+end

data/lib/simple_infrastructure/inventory.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module SimpleInfrastructure
+  class Inventory
+    attr_reader :servers, :path, :defaults
+
+    def initialize(path = nil)
+      @path = path || SimpleInfrastructure.configuration.inventory_path
+      @erb_path = @path.sub(/\.yml$/, ".yml.erb")
+      @servers = []
+      @defaults = {}
+      load!
+    end
+
+    def load!
+      content = if File.exist?(@erb_path)
+        ERB.new(File.read(@erb_path)).result
+      elsif File.exist?(@path)
+        File.read(@path)
+      else
+        raise "No inventory found at #{@path} or #{@erb_path}"
+      end
+
+      data = YAML.safe_load(content, permitted_classes: [Symbol]) || {}
+      @defaults = (data["defaults"] || {}).transform_keys(&:to_sym)
+
+      @servers = []
+      (data["servers"] || {}).each do |env, server_list|
+        (server_list || []).each do |attrs|
+          merged = defaults.merge(attrs.transform_keys(&:to_sym)).merge(env: env)
+          @servers << Server.new(**merged)
+        end
+      end
+    end
+
+    def find_by_hostname(hostname)
+      servers.find { |s| s.hostname == hostname }
+    end
+
+    def find_by_env(env)
+      servers.select { |s| s.env == env.to_sym }
+    end
+  end
+end

data/lib/simple_infrastructure/railtie.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "rails/railtie"
+
+module SimpleInfrastructure
+  class Railtie < Rails::Railtie
+    initializer "simple_infrastructure.configure" do
+      SimpleInfrastructure.configure do |config|
+        config.project_root = Rails.root.to_s
+        config.logger = Rails.logger
+      end
+    end
+
+    rake_tasks do
+      load File.expand_path("../tasks/simple_infrastructure.rake", __dir__)
+    end
+
+    generators do
+      require_relative "../generators/simple_infrastructure/change_generator"
+    end
+  end
+end

data/lib/simple_infrastructure/runner.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+module SimpleInfrastructure
+  class Runner
+    REMOTE_STATE_DIR = ".infrastructure"
+
+    attr_reader :inventory, :changes, :dry_run
+
+    def initialize(dry_run: false)
+      @inventory = Inventory.new
+      @changes = Change.load_all.sort
+      @dry_run = dry_run
+    end
+
+    def run_for_env(env)
+      servers = inventory.find_by_env(env)
+      if servers.empty?
+        SimpleInfrastructure.logger.debug "No servers found for environment: #{env}"
+        return false
+      end
+
+      SimpleInfrastructure.logger.debug "Running changes for #{servers.length} server(s) in #{env}..."
+      success = true
+      servers.each do |server|
+        success &= run_for_server(server)
+      end
+      success
+    end
+
+    def run_for_hostname(hostname)
+      server = inventory.find_by_hostname(hostname)
+      unless server
+        SimpleInfrastructure.logger.debug "Server not found: #{hostname}"
+        return false
+      end
+
+      run_for_server(server)
+    end
+
+    def run_for_server(server)
+      # Show connecting message
+      SimpleInfrastructure.logger.debug "\n#{server}: connecting..."
+      $stdout.flush
+
+      # Always use real SSH to check current state
+      ssh_connection = SshConnection.new(server)
+      ssh_connection.connect
+
+      begin
+        applied = get_applied_changes(ssh_connection)
+        pending = changes.reject { |c| applied.include?(c.name) }
+                         .select { |c| c.targets?(server) }
+
+        # Clear line and show result
+        SimpleInfrastructure.logger.debug "\r\e[K"
+        if pending.empty?
+          SimpleInfrastructure.logger.debug "#{server}: up to date"
+          return true
+        end
+
+        SimpleInfrastructure.logger.debug "#{server}: #{pending.length} pending change(s)"
+
+        # For execution, use DryRunConnection in dry-run mode
+        connection = dry_run ? DryRunConnection.new(server) : ssh_connection
+
+        # Ensure state directory exists
+        ssh_connection.exec("mkdir -p ~/#{REMOTE_STATE_DIR}") unless dry_run
+
+        pending.each_with_index do |change, index|
+          SimpleInfrastructure.logger.debug "  APPLY: #{change.name}"
+          log_output = []
+
+          change.steps.each do |step|
+            output = step.execute(connection, dry_run: dry_run)
+            log_output << output if output.is_a?(String)
+          end
+
+          unless dry_run
+            # Write completion log file
+            log_content = "Change applied at: #{Time.now.iso8601}\n\n#{log_output.join("\n")}"
+            ssh_connection.write_file("~/#{REMOTE_STATE_DIR}/#{change.name}.log", log_content)
+          end
+
+          SimpleInfrastructure.logger.debug "  DONE: #{change.name}"
+          SimpleInfrastructure.logger.debug "" if index < pending.length - 1
+        end
+        true
+      rescue StandardError => e
+        SimpleInfrastructure.logger.debug "\r\e[K"
+        SimpleInfrastructure.logger.debug "#{server}: FAILED - #{e.message}"
+        SimpleInfrastructure.logger.debug e.backtrace.first(5).map { |l| "    #{l}" }.join("\n")
+        false
+      ensure
+        ssh_connection.disconnect
+      end
+    end
+
+    def check_server_status(server)
+      connection = SshConnection.new(server)
+      connection.connect
+      applied = get_applied_changes(connection)
+      connection.disconnect
+      changes.reject { |c| applied.include?(c.name) }
+             .select { |c| c.targets?(server) }
+    end
+
+    def get_applied_changes(connection)
+      # List all .log files in the state directory
+      result = connection.exec("ls ~/#{REMOTE_STATE_DIR}/*.log 2>/dev/null || true")
+      return [] if result[:stdout].strip.empty?
+
+      result[:stdout].strip.split("\n").map do |path|
+        # Extract change name from path: ~/.infrastructure/20250121000100_install_essentials.log
+        File.basename(path, ".log")
+      end
+    end
+
+    def status(verbose: false)
+      by_env = inventory.servers.group_by(&:env)
+
+      by_env.keys.sort.each_with_index do |env, env_index|
+        servers = by_env[env]
+
+        title = env.to_s.split("_").map(&:capitalize).join(" ")
+        divider = "-" * (72 - title.length - 1)
+        SimpleInfrastructure.logger.debug "#{title} #{divider}"
+
+        servers.each do |server|
+          # Show connecting message, then overwrite with result
+          SimpleInfrastructure.logger.debug "  ⋯ #{server.hostname} (connecting...)"
+          $stdout.flush
+
+          begin
+            connection = SshConnection.new(server)
+            connection.connect
+            applied = get_applied_changes(connection)
+            connection.disconnect
+
+            pending = changes.reject { |c| applied.include?(c.name) }
+                             .select { |c| c.targets?(server) }
+
+            # Clear line and show result
+            SimpleInfrastructure.logger.debug "\r\e[K"
+            if pending.empty?
+              SimpleInfrastructure.logger.debug "  \e[1;92m✔︎\e[0m #{server.hostname} (up to date)"
+            else
+              SimpleInfrastructure.logger.debug "  \e[31m✗\e[0m #{server.hostname} (#{pending.count} pending)"
+              if verbose
+                pending.each { |c| SimpleInfrastructure.logger.debug "      #{c.name}" }
+              end
+            end
+          rescue StandardError
+            SimpleInfrastructure.logger.debug "\r\e[K"
+            SimpleInfrastructure.logger.debug "  \e[33m?\e[0m #{server.hostname} (unable to connect)"
+          end
+        end
+
+        SimpleInfrastructure.logger.debug "" if env_index < by_env.keys.length - 1
+      end
+    end
+  end
+end