pangea 0.0.42 → 0.0.48

data/lib/pangea/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/shell/terraform.rb

@@ -5,9 +5,9 @@ module Shell
     class << self
       def run(terraform_cmd)
         cmd = []
-        cmd << %(cd)
-        cmd << Dir.pwd
-        cmd << %(&&)
+        # cmd << %(cd)
+        # cmd << Dir.pwd
+        # cmd << %(&&)
         cmd << BIN
         cmd << terraform_cmd
         system cmd.join(%( ))

data/lib/pangea/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/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/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/structures/abstract.rb

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

data/lib/pangea/synthesizer/config.rb

@@ -28,12 +28,11 @@ class ConfigSynthesizer < AbstractSynthesizer
     end
   end
 
-  def method_missing(method_name, *args, &block)
+  def method_missing(method_name, ...)
     abstract_method_missing(
       method_name,
       %i[namespace],
-      *args,
-      &block
+      ...
     )
   end
 end

data/lib/pangea/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/version.rb

@@ -1,3 +1,3 @@
 module Pangea
-  VERSION = %(0.0.42).freeze
+  VERSION = %(0.0.48).freeze
 end

data/lib/pangea.rb

@@ -1,11 +1,23 @@
-###############################################################################
-# non-cli top level commands
-###############################################################################
+require 'pangea/config'
+require 'pangea/state'
+require 'pangea/utils'
+require 'pangea/cli'
+require 'json'
 
 module Pangea
-  class << self
-    def ping
-      %(pong)
+  autoload :Module, File.join(__dir__, 'pangea', 'module')
+
+  module App
+    class << self
+      def cfg
+        @cfg ||= Pangea::Utils.symbolize(
+          Pangea::Config.config
+        )
+      end
+
+      def run
+        Pangea::Cli.start(ARGV)
+      end
     end
   end
 end

data/pangea.gemspec

@@ -2,7 +2,7 @@
 
 lib = File.expand_path(%(lib), __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require_relative %(./lib/pangea/version)
+require_relative %(lib/pangea/version)
 
 Gem::Specification.new do |spec|
   spec.name                  = %(pangea)
@@ -15,39 +15,42 @@ Gem::Specification.new do |spec|
   spec.license               = %(MIT)
   spec.require_paths         = [%(lib)]
   spec.executables << %(pangea)
-  spec.required_ruby_version = %(>= #{`cat .ruby-version`})
+  spec.required_ruby_version = %(>=3.3.0)
 
   spec.files = `git ls-files -z`.split("\x0").reject do |f|
     f.match(%r{^(test|spec|features)/})
   end
 
-  %i[
-    rubocop-rspec
-    rubocop-rake
-    solargraph
-    keycutter
-    rubocop
-    rspec
+  %w[
     rake
-    yard
-  ].each do |gem|
-    spec.add_development_dependency(gem)
+    rspec
+    debug
+    rubocop
+    ruby-lsp
+    rubocop-rake
+    rubocop-rspec
+    debug_inspector
+  ].each do |dep|
+    spec.add_development_dependency dep
   end
 
-  %i[
-    terraform-synthesizer
-    abstract-synthesizer
-    aws-sdk-dynamodb
-    tty-progressbar
-    aws-sdk-s3
-    tty-option
-    tty-table
-    tty-color
-    tty-box
+  %w[
+    thor
+    rexml
+    bundler
     toml-rb
-  ].each do |gem|
-    spec.add_runtime_dependency(gem)
+    tty-box
+    tty-color
+    tty-table
+    tty-option
+    aws-sdk-s3
+    bigdecimal
+    tty-progressbar
+    aws-sdk-dynamodb
+    abstract-synthesizer
+    terraform-synthesizer
+  ].each do |dep|
+    spec.add_dependency dep
   end
-
-  spec.metadata[%(rubygems_mfa_required)] = %(true)
+  spec.metadata['rubygems_mfa_required'] = 'true'
 end