pangea 0.0.42 → 0.0.46

data/lib/pangea/cli/constants.rb

@@ -1,15 +1,12 @@
 module Constants
-  # useful names
-  ARTIFACT_FILE = %(artifact.tf.json)
+  ARTIFACT_FILE = %(artifact.tf.json).freeze
 
-  # cli related constants
   CACHE_DIR = File.join(
-    ENV.fetch(%(HOME), nil),
+    Dir.home,
     %(.cache),
     %(pangea)
   ).freeze
 
-  # project related constants
   PROJECT_VERSION = %i[version.rb].freeze
 
   # order of elements matters here
@@ -18,10 +15,10 @@ module Constants
   # this order. changing this can significantly
   # impact how a project is processed.
   PROJECT_SRC_DIRS = %i[
-    lib
-    pre
     resources
     post
+    lib
+    pre
   ].freeze
 
   # configuration extensions

data/lib/pangea/cli/subcommands/config.rb

@@ -101,9 +101,7 @@ class ConfigCommand < PangeaCommand
           ###################################################################
           # setup modules
           ###################################################################
-
-          module_dirs = %w[lib src test]
-          modules     = ctx[:modules]
+          modules = ctx[:modules]
 
           modules.each_key do |mod_name|
             this_mod = modules[mod_name]
@@ -187,11 +185,7 @@ class ConfigCommand < PangeaCommand
 
           bucket_name =
             ctx[:state_config][:terraform][:s3][:bucket]
-          if bucket_exist?(bucket_name)
-            nil
-          else
-            s3.create_bucket(bucket: bucket_name)
-          end
+          s3.create_bucket(bucket: bucket_name) unless bucket_exist?(bucket_name)
 
           # end s3 bucket setup
 
@@ -199,7 +193,7 @@ class ConfigCommand < PangeaCommand
           # setup directories
           ###################################################################
 
-          base_dir    = File.join(ENV.fetch(%(HOME), nil), %(.pangea))
+          base_dir    = File.join(Dir.home, %(.pangea))
           context_dir = File.join(base_dir, ctx_name)
           synth_dir   = File.join(base_dir, synth_dir)
 

data/lib/pangea/cli/subcommands/infra.rb

@@ -6,10 +6,9 @@ require %(pangea/errors/site_not_found_error)
 require %(pangea/errors/project_not_found_error)
 require %(pangea/errors/no_infra_target_error)
 require %(pangea/errors/incorrect_subcommand_error)
+require %(pangea/shell/terraform)
 require %(pangea/say/init)
 require %(pangea/modules)
-# require %(terraform-synthesizer)
-# require %(json)
 
 class InfraCommand < PangeaCommand
   include Constants
@@ -50,6 +49,14 @@ class InfraCommand < PangeaCommand
     HELP
   end
 
+  def pangea_home
+    File.join(Dir.home, %(.pangea))
+  end
+
+  def terraform_files_home
+    File.join(pangea_home, %(terraform))
+  end
+
   def cfg_synth
     @cfg_synth ||= Config.resolve_configurations
   end
@@ -57,7 +64,23 @@ class InfraCommand < PangeaCommand
   def plan(argv)
     Say.terminal %(planning!)
     parse(argv)
