pangea-orchestrator 0.0.1 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f9b12ac7b3e065ca345bb68c81825d3e2173b94a45e0a5db94f588d24ccc93ef
-  data.tar.gz: dff24d5821332cdc536017ec1f697ecf77d0ce0c45e70851fff18a211a723825
+  metadata.gz: eea60208eafbfc9698d5d86189f203af5dfee5d9578f81d3635b6c0bb7a56801
+  data.tar.gz: da7d8aea4b030a38f3109ea794a913f64871a6d1b5a74db60d5e531422ced75c
 SHA512:
-  metadata.gz: dc01babfe66702964621d86f2c5a9a8e70252d8ddce1efc8da1968bf3ace5750f1a2c519a01235edb37168636048530fcf740916c8fd38ebe5995982b628a7e3
-  data.tar.gz: b204db31458d4a164afbc05fde9759eae555c751bbc7779df276ea2cf5a0f38cca8bf6de111f0be700637a4ed40dba8974a9703e12345581a110a9a3b907069e
+  metadata.gz: 65cd3ca6770923599209f26ab85fef33c9409491e11b01c212e530aeea9bbf14024a417aae9321c0c79483d71e82e9ff0835c2aa62fba69a081608a69f9bb5ec
+  data.tar.gz: 39ec6bcf0b1e05eb87b4b25ca35551497bbb0eb3cce44b039d27fc1a1c2f79fbde9161431e0fb380b2a8775ca09f31e7e8c2f3a640683624e8b7b25026fb34f7

data/.gitignore

@@ -1 +1,2 @@
 .direnv
+pkg

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    pangea-orchestrator (0.0.1)
+    pangea-orchestrator (0.0.4)
       abstract-synthesizer
       terraform-synthesizer
 

data/gemset.nix

@@ -139,7 +139,7 @@
       path = ./.;
       type = "path";
     };
