pangea 0.0.45 → 0.0.46

data/lib/pangea/cli/config.rb

@@ -0,0 +1,99 @@
+require %(pangea/synthesizer/config)
+require %(pangea/cli/constants)
+
+module Config
+  class << self
+    include Constants
+
+    def synthesizer
+      @synthesizer ||= ConfigSynthesizer.new
+    end
+
+    def xdg_config_home
+      ENV.fetch(
+        %(XDG_CONFIG_HOME),
+        %(#{Dir.home}/.config)
+      )
+    end
+
+    # return array of paths that can store a configuration
+    def default_paths
+      paths = {}
+
+      # configuration files to look for
+      EXTENSIONS.each do |ext|
+        paths[ext] = [] unless paths[ext]
+
+        ###############################
+        # system level configuration
+        ###############################
+
+        paths[ext] << File.join(%(/etc), %(pangea), %(pangea.#{ext}))
+        paths[ext].concat(
+          Dir.glob(
+            File.join(%(/etc/), %(pangea), %(conf.d), %(*.#{ext}))
+          )
+        )
+
+        # end system level configuration
+
+        ###############################
+        # home configuration
+        ###############################
+
+        paths[ext] << File.join(xdg_config_home, %(pangea), %(pangea.#{ext}))
+        paths[ext].concat(
+          Dir.glob(
+            File.join(xdg_config_home, %(pangea), %(conf.d), %(*.#{ext}))
+          )
+        )
+
+        # end home configuration
+
+        ###############################
+        # local configuration
+        ###############################
+
+        paths[ext] << %(pangea.#{ext})
+        paths[ext] << Dir.glob(
+          File.join(
+            %(pangea),
+            %(conf.d),
+            %(*.#{ext})
+          )
+        )
+
+        # end local configuration
+      end
+
+      # only return existing files
+      res = []
+      EXTENSIONS.each do |ext|
+        files = paths[ext]
+        files.each do |file|
+          res << file if File.exist?(file.to_s)
+        end
+      end
+
+      res
+    end
+
+    # read file paths and run configuration parsers
+    # then appropriately merge configurations
+    def resolve_configurations(ignore_default_paths: false, extra_paths: [])
+      paths = if ignore_default_paths
+                extra_paths
+              else
+                default_paths.concat(extra_paths)
+              end
+      paths.each do |path|
+        parted  = path.split(%(.))
+        ext     = parted[-1]
+        _base   = parted[0]
+
+        synthesizer.synthesize(File.read(path), ext)
+      end
+      synthesizer.synthesis
+    end
+  end
+end

data/lib/pangea/cli/constants.rb

@@ -0,0 +1,33 @@
+module Constants
+  ARTIFACT_FILE = %(artifact.tf.json).freeze
+
+  CACHE_DIR = File.join(
+    Dir.home,
+    %(.cache),
+    %(pangea)
+  ).freeze
+
+  PROJECT_VERSION = %i[version.rb].freeze
+
+  # order of elements matters here
+  # projects should be processed
+  # by collecting ruby files in exactly
+  # this order. changing this can significantly
+  # impact how a project is processed.
+  PROJECT_SRC_DIRS = %i[
+    resources
+    post
+    lib
+    pre
+  ].freeze
+
+  # configuration extensions
+  EXTENSIONS = %i[
+    json
+    toml
+    yaml
+    yml
+    nix
+    rb
+  ].freeze
+end

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

@@ -0,0 +1,212 @@
+require %(pangea/cli/subcommands/pangea)
+require %(pangea/synthesizer/config)
+require %(terraform-synthesizer)
+require %(pangea/cli/config)
+require %(aws-sdk-dynamodb)
+require %(aws-sdk-s3)
+require %(json)
+
+class ConfigCommand < PangeaCommand
+  usage do
+    desc    %(manage configuration)
+    program %(pangea)
+    command %(config)
+  end
+
+  argument :subcommand do
+    desc %(subcommand for config)
+    required
+  end
+
+  def help
+    <<~HELP
+      Usage: pangea config [OPTIONS] SUBCOMMAND
+
+      Arguments:
+        SUBCOMMAND  subcommand for config
+
+      Options:
+        -h, --help    Print usage
+    HELP
+  end
+
+  #############################################################################
+  # helpers
+  #############################################################################
+
+  # check if dynamodb table exists
+  def table_exists?(table_name)
+    dynamodb.describe_table({ table_name: table_name })
+    true
+  rescue Aws::DynamoDB::Errors::ResourceNotFoundException
+    false
+  end
+
+  def s3
+    @s3 ||= Aws::S3::Resource.new
+  end
+
+  def bucket_exist?(name)
+    s3.bucket(name).exists?
+  end
+
+  def dynamodb
+    @dynamodb ||= Aws::DynamoDB::Client.new
+  end
+
+  def dynamodb_terraform_lock_spec(table_name)
+    {
+      table_name: table_name,
+      key_schema: [
+        {
+          attribute_name: %(LockID),
+          key_type: %(HASH)
+        }
+      ],
+      attribute_definitions: [
+        {
+          attribute_name: %(LockID),
+          attribute_type: %(S)
+        }
+      ],
+      provisioned_throughput: {
+        read_capacity_units: 5,
+        write_capacity_units: 5
+      }
+    }
+  end
+
+  # end helpers
+
+  #####################################################################
+  # catch pangea config <subcommand>
+  #####################################################################
+
+  def run(argv)
+    case argv[1].to_s
+    when %(show)
+      config = Config.resolve_configurations
+      puts JSON.pretty_generate(config)
+    when %(plan)
+      puts 'planning pangea configuration...'
+      synth  = TerraformSynthesizer.new
+      config = Config.resolve_configurations
+      puts JSON.pretty_generate(config)
+
+      config[:namespace].each_key do |ns_name|
+        ns = config[:namespace][ns_name]
+        ns.each_key do |ctx_name|
+          ctx = ns[ctx_name]
+
+          ###################################################################
+          # setup modules
+          ###################################################################
+          modules = ctx[:modules]
+
+          modules.each_key do |mod_name|
+            this_mod = modules[mod_name]
+
+            if this_mod[:sandboxed]
+              # TODO: setup sandboxed module
+              # sandbox should be a complete ruby executable space
+              nil
+            elsif this_mod[:path]
+
+              lib_dir   = File.join(this_mod[:path], %(lib))
+              lib_files = Dir.glob(File.join(this_mod[:path], %(lib), %(**/*.rb)))
+
+              system(%(mkdir -p #{lib_dir})) unless Dir.exist?(lib_dir)
+
+              lib_files.each do |lib_file|
+                synth.synthesize(
+                  File.read(
+                    File.join(
+                      this_mod[:path],
+                      %(lib),
+                      lib_file
+                    )
+                  )
+                )
+              end
+
+              # end process lib if exists
+              # process src if exists
+
+              src_dir   = File.join(this_mod[:path], %(src))
+              src_files = Dir.glob(File.join(src_dir, %(**/*.rb)))
+
+              system(%(mkdir -p #{src_dir})) unless Dir.exist?(src_dir)
+
+              src_files.each do |src_file|
+                synth.synthesize(File.read(File.join(src_file)))
+              end
+            end
+          end
+        end
+        puts JSON.pretty_generate(synth.synthesis)
+      end
+    when %(init)
+      puts 'intializing pangea configuration...'
+      config = Config.resolve_configurations
+
+      config[:namespace].each_key do |ns_name|
+        ns = config[:namespace][ns_name]
+
+        #####################################################################
+        # process namespaces in configuraton
+        #####################################################################
+
+        ns.each_key do |ctx_name|
+          ctx = ns[ctx_name]
+          next unless ctx[:state_config][:terraform][:s3]
+
+          ###################################################################
+          # dynamodb table setup
+          ###################################################################
+
+          unless table_exists?(ctx[:state_config][:terraform][:s3][:dynamodb_table])
+            begin
+              result = dynamodb.create_table(
+                dynamodb_terraform_lock_spec(
+                  ctx[:state_config][:terraform][:s3][:dynamodb_table]
+                )
+              )
+              puts "Created table. Status: #{result.table_description.table_status}"
+            rescue Aws::DynamoDB::Errors::ServiceError => e
+              puts e.message
+            end
+          end
+
+          # dynamodb table setup
+
+          ###################################################################
+          # s3 bucket setup
+          ###################################################################
+
+          bucket_name =
+            ctx[:state_config][:terraform][:s3][:bucket]
+          s3.create_bucket(bucket: bucket_name) unless bucket_exist?(bucket_name)
+
+          # end s3 bucket setup
+
+          ###################################################################
+          # setup directories
+          ###################################################################
+
+          base_dir    = File.join(Dir.home, %(.pangea))
+          context_dir = File.join(base_dir, ctx_name)
+          synth_dir   = File.join(base_dir, synth_dir)
+
+          system(%(mkdir -p #{context_dir})) unless Dir.exist?(context_dir)
+          system(%(mkdir -p #{synth_dir})) unless Dir.exist?(synth_dir)
+
+          # end setup directories
+        end
+
+        # end process namespaces in configuraton
+      end
+    end
+  end
+
+  # end catch pangea config <subcommand>
+end

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

@@ -0,0 +1,311 @@
+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 InfraCommand < PangeaCommand
+  include Constants
+  NAME = :infra
+
+  usage do
+    desc %(manage infrastructure)
+    program %(pangea)
+    command %(infra)
+  end
+
+  argument :subcommand do
+    desc %(the subcommand)
+  end
+
+  argument :target do
+    desc %(target like ${namespace}.${site})
+  end
+
+  def reject_empty_configurations
+    if cfg_synth.empty?
+      Say.terminal %(configuration empty, exiting...)
+      exit
+    end
+  end
+
+  def help
+    <<~HELP
+      Usage: pangea infra command [OPTIONS] SUBCOMMAND
+
+      Arguments:
+        SUBCOMMAND  subcommand for pangea infra
+
+      Subcommands:
+        plan    plan infrastructure
+        apply   apply infrastructure
+        config  show run configuration
+    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
+
+  def plan(argv)
+    Say.terminal %(planning!)
+    parse(argv)
+    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
+    Say.terminal JSON.pretty_generate(cfg_synth)
+  end
+
+  def common_run_checks
+    reject_empty_configurations
+  end
+
+  def process_modules(namespace)
+    template = {}
+    namespaces = cfg_synth[:namespace].keys.map(&:to_sym)
+    namespaces.each do |namespace_name|
+      ns = cfg_synth[:namespace][namespace_name]
+      context_names = ns.keys.map(&:to_sym)
+
+      context_names.each do |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]
+          template.merge!(PangeaModule.process(mod))
+        end
+      end
+    end
+    { template: template, namespaces: cfg_synth[:namespace].keys.map(&:to_sym) }
+  end
+
+  def run(argv)
+    common_run_checks
+
+    if argv.length < 2
+      puts help
+      exit
+    end
+
+    config if argv[1].to_s.eql?(%(config))
+    plan(argv) if argv[1].to_s.eql?(%(plan))
+    apply(argv) if argv[1].to_s.eql?(%(apply))
+
+    # preflight checks for the command execution
+    # check_run
+    # check_target(params[:target], cfg_synth)
+
+    # targets = params[:target].split('.').map(&:to_sym)
+    # process_target(targets, cfg_synth)
+
+    ###########################################################################
+    # modules
+    # modules can be fetched from git or local path
+    # modules can have a virtual environment to execute in
+    ###########################################################################
+
+    # 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)
+    #
+    #   context_names.each do |cn|
+    #     context = namespace[cn]
+    #     modules = context[:modules]
+    #
+    #     modules.each do |mod|
+    #       PangeaModule.process(mod)
+    #     end
+    #   end
+    # end
+
+    ###########################################################################
+
+    # provide some kind of default exit of the command execution
+    # exit
+  end
+
+  # process stage for target
+  # def process_target(targets, cfg_synth)
+  #   namespaces    = cfg_synth[:namespace].keys.map(&:to_sym)
+  #   environments  = []
+  #
+  #   namespaces.each do |ns_name|
+  #     environments.concat(cfg_synth[:namespace][ns_name].keys.map(&:to_sym))
+  #   end
+  #
+  #   case targets.length.to_i
+  #     # only provided namespace
+  #   when 1
+  #     nil
+  #     # only provided namespace.site
+  #   when 2
+  #     nil
+  #     # only provided namespace.site.project
+  #   when 3
+  #     announce_preflight_info(targets, cfg_synth)
+  #     environments.each do |e_name|
+  #       projects = cfg_synth[:namespace][targets[0]][e_name][:projects]
+  #       projects.each do |project|
+  #         announce_project(project)
+  #
+  #         synth = TerraformSynthesizer.new
+  #         case project[:src][:type].to_sym
+  #         when :local
+  #           system %(mkdir -p #{CACHE_DIR}) unless Dir.exist?(CACHE_DIR)
+  #           PROJECT_SRC_DIRS.each do |src_dir|
+  #             next unless File.exist?(File.join(
+  #                                       project[:src][:location].to_s,
+  #                                       %(src),
+  #                                       src_dir.to_s
+  #                                     ))
+  #
+  #             synth_files = Dir.glob("#{File.join(
+  #               project[:src][:location].to_s,
+  #               %(src),
+  #               src_dir.to_s
+  #             )}/**/*.rb")
+  #             synth_files.each do |synth_file|
+  #               synth.synthesize(File.read(synth_file))
+  #             end
+  #           end
+  #
+  #           Say.terminal JSON.pretty_generate(synth.synthesis)
+  #
+  #           project_cache_dir = File.join(CACHE_DIR, project[:name].to_s)
+  #
+  #           system %(mkdir -p #{project_cache_dir}) unless Dir.exist?(project_cache_dir)
+  #           File.write(File.join(project_cache_dir, ARTIFACT_FILE), synth.synthesis.to_json)
+  #           system %(cd #{project_cache_dir} && terraform init)
+  #           system %(cd #{project_cache_dir} && terraform plan)
+  #
+  #         when :git
+  #           nil
+  #         end
+  #       end
+  #     end
+  #
+  #     # fetch project data
+  #     # projet_data = cfg_synth[:namespace][targets[0]]
+  #   end
+  # end
+
+  # def announce_project(project)
+  #   msg = []
+  #   msg << %(project: #{project[:name]})
+  #   msg << %(src:     #{project[:src]})
+  #   Say.terminal msg.map(&:strip).join(%(\n))
+  # end
+
+  # def announce_preflight_info(targets, cfg_synth)
+  #   namespaces    = cfg_synth[:namespace].keys.map(&:to_sym)
+  #   environments  = []
+  #
+  #   namespaces.each do |ns_name|
+  #     environments.concat(cfg_synth[:namespace][ns_name].keys.map(&:to_sym))
+  #   end
+  #
+  #   preflight_info = []
+  #   preflight_info << %(environments: #{environments})
+  #   preflight_info << %(\n)
+  #   preflight_info << %(namespace: #{targets[0]})
+  #   preflight_info << %(site:      #{targets[1]})
+  #   preflight_info << %(project:   #{targets[2]})
+  #
+  #   Say.terminal preflight_info.map(&:strip).join(%(\n))
+  # end
+
+  # targets can be...
+  # ${namespace}
+  # ${namespace}.${site}
+  # def check_target(target, config)
+  #   # raise NamespaceNotFoundError if target.nil?
+  #
+  #   # targets       = target.split('.').map(&:to_sym)
+  #   # namespaces    = config[:namespace].keys.map(&:to_sym)
+  #   # runtype       = nil
+  #   # environments  = []
+  #
+  #   # namespaces.each do |ns_name|
+  #   #   environments.concat(config[:namespace][ns_name].keys.map(&:to_sym))
+  #   # end
+  #
+  #   # raise NamespaceNotFoundError unless namespaces.include?(targets[0])
+  #
+  #   # namespaces.each do |ns_name|
+  #   #   environments.each do |e_name|
+  #   #     sites = config[:namespace][ns_name][e_name][:sites] || []
+  #   #
+  #   #     next if sites.empty?
+  #   #
+  #   #     site_names = []
+  #   #     sites.each do |site|
+  #   #       site_names << site[:name]
+  #   #     end
+  #   #
+  #   #     raise SiteNotFoundError unless site_names.include?(targets[1].to_sym)
+  #   #
+  #   #     projects = config[:namespace][ns_name][e_name][:projects] || []
+  #   #
+  #   #     next if projects.empty?
+  #   #
+  #   #     project_names = []
+  #   #     projects.each do |project|
+  #   #       project_names << project[:name]
+  #   #     end
+  #   #
+  #   #     raise ProjectNotFoundError \
+  #   #     unless project_names
+  #   #            .include?(
+  #   #              targets[2].to_sym
+  #   #            )
+  #   #   end
+  #   # end
+  # end
+
+  # def check_run
+  #   raise IncorrectSubcommandError unless correct_subcommand?(
+  #     params[:subcommand]
+  #   )
+  #   raise NoInfraTargetError unless params[:target]
+  # end
+
+  # def correct_subcommand?(sbcmd)
+  #   NAME.to_s.eql?(sbcmd.to_s)
+  # end
+end

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

@@ -0,0 +1,58 @@
+require %(pangea/cli/subcommands/pangea)
+require %(pangea/cli/subcommands/infra)
+require %(pangea/cli/subcommands/config)
+require %(pangea/cli/config)
+require %(pangea/version)
+
+###############################################################################
+# cli entrypoint
+###############################################################################
+
+class Command < PangeaCommand
+  usage do
+    program %(pangea)
+  end
+
+  argument :subcommand do
+    desc %(subcommand for pangea)
+    required
+  end
+
+  def help
+    <<~HELP
+      Usage: pangea command [OPTIONS] SUBCOMMAND
+
+      Arguments:
+        SUBCOMMAND  subcommand for pangea
+
+      Options:
+        -h, --help     Print usage
+        -v, --version  Print version
+
+      Subcommands:
+        infra   manage infrastructure
+        config  manage configuration
+    HELP
+  end
+
+  def run
+    argv = ARGV
+    parse(argv)
+
+    case params[:subcommand].to_s
+    when %(infra)
+      InfraCommand.new.run(argv)
+    when %(config)
+      ConfigCommand.new.run(argv)
+    else
+      if params[:version]
+        puts Pangea::VERSION
+      else
+        puts help
+      end
+      exit
+    end
+  end
+end
+
+# end cli entrypoint