-    process_modules
+    namespaces = cfg_synth[:namespace].keys.map(&:to_sym)
+    namespaces.each do |namespace|
+      system(%(mkdir -p #{File.join(terraform_files_home.to_s, namespace.to_s)})) unless Dir.exist?(
+        File.join(
+          terraform_files_home.to_s, namespace.to_s
+        )
+      )
+      processed = process_modules(ns)
+      template = processed[:template]
+      ns_home = File.join(terraform_files_home, ns.to_s)
+      File.write(
+        File.join(ns_home, %(template.tf.json)),
+        JSON[template]
+      )
+      system(%(cd #{ns_home} && terraform init))
+      system(%(cd #{ns_home} && terraform plan))
+    end
   end
 
   def config
@@ -68,22 +91,26 @@ class InfraCommand < PangeaCommand
     reject_empty_configurations
   end
 
-  def process_modules
+  def process_modules(namespace)
+    template = {}
     namespaces = cfg_synth[:namespace].keys.map(&:to_sym)
     namespaces.each do |namespace_name|
-      namespace     = cfg_synth[:namespace][namespace_name]
-      context_names = namespace.keys.map(&:to_sym)
+      ns = cfg_synth[:namespace][namespace_name]
+      context_names = ns.keys.map(&:to_sym)
 
       context_names.each do |cn|
-        context = namespace[cn]
+        context = ns[cn]
         modules = context[:modules]
 
+        next unless namespace_name.to_s.eql?(namespace.to_s)
+
         modules.each_key do |mod_key|
           mod = modules[mod_key]
-          PangeaModule.process(mod)
+          template.merge!(PangeaModule.process(mod))
         end
       end
     end
+    { template: template, namespaces: cfg_synth[:namespace].keys.map(&:to_sym) }
   end
 
   def run(argv)

data/lib/pangea/cli/subcommands/main.rb

@@ -10,7 +10,6 @@ require %(pangea/version)
 
 class Command < PangeaCommand
   usage do
-    desc %(manage crud apis declaratively)
     program %(pangea)
   end
 

data/lib/pangea/cli/subcommands/state.rb

@@ -0,0 +1,30 @@
+# require %(pangea/cli/subcommands/pangea)
+# require %(pangea/cli/constants)
+# require %(pangea/cli/config)
+# require %(pangea/errors/namespace_not_found_error)
+# require %(pangea/errors/site_not_found_error)
+# require %(pangea/errors/project_not_found_error)
+# require %(pangea/errors/no_infra_target_error)
+# require %(pangea/errors/incorrect_subcommand_error)
+# require %(pangea/shell/terraform)
+# require %(pangea/say/init)
+# require %(pangea/modules)
+
+class StateCommand < PangeaCommand
+  include Constants
+  NAME = :state
+
+  usage do
+    desc %(manage infrastructure state)
+    program %(pangea)
+    command %(state)
+  end
+
+  argument :subcommand do
+    desc %(manage infrastructure state)
+  end
+
+  def run
+    nil
+  end
+end

data/lib/pangea/cli.rb

@@ -1 +1,63 @@
-require %(pangea/cli/subcommands/main)
+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('plan')
+      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/config.rb

@@ -0,0 +1,35 @@
+require 'pangea/utils'
+require 'yaml'
+
+module Pangea
+  module Config
+    class << self
+      # Public: Returns a memoized configuration Hash.
+      # The configuration is lazily loaded and deep-merged so that:
+      # - Keys in pangea.yml override keys in ~/.config/pangea/config.yml
+      # - Keys in ~/.config/pangea/config.yml override keys in /etc/pangea/config.yml
+      def config
+        @config ||= load_config
+      end
+
+      # File paths in increasing order of priority.
+      CONFIG_PATHS = [
+        '/etc/pangea/config.yml',
+        File.expand_path('~/.config/pangea/config.yml'),
+        'pangea.yml'
+      ].freeze
+
+      # Loads and deep-merges available YAML configuration files.
+      def load_config
+        merged = {}
+        CONFIG_PATHS.each do |file_path|
+          if File.exist?(file_path)
+            data = YAML.load_file(file_path)
+            merged = Pangea::Utils.deep_merge(merged, data) if data.is_a?(Hash)
+          end
+        end
+        merged
+      end
+    end
+  end
+end

data/lib/pangea/executor.rb

@@ -0,0 +1,10 @@
+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/modcache.rb

@@ -0,0 +1,79 @@
+# unfortunately, in order to call an opentofu mod/resource combination a file must be created
+# represent the resource module and then another file must represent the caller.
+# this means temporarily having a folder created for each as we move through mod/resources
+
+module Pangea
+  class ModCache
+    attr_reader :name,
+                :mod,
+                :resource,
+                :virtual,
+                :basedir,
+                :modcachedir,
+                :address
+
+    def initialize(name, mod, resource, virtual)
+      @name     = name
+      @mod      = mod
+      @resource = resource
+      @virtual  = virtual
+      @basedir = File.join(Dir.home, '.pangea')
+      @modcachedir = File.join(basedir, 'modcache')
+      @address = "#{name}/#{mod}/#{resource}/#{virtual}/module"
+      @internal_module_file_name = 'internal.tf.json'
+    end
+
+    def preflight
+      [basedir, modcachedir, File.join(modcachedir, address)].each do |d|
+        `mkdir -p #{modcachedir}` unless Dir.exist?(d)
+      end
+    end
+
+    def place_internal_module(template)
+      preflight
+      internal_module_path = File.join(
+        modcachedir,
+        @internal_module_file_name
+      )
+      File.write(internal_module_path, template)
+    end
+
+    def place_caller_template
+      internal_module_path = File.join(
+        modcachedir,
+        @internal_module_file_name
+      )
+      caller_template = {
+        provider: {
+          aws: {
+            region: 'us-east-1'
+          }
+        },
+        module: {
+          "#{name}": {
+            source: internal_module_path
+          }
+        }
+      }
+
+      internal_caller_template_path = File.join(
+        modcachedir,
+        'caller.tf.json'
+      )
+      File.write(internal_caller_template_path, JSON[caller_template])
+    end
+
+    # class << self
+    #   def register_module(mod)
+    #     @mod = mod
+    #   end
+    #
+    #   def register_name(name)
+    #     @name = name
+    #   end
+    #
+    #
+    #   def create_directories(dirs); end
+    # end
+  end
+end

data/lib/pangea/module.rb

@@ -0,0 +1,17 @@
+require 'pangea/renderer'
+require 'pangea/config'
+
+module Pangea
+  # Pangea::Module is a group of delcared render_component calls
+  class Module
+    attr_reader :name
+
+    def initialize(name)
+      @name = name
+    end
+
+    # def render(namespace, &block)
+    #   Pangea::S3Renderer.new(namespace).render_component(name, &block)
+    # end
+  end
+end

data/lib/pangea/processor.rb

@@ -0,0 +1,101 @@
+require 'terraform-synthesizer'
+require 'pangea/renderer'
+require 'pangea/config'
+require 'pangea/utils'
+require 'aws-sdk-s3'
+
+module Pangea
+  # ingests files and builds a context
+  # for rendering Pangea programming
+  module Processor
+    class << self
+      def register_action(action)
+        permitted_actions = %i[plan apply show]
+        @action = action if permitted_actions.map(&:to_s).include?(action.to_s)
+        @action = 'plan' if @action.nil?
+      end
+
+      def process(content)
+        instance_eval(content)
+      end
+
+      def synthesizer
+        @synthesizer ||= TerraformSynthesizer.new
+      end
+
+      def config
+        @config ||= Pangea::Utils.symbolize(
+          Pangea::Config.config
+        )
+      end
+
+      def namespace
+        @namespace ||= ENV.fetch('PANGEA_NAMESPACE')
+      end
+
+      def s3
+        @s3 = Aws::S3::Client.new
+      end
+
+      def bin
+        'tofu'
+      end
+
+      def namespace_config
+        sns = ''
+        config[:namespaces].each_key do |ns|
+          sns = config[:namespaces][ns] if ns.to_s.eql?(namespace.to_s)
+        end
+        @namespace_config ||= sns
+      end
+
+      def template(name, &block)
+        prefix = "#{namespace}/#{name}"
+        pangea_home = %(#{Dir.home}/.pangea/#{namespace})
+        local_cache = File.join(pangea_home, prefix)
+        `mkdir -p #{local_cache}` unless Dir.exist?(local_cache)
+        synthesizer.synthesize(&block)
+        sns = namespace_config
+        unless synthesizer.synthesis[:terraform]
+          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[synthesizer.synthesis]
+        )
+
+        system("cd #{local_cache} && #{bin} init -input=false") unless File.exist?(
+          File.join(
+            local_cache,
+            '.terraform.lock.hcl'
+          )
+        )
+
+        system("cd #{local_cache} && #{bin} apply -auto-approve") if @action.to_s.eql?('apply')
+        system("cd #{local_cache} && #{bin} plan") if @action.to_s.eql?('plan')
+        system("cd #{local_cache} && #{bin} destroy -auto-approve") if @action.to_s.eql?('destroy')
+
+        template = Pangea::Utils.symbolize(
+          JSON[File.read(
+            File.join(local_cache, 'main.tf.json')
+          )]
+        )
+        puts JSON.pretty_generate(tempalte) if @action.to_s.eql?('show')
+        { template: template }
+      end
+    end
+  end
+end