-    version = "0.0.1";
+    version = "0.0.4";
   };
   parallel = {
     groups = ["default" "development"];

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

@@ -1,9 +1,15 @@
 # lib/pangea-orchestrator/resources/eks.rb
 require 'json'
+require 'terraform-synthesizer'
+
 module PangeaOrchestrator
   module Resources
     class EKS
       class << self
+        def synthesizer
+          @synthesizer ||= Terraform::Synthesizer.new
+        end
+
         def symbolize(hash)
           JSON[JSON[hash, symbolic_names: true]]
         end
@@ -12,8 +18,10 @@ module PangeaOrchestrator
           kwargs        = symbolize(kwargs)
           resource_name = kwargs[:resource_name]
           name          = kwargs[:name]
-          resource :aws_eks_cluster, resource_name do
-            name name
+          synthesizer.synthesize do
+            resource :aws_eks_cluster, resource_name do
+              name name
+            end
           end
         end
       end

data/lib/pangea-orchestrator/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pangea-orchestrator
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.4
 platform: ruby
 authors:
 - drzthslnt@gmail.com
@@ -168,31 +168,8 @@ files:
 - flake.nix
 - gemset.nix
 - lib/pangea-orchestrator.rb
-- lib/pangea-orchestrator/cli.rb
-- lib/pangea-orchestrator/errors/incorrect_subcommand_error.rb
-- lib/pangea-orchestrator/errors/namespace_not_found_error.rb
-- lib/pangea-orchestrator/errors/no_infra_target_error.rb
-- lib/pangea-orchestrator/errors/project_not_found_error.rb
-- lib/pangea-orchestrator/errors/site_not_found_error.rb
-- lib/pangea-orchestrator/executor.rb
-- lib/pangea-orchestrator/modules.rb
-- lib/pangea-orchestrator/renderer.rb
 - lib/pangea-orchestrator/resources.rb
 - lib/pangea-orchestrator/resources/eks.rb
-- lib/pangea-orchestrator/sandbox.rb
-- lib/pangea-orchestrator/say/init.rb
-- lib/pangea-orchestrator/shell.rb
-- lib/pangea-orchestrator/shell/README.md
-- lib/pangea-orchestrator/shell/terraform.rb
-- lib/pangea-orchestrator/stack.rb
-- lib/pangea-orchestrator/state.rb
-- lib/pangea-orchestrator/structures/README.md
-- lib/pangea-orchestrator/structures/abstract.rb
-- lib/pangea-orchestrator/structures/namespace.rb
-- lib/pangea-orchestrator/structures/project.rb
-- lib/pangea-orchestrator/structures/site.rb
-- lib/pangea-orchestrator/synthesizer/config.rb
-- lib/pangea-orchestrator/utils.rb
 - lib/pangea-orchestrator/version.rb
 - pangea-orchestrator.gemspec
 homepage: https://github.com/drzln/pangea-orchestrator

data/lib/pangea-orchestrator/cli.rb

@@ -1,73 +0,0 @@
-require 'terraform-synthesizer'
-require 'pangea/processor'
-require 'pangea/renderer'
-require 'pangea/config'
-require 'pangea/state'
-require 'pangea/utils'
-require 'thor'
-
-module TheseUtils
-  class << self
-    def cfg
-      @cfg ||= Pangea::Utils.symbolize(
-        Pangea::Config.config
-      )
-    end
-
-    def state_init
-      state = Pangea::S3State.new
-      cfg[:namespaces].each_key do |nk|
-        ns_config = cfg[:namespaces][nk]
-        case ns_config[:state][:type].to_sym
-        when :s3
-          bucket_name     = ns_config[:state][:config][:bucket]
-          region          = ns_config[:state][:config][:region]
-          lock_table_name = ns_config[:state][:config][:lock]
-
-          state.create_bucket(
-            name: bucket_name,
-            region: region
-          )
-
-          state.create_dynamodb_table_for_lock(
-            name: lock_table_name,
-            region: region
-          )
-        end
-      end
-    end
-  end
-end
-
-module Pangea
-  class Cli < Thor
-    desc 'apply FILE', 'apply a FILE of pangea code'
-    def apply(file)
-      Pangea::Processor.register_action('apply')
-      Pangea::Processor.process(File.read(file))
-    end
-
-    desc 'show FILE', 'transpile a FILE of pangea code to json'
-    def show(file)
-      Pangea::Processor.register_action('show')
-      Pangea::Processor.process(File.read(file))
-    end
-
-    desc 'plan FILE', 'plan a FILE of pangea code'
-    def plan(file)
-      Pangea::Processor.register_action('plan')
-      Pangea::Processor.process(File.read(file))
-    end
-
-    desc 'destroy FILE', 'destroy a FILE of pangea code'
-    def destroy(file)
-      Pangea::Processor.register_action('destroy')
-      Pangea::Processor.process(File.read(file))
-    end
-
-    desc 'init', 'initialize an s3 state configuation according to pangea.yml'
-    def init
-      TheseUtils.state_init
-    end
-  end
-end

data/lib/pangea-orchestrator/errors/incorrect_subcommand_error.rb

@@ -1,2 +0,0 @@
-class IncorrectSubcommandError < StandardError
-end

data/lib/pangea-orchestrator/errors/namespace_not_found_error.rb

@@ -1,2 +0,0 @@
-class NamespaceNotFoundError < StandardError
-end

data/lib/pangea-orchestrator/errors/no_infra_target_error.rb

@@ -1,2 +0,0 @@
-class NoInfraTargetError < StandardError
-end

data/lib/pangea-orchestrator/errors/project_not_found_error.rb

@@ -1,2 +0,0 @@
-class ProjectNotFoundError < StandardError
-end

data/lib/pangea-orchestrator/errors/site_not_found_error.rb

@@ -1,2 +0,0 @@
-class SiteNotFoundError < StandardError
-end

data/lib/pangea-orchestrator/executor.rb

@@ -1,10 +0,0 @@
-require 'pangea/shell'
-# an executor is anything that follows opentofu api
-
-module Pangea
-  module Executor
-    def run(command)
-      Pangea::Shell.run(command)
-    end
-  end
-end

data/lib/pangea-orchestrator/modules.rb

@@ -1,134 +0,0 @@
-###############################################################################
-# modules
-# module for handling pangea modules
-# pangea modules are execution units
-# for terraform code.
-###############################################################################
-
-require %(terraform-synthesizer)
-require %(bundler)
-
-module PangeaBase
-  BASE_DIR = File.join(
-    Dir.home,
-    %(.pangea)
-  )
-end
-
-module PangeaRbenv
-  include PangeaBase
-
-  BIN = %(rbenv).freeze
-
-  RBENV_DIR = File.join(
-    BASE_DIR,
-    %(rbenv)
-  )
-
-  VERSIONS_DIR = File.join(
-    RBENV_DIR,
-    %(versions)
-  )
-
-  class << self
-    def versions_dir
-      VERSIONS_DIR
-    end
-
-    def rbenv_installed?
-      `which rbenv`.strip != ''
-    end
-
-    def rbenv_install(version, path)
-      system %(mkdir -p #{VERSIONS_DIR}) unless Dir.exist?(VERSIONS_DIR)
-      if rbenv_installed? && !Dir.exist?(File.join(path.to_s))
-        system [BIN, %(install), version.to_s, path.to_s].join(%( ))
-      end
-    end
-  end
-end
-
-module PangeaRubyBuild
-  include PangeaBase
-  BIN = %(ruby-build).freeze
-  RUBY_BUILD_DIR = File.join(
-    BASE_DIR,
-    %(rbenv)
-  )
-  class << self
-    def ruby_build_installed?
-      `which rbenv`.strip != ''
-    end
-
-    def ruby_build(version, path)
-      system %(mkdir -p #{PangeaRbenv.versions_dir}) unless Dir.exist?(PangeaRbenv.versions_dir)
-      system [BIN, version.to_s, path.to_s].join(%( )) if ruby_build_installed? && !Dir.exist?(File.join(path.to_s))
-    end
-
-    def gem_install(gem, ruby_version, gem_version, gemset_path)
-      gem_path = File.join(gemset_path, %(lib), %(ruby), %(gems), ruby_version.to_s, %(gems), %(#{gem}-#{gem_version}))
-      unless Dir.exist?(gem_path)
-        gembin = File.join(gemset_path, %(bin), %(gem))
-        system [gembin, %(install), gem.to_s.strip, %(-v), gem_version.to_s].join(%( ))
-      end
-    end
-
-    def bundle_install(mpath, gemset_path)
-      @bundlebin = File.join(gemset_path, %(bin), %(bundle))
-      bundlehint = File.join(gemset_path, %(bundle_hint))
-      unless File.exist?(bundlehint)
-        cmd = [
-          # %(cd #{mpath} &&),
-          %(BUNDLE_GEMFILE=#{File.join(mpath, %(Gemfile))}), @bundlebin,
-          %(install)
-        ].join(%( ))
-        system cmd
-        system [%(touch), bundlehint].join(%( ))
-      end
-    end
-  end
-end
-
-module PangeaModule
-  include PangeaBase
-
-  CACHE_DIR = File.join(
-    BASE_DIR,
-    %(cache)
-  )
-
-  RUBIES_DIR = File.join(
-    BASE_DIR,
-    %(rubies)
-  )
-
-  class << self
-    def symbolize(hash)
-      JSON[JSON[hash], symbolize_names: true]
-    end
-
-    def terraform_synth
-      @terraform_synth ||= TerraformSynthesizer.new
-    end
-
-    # entrypoint for module processing
-    def process(mod)
-      mod = symbolize(mod)
-
-      name = mod.fetch(:name)
-      data = mod.fetch(:data, {})
-
-      raise ArgumentError, %(name cannot be nil) if name.nil?
-
-      # understanding that module entrypoint loading
-      # will work with #{context}-#{name}
-      context       = mod.fetch(:context, %(pangea-component))
-      require_name  = %(#{context}-#{name})
-
-      require require_name
-      render(data)
-    end
-  end
-end
-
-# end modules

data/lib/pangea-orchestrator/renderer.rb

@@ -1,241 +0,0 @@
-# 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/sandbox.rb

@@ -1,90 +0,0 @@
-###############################################################################
-# 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

@@ -1,27 +0,0 @@
-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

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

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

@@ -1,21 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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

@@ -1,11 +0,0 @@
-# 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

@@ -1,96 +0,0 @@
-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

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

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

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

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

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

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

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

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

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

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

@@ -1,38 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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