simple_infrastructure 0.1.0

data/lib/simple_infrastructure/server.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module SimpleInfrastructure
+  class Server
+    attr_reader :hostname, :env, :user, :attributes
+
+    def initialize(hostname:, env:, user: "root", **attributes)
+      @hostname = hostname
+      @env = env.to_sym
+      @user = user
+      @attributes = attributes
+    end
+
+    def matches?(target)
+      return false if target[:env] && env != target[:env].to_sym
+
+      if target[:hostname]
+        case target[:hostname]
+        when Regexp
+          return false unless hostname.match?(target[:hostname])
+        when String
+          return false unless hostname == target[:hostname]
+        end
+      end
+
+      true
+    end
+
+    def to_h
+      {
+        "hostname" => hostname
+      }.merge(attributes.transform_keys(&:to_s))
+    end
+
+    def to_s
+      "#{user}@#{hostname} (#{env})"
+    end
+  end
+end

data/lib/simple_infrastructure/ssh_connection.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require "net/ssh"
+
+module SimpleInfrastructure
+  class SshConnection
+    attr_reader :server
+
+    def initialize(server)
+      @server = server
+      @ssh = nil
+    end
+
+    def connect
+      @ssh = Net::SSH.start(
+        server.hostname,
+        server.user,
+        forward_agent: true,
+        verify_host_key: :accept_new
+      )
+      self
+    end
+
+    def disconnect
+      @ssh&.close
+      @ssh = nil
+    end
+
+    def exec(command)
+      stdout = ""
+      stderr = ""
+      exit_code = nil
+
+      @ssh.open_channel do |channel|
+        channel.exec(command) do |ch, success|
+          raise "Failed to execute command" unless success
+
+          ch.on_data { |_, data| stdout += data }
+          ch.on_extended_data { |_, _, data| stderr += data }
+          ch.on_request("exit-status") { |_, data| exit_code = data.read_long }
+        end
+      end.wait
+
+      {
+        stdout: stdout,
+        stderr: stderr,
+        exit_code: exit_code,
+        success: exit_code.zero?
+      }
+    end
+
+    def read_file(path, sudo: false)
+      cmd = "cat #{shell_escape(path)} 2>/dev/null || echo ''"
+      cmd = "sudo #{cmd}" if sudo
+      result = exec(cmd)
+      result[:stdout]
+    end
+
+    def write_file(path, content, sudo: false)
+      # Use heredoc to safely write content
+      delimiter = "INFRASTRUCTURE_EOF_#{rand(100_000)}"
+      cmd = "cat > #{shell_escape(path)} << '#{delimiter}'\n#{content}\n#{delimiter}"
+      if sudo
+        # For sudo, write to temp file then move
+        tmp = "/tmp/infrastructure_#{rand(100_000)}"
+        exec("cat > #{tmp} << '#{delimiter}'\n#{content}\n#{delimiter}")
+        exec("sudo mv #{tmp} #{shell_escape(path)}")
+      else
+        exec(cmd)
+      end
+    end
+
+    def file_exists?(path, sudo: false)
+      cmd = "test -f #{shell_escape(path)}"
+      cmd = "sudo #{cmd}" if sudo
+      result = exec(cmd)
+      result[:success]
+    end
+
+    private
+
+    def shell_escape(str)
+      # Handle ~ expansion: don't quote the ~/ prefix
+      if str.start_with?("~/")
+        "~/'#{str[2..].gsub("'", "'\\''")}'"
+      else
+        "'#{str.gsub("'", "'\\''")}'"
+      end
+    end
+  end
+end

