pangea-orchestrator 0.0.1

data/lib/pangea-orchestrator/renderer.rb

@@ -0,0 +1,241 @@
+# a renderer takes an artifact.json and implements
+# it against a rest api, then potentially runs
+# packaged checks and verifications.
+# it also exports values into state for the
+# child renderer to pick up on
+
+require %(terraform-synthesizer)
+require %(pangea/modcache)
+require %(pangea/config)
+require %(pangea/utils)
+require %(aws-sdk-s3)
+require %(digest)
+require %(json)
+
+module Pangea
+  class DirectoryRenderer
+    BIN = %(tofu).freeze
+
+    def home_dir
+      %(#{Dir.home}/.pangea)
+    end
+
+    def infra_dir
+      %(#{home_dir}/infra)
+    end
+
+    def init_dir
+      %(#{infra_dir}/init)
+    end
+
+    def artifact_json
+      File.join(init_dir, %(artifact.tf.json))
+    end
+
+    def pretty(content)
+      JSON.pretty_generate(content)
+    end
+
+    def create_prepped_state_directory(dir, synthesis)
+      system %(mkdir -p #{dir}) unless Dir.exist?(dir)
+      File.write(File.join(dir, %(artifact.tf.json)), JSON[synthesis])
+      system %(cd #{dir} && #{BIN} init -json) unless Dir.exist?(File.join(dir, %(.terraform)))
+      true
+    end
+
+    def resource(dir)
+      JSON[File.read(File.join(dir, %(artifact.tf.json)))]
+    end
+
+    def state(dir)
+      pretty(JSON[File.read(File.join(dir, %(terraform.tfstate)))])
+    end
+
+    def plan(dir)
+      pretty(JSON[File.read(File.join(dir, %(plan.json)))])
+    end
+
+    # component is a single resource wrapped in state
+    # with available attributes
+    def render_component(&block)
+      synthesizer.synthesize(&block)
+      resource_type = synthesizer.synthesis[:resource].keys[0]
+      resource_name = synthesizer.synthesis[:resource][synthesizer.synthesis[:resource].keys[0]].keys[0]
+      dir = File.join(init_dir, resource_type.to_s, resource_name.to_s)
+      create_prepped_state_directory(dir, synthesizer.synthesis)
+      system %(cd #{dir} && #{BIN} show -json tfplan > plan.json)
+      system %(cd #{dir} && #{BIN} apply -auto-approve)
+
+      synthesizer.clear_synthesis!
+
+      {
+        resource: resource(dir),
+        state: state(dir),
+        plan: plan(dir)
+      }
+    end
+  end
+
+  class S3Renderer
+    class << self
+      def synthesizer
+        @synthesizer ||= TerraformSynthesizer.new
+      end
+    end
+
+    # BIN = %(tofu).freeze
+
+    # attr_reader :namespace
+
+    # def initialize
+    #   raise ArgumentError, 'provide PANGEA_NAMESPACE ENVVAR' if ENV.fetch('PANGEA_NAMESPACE').nil?
+    #
+    #   @namespace = ENV.fetch('PANGEA_NAMESPACE', nil)
+    # end
+
+    # def config
+    #   @config ||= Pangea::Utils.symbolize(
+    #     Pangea::Config.config
+    #   )
+    # end
+
+    # def s3
+    #   @s3 = Aws::S3::Client.new
+    # end
+
+    # def verify_state(state)
+    #   raise Argumenterror, 'must have a bucket' unless state[:config][:bucket]
+    #   raise Argumenterror, 'must have a region' unless state[:config][:region]
+    #   raise Argumenterror, 'must have a lock' unless state[:config][:lock]
+    # end
+
+    # def pangea_home
+    #   %(#{Dir.home}/.pangea/#{namespace})
+    # end
+
+    # def bin
+    #   %(tofu)
+    # end
+
+    # def selected_namespace_configuration
+    #   sns = ''
+    #   config[:namespaces].each_key do |ns|
+    #     sns = config[:namespaces][ns] if ns.to_s.eql?(namespace.to_s)
+    #   end
+    #   @selected_namespace_configuration ||= sns
+    # end
+
+    # render things in a resource context
+    # without using terraform modules
+    # def state(name, &block)
+    #   if block.nil?
+    #     File.write(File.join(local_cache, 'main.tf.json'), JSON[{}])
+    #     system("cd #{local_cache} && #{bin} init -input=false")
+    #     system("cd #{local_cache} && #{bin} plan")
+    #     system("cd #{local_cache} && #{bin} apply -auto-approve")
+    #     return {}
+    #   end
+    #   S3Renderer.synthesizer.synthesize(&block)
+    #   synth = Pangea::Utils.symbolize(S3Renderer.synthesizer.synthesis)
+    #   prefix = "#{name}/pangea"
+    #   local_cache = File.join(pangea_home, prefix)
+    #   `mkdir -p #{local_cache}` unless Dir.exist?(local_cache)
+    #   sns = selected_namespace_configuration
+    #   verify_state(sns[:state])
+    #
+    #   # apply state configuration
+    #   unless synth[:terraform]
+    #     S3Renderer.synthesizer.synthesize do
+    #       terraform do
+    #         backend(
+    #           s3: {
+    #             key: prefix,
+    #             dynamodb_table: sns[:state][:config][:lock].to_s,
+    #             bucket: sns[:state][:config][:bucket].to_s,
+    #             region: sns[:state][:config][:region].to_s,
+    #             encrypt: true
+    #           }
+    #         )
+    #       end
+    #     end
+    #   end
+    #
+    #   File.write(File.join(local_cache, 'main.tf.json'), JSON[S3Renderer.synthesizer.synthesis])
+    #   template = Pangea::Utils.symbolize(JSON[File.read(File.join(local_cache, 'main.tf.json'))])
+    #   system("cd #{local_cache} && #{bin} init -input=false")
+    #   system("cd #{local_cache} && #{bin} plan")
+    #   system("cd #{local_cache} && #{bin} apply -auto-approve")
+    #   # puts s3.list_objects_v2(bucket: sns[:state][:config][:bucket], prefix: prefix).contents.map(&:key)
+    #   { template: template }
+    # end
+
+    # def state_keys
+    #   sns = selected_namespace_configuration
+    # end
+
+    # def state; end
+
+    # def render_component(template)
+    #   mod = 'stump'
+    #   sns = ''
+    #   config[:namespaces].each_key do |ns|
+    #     sns = config[:namespaces][ns] if ns.to_s.eql?(namespace.to_s)
+    #   end
+    #
+    #   unless sns[:state][:type].to_s.eql?('s3')
+    #     raise ArgumentError,
+    #           'state type must be s3 '
+    #   end
+    #
+    #   if sns.nil? || sns.empty?
+    #     raise ArgumentError,
+    #           "namespace #{namespace} not found in #{Pangea::Utils.pretty(config)}"
+    #   end
+    #
+    #   synthesizer.synthesize(template)
+    #   syn = Pangea::Utils.symbolize(synthesizer.synthesis)
+    #   raise ArgumentError, 'must provide at least one resource' if syn[:resource].nil?
+    #
+    #   resource_name = syn[:resource].keys[0]
+    #   virtual_name  = syn[:resource][syn[:resource].keys[0]].keys[0]
+    #
+    #   synthesizer.synthesize do
+    #     provider do
+    #       aws(region: sns[:state][:config][:region].to_s)
+    #     end
+    #     variable do
+    #       name(type: 'string', description: 'the module name')
+    #     end
+    #   end
+    #
+    #   synthesizer.synthesize do
+    #     terraform do
+    #       backend(
+    #         s3: {
+    #           key: "#{sns[:name]}/#{mod}/#{resource_name}/#{virtual_name}/module",
+    #           dynamodb_table: sns[:state][:config][:lock].to_s,
+    #           bucket: sns[:state][:config][:bucket].to_s,
+    #           region: sns[:state][:config][:region].to_s,
+    #           encrypt: true
+    #         }
+    #       )
+    #     end
+    #   end
+    #
+    #   # modcache_address = "#{sns[:name]}/#{mod}/#{resource_name}/#{virtual_name}/module"
+    #
+    #   # create the modcache directory
+    #   modcache = Pangea::ModCache.new(
+    #     sns[:name],
+    #     mod,
+    #     resource_name,
+    #     virtual_name
+    #   )
+    #   # place the internal module
+    #   modcache.place_internal_module(syn)
+    #   modcache.place_caller_template
+    #
+    #   Pangea::Utils.symbolize(synthesizer.synthesis)
+    # end
+  end
+end

data/lib/pangea-orchestrator/resources/eks.rb

@@ -0,0 +1,22 @@
+# lib/pangea-orchestrator/resources/eks.rb
+require 'json'
+module PangeaOrchestrator
+  module Resources
+    class EKS
+      class << self
+        def symbolize(hash)
+          JSON[JSON[hash, symbolic_names: true]]
+        end
+
+        def cluster(*_args, **kwargs)
+          kwargs        = symbolize(kwargs)
+          resource_name = kwargs[:resource_name]
+          name          = kwargs[:name]
+          resource :aws_eks_cluster, resource_name do
+            name name
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pangea-orchestrator/resources.rb

@@ -0,0 +1,8 @@
+# lib/pangea-orchestrator/resources.rb
+module PangeaOrchestrator
+  module Resources
+    autoload :EKS, File.join(__dir__, 'resources', 'eks')
+    # autoload :NOMAD, File.join(__dir__, 'resources', 'nomad')
+    # autoload :NIX, File.join(__dir__, 'resources', 'nix')
+  end
+end

data/lib/pangea-orchestrator/sandbox.rb

@@ -0,0 +1,90 @@
+###############################################################################
+# sandbox
+#
+# modules need an execution space which I'm naming sandboxes
+# sandboxes will contain the ruby interpreter, associated packages
+# and pangea DSL code for the execution of a single module
+###############################################################################
+
+class SandboxRuby
+  attr_reader(*%i[base_dir name gemset version])
+
+  def initialize(base_dir:, name:, gemset:, version:)
+    @base_dir = base_dir
+    @version  = version
+    @name     = name
+    @gemset   = gemset
+  end
+end
+
+class SandBox
+  attr_reader(*%i[base_dir name rubies])
+
+  def initialize(
+    name:,
+    base_dir: %(~/.pangea/sandbox),
+    rubies: []
+  )
+    @base_dir = base_dir
+    @name     = name
+    @rubies   = rubies
+
+    @rubies_dir = File.join(@base_dir, @name, %(rubies))
+
+    @ruby_build_cmd = %(ruby-build)
+  end
+
+  def prepare_sandbox
+    ensure_base_dir_exists
+    ensure_rubies_directories_exist
+    check_ruby_build_installed
+    ensure_rubies_installed
+  end
+
+  def clean_sandbox
+    system %(rm -rf #{base_dir})
+  end
+
+  private
+
+  def ensure_base_dir_exists
+    system %(mkdir -p #{base_dir}) unless Dir.exist?(base_dir)
+  end
+
+  def ensure_rubies_directories_exist
+    rubies.each do |ruby|
+      ruby_dir = File.join(@rubies_dir, ruby.version, ruby.gemset, ruby.name)
+      system %(mkdir -p #{ruby_dir}) unless Dir.exist?(ruby_dir)
+    end
+  end
+
+  def command_exists_on_path?(cmd)
+    system("which #{cmd} > /dev/null 2>&1")
+  end
+
+  def ruby_build_installed?
+    command_exists_on_path?(@ruby_build_cmd)
+  end
+
+  def ensure_rubies_installed
+    rubies.each do |ruby|
+      ruby_dir = File.join(@rubies_dir, ruby.version, ruby.gemset, ruby.name)
+      system %(#{@ruby_build_cmd} #{ruby.version} #{ruby_dir}) unless File.exist?(
+        File.join(
+          ruby_dir,
+          %(.installed_by_pangea)
+        )
+      )
+      system %(touch #{File.join(ruby_dir, %(.installed_by_pangea))}) unless File.exist?(
+        File.join(
+          ruby_dir,
+          %(.installed_by_pangea)
+        )
+      )
+    end
+  end
+
+  def check_ruby_build_installed
+    raise %(ruby-build not installed) unless ruby_build_installed?
+  end
+end

data/lib/pangea-orchestrator/say/init.rb

@@ -0,0 +1,27 @@
+require %(tty-color)
+require %(tty-box)
+
+module Say
+  class << self
+    def terminal(msg)
+      spec = {
+        width: 80,
+        style: {
+          fg: :yellow,
+          bg: :blue,
+          border: { fg: :green, bg: :black }
+        },
+        align: :right,
+        border: :thick
+        # padding: 0,
+        # height: 1
+      }
+
+      box = TTY::Box.frame(**spec)
+
+      puts box + "\n"
+      puts msg.strip
+      puts "\n" + box
+    end
+  end
+end

data/lib/pangea-orchestrator/shell/README.md

@@ -0,0 +1 @@
+# localize calling out to the shell

data/lib/pangea-orchestrator/shell/terraform.rb

@@ -0,0 +1,21 @@
+module Shell
+  module Terraform
+    BIN = ENV[%(TERRAFORM_BIN)] || %(terraform).freeze
+
+    class << self
+      def run(terraform_cmd)
+        cmd = []
+        # cmd << %(cd)
+        # cmd << Dir.pwd
+        # cmd << %(&&)
+        cmd << BIN
+        cmd << terraform_cmd
+        system cmd.join(%( ))
+      end
+
+      def plan
+        run(%(plan))
+      end
+    end
+  end
+end

data/lib/pangea-orchestrator/shell.rb

@@ -0,0 +1,27 @@
+require 'open3'
+module Pangea
+  module Shell
+    class << self
+      def run(command)
+        Open3.popen3(command) do |_stdin, stdout, stderr, wait_thr|
+          # Process standard output
+          stdout.each_line do |line|
+            parsed = JSON.parse(line.strip)
+            puts JSON.pretty_generate(parsed)
+            puts "\n---\n" # Separator between JSON objects
+          rescue JSON::ParserError
+            warn "⚠️  Invalid JSON received: #{line.inspect}"
+          end
+
+          # Handle standard error
+          unless (err = stderr.read).empty?
+            warn "\n❌ Command errors:\n#{err}"
+          end
+
+          exit_status = wait_thr.value
+          warn "\n🔥 Command failed with status #{exit_status.exitstatus}" unless exit_status.success?
+        end
+      end
+    end
+  end
+end

data/lib/pangea-orchestrator/stack.rb

@@ -0,0 +1,11 @@
+# stack is the most top level executable element
+
+module Pangea
+  class Stack
+    attr_reader :name
+
+    def initialize(name)
+      @name = name
+    end
+  end
+end

data/lib/pangea-orchestrator/state.rb

@@ -0,0 +1,96 @@
+require 'aws-sdk-s3'
+require 'aws-sdk-dynamodb'
+
+module Pangea
+  # Base state management class
+  class State
+    def initialize
+      # Initialize common state if needed.
+    end
+  end
+
+  # Manage local state
+  class LocalState < Pangea::State; end
+
+  # Manage S3 state
+  class S3State < Pangea::State
+    # Creates a DynamoDB table to be used for state locking.
+    # Optional parameters allow you to customize the table name, AWS region, and whether to check for existing table.
+    def create_dynamodb_table_for_lock(name:, region:, check: true)
+      dynamodb = Aws::DynamoDB::Client.new(region: region)
+
+      if check
+        begin
+          # Check if the table already exists
+          dynamodb.describe_table(table_name: name)
+          puts "DynamoDB table '#{name}' already exists, skipping creation."
+          return
+        rescue Aws::DynamoDB::Errors::ResourceNotFoundException
+          # Table does not exist; proceed with creation.
+        rescue Aws::DynamoDB::Errors::ServiceError => e
+          puts "Failed to check DynamoDB table existence: #{e.message}"
+          return
+        end
+      end
+
+      begin
+        dynamodb.create_table(
+          {
+            table_name: name,
+            attribute_definitions: [
+              {
+                attribute_name: 'LockID',
+                attribute_type: 'S'
+              }
+            ],
+            key_schema: [
+              {
+                attribute_name: 'LockID',
+                key_type: 'HASH'
+              }
+            ],
+            provisioned_throughput: {
+              read_capacity_units: 1,
+              write_capacity_units: 1
+            }
+          }
+        )
+        puts "DynamoDB table '#{name}' created successfully!"
+      rescue Aws::DynamoDB::Errors::ResourceInUseException
+        puts "DynamoDB table '#{name}' already exists."
+      rescue Aws::DynamoDB::Errors::ServiceError => e
+        puts "Failed to create DynamoDB table: #{e.message}"
+      end
+    end
+
+    # Creates an S3 bucket for state storage.
+    # If `check` is true, the method first checks if the bucket exists.
+    def create_bucket(name:, region:, check: true)
+      s3 = Aws::S3::Client.new(region: region)
+
+      if check
+        begin
+          # Attempt to check if the bucket exists
+          s3.head_bucket(bucket: name)
+          # Bucket exists; nothing to do.
+          return
+        rescue Aws::S3::Errors::NotFound, Aws::S3::Errors::NoSuchBucket
+          # Bucket does not exist; proceed with creation.
+        rescue Aws::S3::Errors::Forbidden => e
+          # The bucket exists but is inaccessible (perhaps owned by someone else).
+          puts "Bucket '#{name}' exists but is not accessible: #{e.message}"
+          return
+        end
+      end
+
+      begin
+        s3.create_bucket(bucket: name)
+        puts "Bucket '#{name}' created successfully!"
+      rescue Aws::S3::Errors::BucketAlreadyOwnedByYou
+        puts "Bucket '#{name}' already exists and is owned by you."
+      rescue Aws::S3::Errors::ServiceError => e
+        puts "Failed to create bucket: #{e.message}"
+      end
+    end
+  end
+end

data/lib/pangea-orchestrator/structures/README.md

@@ -0,0 +1,3 @@
+# structures
+
+The principle structures driving the pangea cli

data/lib/pangea-orchestrator/structures/abstract.rb

@@ -0,0 +1,2 @@
+# class AbstractPangeaStructure
+# end

data/lib/pangea-orchestrator/structures/namespace.rb

@@ -0,0 +1,4 @@
+require %(pangea/structures/abstract)
+
+class Namespace < AbstractPangeaStructure
+end

data/lib/pangea-orchestrator/structures/project.rb

@@ -0,0 +1,4 @@
+require %(pangea/structures/abstract)
+
+class Project < AbstractPangeaStructure
+end

data/lib/pangea-orchestrator/structures/site.rb

@@ -0,0 +1,4 @@
+require %(pangea/structures/abstract)
+
+class Site < AbstractPangeaStructure
+end

data/lib/pangea-orchestrator/synthesizer/config.rb

@@ -0,0 +1,38 @@
+require %(pangea/cli/constants)
+require %(abstract-synthesizer)
+require %(toml-rb)
+require %(json)
+require %(yaml)
+
+###############################################################################
+# read files merge config data and provide a single configuation structure
+###############################################################################
+
+class ConfigSynthesizer < AbstractSynthesizer
+  include Constants
+
+  def synthesize(content, ext)
+    case ext.to_s
+    when %(yaml), %(yml)
+      translation[:template] = YAML.safe_load(content)
+    when %(toml)
+      translation[:template] = TomlRB.parse(content)
+    when %(json)
+      translation[:template] = JSON.parse(content)
+    when %(rb)
+      if block_given?
+        yield
+      else
+        instance_eval(content)
+      end
+    end
+  end
+
+  def method_missing(method_name, ...)
+    abstract_method_missing(
+      method_name,
+      %i[namespace],
+      ...
+    )
+  end
+end

data/lib/pangea-orchestrator/utils.rb

@@ -0,0 +1,32 @@
+module Pangea
+  module Utils
+    class << self
+      def component(kwargs)
+        resource(kwargs[:type], kwargs[:name]) do
+          kwargs[:attrs].each_key do |k|
+            send(k, kwargs[:attrs][k])
+          end
+        end
+      end
+
+      def pretty(hash)
+        JSON.pretty_generate(hash)
+      end
+
+      def symbolize(hash)
+        JSON[JSON[hash], symbolize_names: true]
+      end
+
+      # Recursively deep merges two hashes.
+      def deep_merge(hash1, hash2)
+        hash1.merge(hash2) do |_, old_val, new_val|
+          if old_val.is_a?(Hash) && new_val.is_a?(Hash)
+            deep_merge(old_val, new_val)
+          else
+            new_val
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pangea-orchestrator/version.rb

@@ -0,0 +1,3 @@
+module PangeaOrchestrator
+  VERSION = %(0.0.1).freeze
+end

data/lib/pangea-orchestrator.rb

@@ -0,0 +1,5 @@
+# lib/pangea-orchestrator.rb
+
+module PangeaOrchestrator
+  autoload :Resources, File.join(__dir__, 'pangea-orchestrator', 'resources')
+end