data/lib/simple_infrastructure/toml_operations.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+module SimpleInfrastructure
+  class TomlOperations
+    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)
+      data = content.empty? ? {} : parse_toml(content)
+      modified = false
+
+      operations.each do |op, *args|
+        case op
+        when :set
+          key, value = args
+          current = deep_get(data, key)
+          if current != value
+            SimpleInfrastructure.logger.debug "    #{key}: #{current.inspect} -> #{value.inspect}"
+            deep_set(data, key, value)
+            modified = true
+          end
+        when :remove
+          key = args[0]
+          if deep_has?(data, key)
+            SimpleInfrastructure.logger.debug "    remove: #{key}"
+            deep_remove(data, key)
+            modified = true
+          end
+        end
+      end
+
+      if modified
+        new_content = dump_toml(data)
+        unless @dry_run
+          @connection.write_file(@path, new_content, sudo: @sudo)
+        end
+      else
+        SimpleInfrastructure.logger.debug "    (no changes needed)"
+      end
+
+      true
+    end
+
+    private
+
+    def parse_toml(content)
+      data = {}
+      current_section = data
+
+      content.each_line do |line|
+        line = line.strip
+        next if line.empty? || line.start_with?("#")
+
+        if line =~ /^\[([^\]]+)\]$/
+          # Section header
+          current_section = deep_ensure(data, ::Regexp.last_match(1))
+        elsif line =~ /^([^=]+)=(.*)$/
+          key = ::Regexp.last_match(1).strip
+          value = parse_toml_value(::Regexp.last_match(2).strip)
+          current_section[key] = value
+        end
+      end
+
+      data
+    end
+
+    def parse_toml_value(str)
+      case str
+      when /^"(.*)"$/, /^'(.*)'$/ then ::Regexp.last_match(1)
+      when /^true$/i then true
+      when /^false$/i then false
+      when /^-?\d+$/ then str.to_i
+      when /^-?\d+\.\d+$/ then str.to_f
+      when /^\[(.*)\]$/
+        ::Regexp.last_match(1).split(",").map { |v| parse_toml_value(v.strip) }
+      else
+        str
+      end
+    end
+
+    def dump_toml(data, prefix = nil)
+      simple_keys = []
+      table_keys = []
+
+      data.each do |key, value|
+        if value.is_a?(Hash)
+          table_keys << key
+        else
+          simple_keys << key
+        end
+      end
+
+      # Output simple key=value pairs first
+      lines = simple_keys.map do |key|
+        "#{key} = #{toml_value(data[key])}"
+      end
+
+      # Then tables
+      table_keys.each do |key|
+        full_key = prefix ? "#{prefix}.#{key}" : key
+        lines << ""
+        lines << "[#{full_key}]"
+        lines << dump_toml(data[key], full_key)
+      end
+
+      lines.join("\n")
+    end
+
+    def toml_value(value)
+      case value
+      when String then "\"#{value}\""
+      when true, false, Integer, Float then value.to_s
+      when Array then "[#{value.map { |v| toml_value(v) }.join(', ')}]"
+      else value.to_s.inspect
+      end
+    end
+
+    def deep_get(hash, key_path)
+      keys = key_path.split(".")
+      keys.reduce(hash) { |h, k| h.is_a?(Hash) ? h[k] : nil }
+    end
+
+    def deep_set(hash, key_path, value)
+      keys = key_path.split(".")
+      last_key = keys.pop
+      target = keys.reduce(hash) { |h, k| h[k] ||= {} }
+      target[last_key] = value
+    end
+
+    def deep_has?(hash, key_path)
+      keys = key_path.split(".")
+      last_key = keys.pop
+      target = keys.reduce(hash) { |h, k| h.is_a?(Hash) ? h[k] : nil }
+      target.is_a?(Hash) && target.key?(last_key)
+    end
+
+    def deep_remove(hash, key_path)
+      keys = key_path.split(".")
+      last_key = keys.pop
+      target = keys.reduce(hash) { |h, k| h.is_a?(Hash) ? h[k] : nil }
+      target.delete(last_key) if target.is_a?(Hash)
+    end
+
+    def deep_ensure(hash, key_path)
+      keys = key_path.split(".")
+      keys.reduce(hash) { |h, k| h[k] ||= {} }
+    end
+  end
+end

data/lib/simple_infrastructure/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module SimpleInfrastructure
+  VERSION = "0.1.0"
+end

data/lib/simple_infrastructure/yaml_operations.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module SimpleInfrastructure
+  class YamlOperations
+    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)
+      data = content.empty? ? {} : YAML.safe_load(content) || {}
+      modified = false
+
+      operations.each do |op, *args|
+        case op
+        when :set
+          key, value = args
+          current = deep_get(data, key)
+          if current != value
+            SimpleInfrastructure.logger.debug "    #{key}: #{current.inspect} -> #{value.inspect}"
+            deep_set(data, key, value)
+            modified = true
+          end
+        when :remove
+          key = args[0]
+          if deep_has?(data, key)
+            SimpleInfrastructure.logger.debug "    remove: #{key}"
+            deep_remove(data, key)
+            modified = true
+          end
+        end
+      end
+
+      if modified
+        new_content = YAML.dump(data)
+        unless @dry_run
+          @connection.write_file(@path, new_content, sudo: @sudo)
+        end
+      else
+        SimpleInfrastructure.logger.debug "    (no changes needed)"
+      end
+
+      true
+    end
+
+    private
+
+    def deep_get(hash, key_path)
+      keys = key_path.split(".")
+      keys.reduce(hash) { |h, k| h.is_a?(Hash) ? h[k] : nil }
+    end
+
+    def deep_set(hash, key_path, value)
+      keys = key_path.split(".")
+      last_key = keys.pop
+      target = keys.reduce(hash) { |h, k| h[k] ||= {} }
+      target[last_key] = value
+    end
+
+    def deep_has?(hash, key_path)
+      keys = key_path.split(".")
+      last_key = keys.pop
+      target = keys.reduce(hash) { |h, k| h.is_a?(Hash) ? h[k] : nil }
+      target.is_a?(Hash) && target.key?(last_key)
+    end
+
+    def deep_remove(hash, key_path)
+      keys = key_path.split(".")
+      last_key = keys.pop
+      target = keys.reduce(hash) { |h, k| h.is_a?(Hash) ? h[k] : nil }
+      target.delete(last_key) if target.is_a?(Hash)
+    end
+  end
+end

data/lib/simple_infrastructure.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "erb"
+require "net/ssh"
+require "fileutils"
+
+require_relative "simple_infrastructure/version"
+require_relative "simple_infrastructure/configuration"
+
+module SimpleInfrastructure
+  autoload :Change, "simple_infrastructure/change"
+  autoload :RunStep, "simple_infrastructure/change"
+  autoload :FileStep, "simple_infrastructure/change"
+  autoload :OnChangeContext, "simple_infrastructure/change"
+  autoload :YamlStep, "simple_infrastructure/change"
+  autoload :TomlStep, "simple_infrastructure/change"
+  autoload :UploadStep, "simple_infrastructure/change"
+  autoload :Server, "simple_infrastructure/server"
+  autoload :Inventory, "simple_infrastructure/inventory"
+  autoload :Runner, "simple_infrastructure/runner"
+  autoload :Dsl, "simple_infrastructure/dsl"
+  autoload :FileOperations, "simple_infrastructure/file_operations"
+  autoload :YamlOperations, "simple_infrastructure/yaml_operations"
+  autoload :TomlOperations, "simple_infrastructure/toml_operations"
+  autoload :SshConnection, "simple_infrastructure/ssh_connection"
+  autoload :DryRunConnection, "simple_infrastructure/dry_run_connection"
+  autoload :Cli, "simple_infrastructure/cli"
+
+  class << self
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield(configuration)
+    end
+
+    def logger
+      configuration.logger
+    end
+
+    def root
+      configuration.config_dir
+    end
+
+    def project_root
+      configuration.project_root
+    end
+
+    def reset_configuration!
+      @configuration = Configuration.new
+    end
+  end
+end
+
+require "simple_infrastructure/railtie" if defined?(Rails::Railtie)

data/lib/tasks/simple_infrastructure.rake

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+namespace :infrastructure do
+  desc "Show status of all servers"
+  task status: :environment do
+    require "simple_infrastructure"
+    SimpleInfrastructure::Runner.new.status
+  end
+
+  desc "Run pending changes on environment (e.g., rake infrastructure:run[production])"
+  task :run, [:target] => :environment do |_t, args|
+    require "simple_infrastructure"
+    target = args[:target] || ENV["TARGET"]
+    abort "Usage: rake infrastructure:run[production] or TARGET=production rake infrastructure:run" unless target
+
+    runner = SimpleInfrastructure::Runner.new
+    success = if target.include?(".")
+      runner.run_for_hostname(target)
+    else
+      runner.run_for_env(target)
+    end
+    exit(1) unless success
+  end
+
+  desc "Dry run pending changes (e.g., rake infrastructure:dry_run[production])"
+  task :dry_run, [:target] => :environment do |_t, args|
+    require "simple_infrastructure"
+    target = args[:target] || ENV["TARGET"]
+    abort "Usage: rake infrastructure:dry_run[production]" unless target
+
+    puts "=== DRY RUN MODE ===\n\n"
+    runner = SimpleInfrastructure::Runner.new(dry_run: true)
+    if target.include?(".")
+      runner.run_for_hostname(target)
+    else
+      runner.run_for_env(target)
+    end
+  end
+
+  desc "Generate a new change (e.g., rake infrastructure:generate[setup_redis])"
+  task :generate, [:name] => :environment do |_t, args|
+    require "simple_infrastructure"
+    name = args[:name]
+    abort "Usage: rake infrastructure:generate[change_name]" unless name
+
+    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
+end

metadata

@@ -0,0 +1,96 @@
+--- !ruby/object:Gem::Specification
+name: simple_infrastructure
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- FounderCatalyst
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: logger
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: net-ssh
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.0'
+description: Simple Infrastructure provides a change-based approach to server configuration,
+  similar to how Rails database migrations work. Each change is tracked as a versioned
+  file, ensuring idempotency, auditability, and consistency across servers.
+email:
+- dev@foundercatalyst.com
+executables:
+- simple_infrastructure
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- bin/simple_infrastructure
+- lib/generators/simple_infrastructure/change_generator.rb
+- lib/generators/simple_infrastructure/templates/change.rb.tt
+- lib/simple_infrastructure.rb
+- lib/simple_infrastructure/change.rb
+- lib/simple_infrastructure/cli.rb
+- lib/simple_infrastructure/configuration.rb
+- lib/simple_infrastructure/dry_run_connection.rb
+- lib/simple_infrastructure/dsl.rb
+- lib/simple_infrastructure/file_operations.rb
+- lib/simple_infrastructure/inventory.rb
+- lib/simple_infrastructure/railtie.rb
+- lib/simple_infrastructure/runner.rb
+- lib/simple_infrastructure/server.rb
+- lib/simple_infrastructure/ssh_connection.rb
+- lib/simple_infrastructure/toml_operations.rb
+- lib/simple_infrastructure/version.rb
+- lib/simple_infrastructure/yaml_operations.rb
+- lib/tasks/simple_infrastructure.rake
+homepage: https://github.com/foundercatalyst/simple_infrastructure
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/foundercatalyst/simple_infrastructure
+  source_code_uri: https://github.com/foundercatalyst/simple_infrastructure
+  changelog_uri: https://github.com/foundercatalyst/simple_infrastructure/blob/main/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.3
+specification_version: 4
+summary: A migration-like DSL for server provisioning via SSH
+test_files: []