bauble_core 0.1.0

data/lib/bauble/cli/docker_command_builder.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Bauble
+  module Cli
+    # Builds a docker command
+    class DockerCommandBuilder
+      def initialize
+        @command = 'docker run '
+      end
+
+      def with_rm
+        @command += '--rm '
+        self
+      end
+
+      def with_volume(volume)
+        @command += "-v #{volume} "
+        self
+      end
+
+      def with_workdir(workdir)
+        @command += "-w #{workdir} "
+        self
+      end
+
+      def with_entrypoint(entrypoint)
+        @command += "--entrypoint #{entrypoint} "
+        self
+      end
+
+      def with_platform(platform)
+        @command += "--platform #{platform} "
+        self
+      end
+
+      def with_image(image)
+        @command += "#{image} "
+        self
+      end
+
+      def with_command(cmd)
+        @command += "-c \"#{cmd}\""
+        self
+      end
+
+      def with_env(key, value)
+        @command += "-e #{key}=#{value} "
+        self
+      end
+
+      def build
+        @command
+      end
+    end
+  end
+end

data/lib/bauble/cli/logger.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'colorize'
+
+module Bauble
+  module Cli
+    # cli logger
+    module Logger
+      class << self
+        def log(message)
+          print "[ Bauble ] #{message}".green
+        end
+
+        def block_log(message)
+          Logger.nl
+          Logger.log message
+          Logger.nl
+        end
+
+        def pulumi(message)
+          print "[ Pulumi ] #{message}".blue
+        end
+
+        def docker(message)
+          print "[ Docker ] #{message}".magenta
+        end
+
+        def nl(times = 1)
+          times.times { puts }
+        end
+
+        def debug(message)
+          puts "[ Bauble DEBUG ] #{message}".orange if ENV['BAUBLE_DEBUG']
+        end
+
+        def error(message)
+          nl
+          puts "[ Bauble Error ] #{message}".red
+          nl
+        end
+
+        def logo
+          puts <<-LOGO
+
+          ██████╗  █████╗ ██╗   ██╗██████╗ ██╗     ███████╗
+          ██╔══██╗██╔══██╗██║   ██║██╔══██╗██║     ██╔════╝
+          ██████╔╝███████║██║   ██║██████╔╝██║     █████╗
+          ██╔══██╗██╔══██║██║   ██║██╔══██╗██║     ██╔══╝
+          ██████╔╝██║  ██║╚██████╔╝██████╔╝███████╗███████╗
+          ╚═════╝ ╚═╝  ╚═╝ ╚═════╝ ╚═════╝ ╚══════╝╚══════╝ v#{Bauble::VERSION}
+
+          LOGO
+        end
+      end
+    end
+  end
+end

data/lib/bauble/cli/pulumi.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require_relative 'logger'
+require 'English'
+
+# pulumi wrapper
+module Bauble
+  module Cli
+    # Pulumi class
+    class Pulumi
+      attr_accessor :config
+
+      def initialize(config:)
+        @config = config
+      end
+
+      def create_pulumi_yml(template)
+        Logger.debug 'Creating Pulumi.yaml...'
+        FileUtils.mkdir_p(@config.pulumi_home) unless Dir.exist?(@config.pulumi_home)
+        File.write("#{@config.pulumi_home}/Pulumi.yaml", template, mode: 'w')
+      end
+
+      def init!
+        init_pulumi unless pulumi_initialized?
+      end
+
+      def preview
+        Logger.debug "Running pulumi preview...\n"
+        output_command('preview')
+      end
+
+      def up(target = nil)
+        Logger.debug "Running pulumi up...\n"
+        output_command("up --yes#{target ? " --target #{target}" : ''}")
+      end
+
+      def destroy
+        Logger.debug "Running pulumi destroy...\n"
+        output_command('destroy --yes')
+      end
+
+      def create_or_select_stack(stack_name)
+        if stack_initialized?(stack_name)
+          Logger.debug "Selecting stack #{stack_name}"
+          select_stack(stack_name)
+        else
+          Logger.debug "Initializing stack #{stack_name}"
+          init_stack(stack_name)
+        end
+      end
+
+      private
+
+      def pulumi_initialized?
+        return false unless pulumi_yml_exists?
+
+        pulumi_logged_in?
+      end
+
+      def output_command(command)
+        Logger.nl
+        IO.popen("#{build_command(command)} 2>&1") do |io|
+          io.each do |line|
+            Logger.pulumi(line)
+          end
+        end
+        Logger.nl
+      end
+
+      def run_command(command)
+        `#{build_command(command)}#{silent_mode}`
+      end
+
+      def silent_mode
+        @config.debug ? '' : ' 2>/dev/null'
+      end
+
+      def build_command(command)
+        "pulumi #{command} #{global_flags.join(' ')}"
+      end
+
+      def global_flags
+        [
+          '--non-interactive',
+          "--cwd #{@config.pulumi_home}"
+        ]
+      end
+
+      def init_pulumi
+        login
+      end
+
+      def pulumi_yml_exists?
+        Logger.debug "Checking for Pulumi.yaml... #{File.exist?("#{@config.pulumi_home}/Pulumi.yaml")}"
+        File.exist?("#{@config.pulumi_home}/Pulumi.yaml")
+      end
+
+      def login
+        Logger.debug 'Logging into pulumi locally...'
+        run_command('login --local')
+      end
+
+      def pulumi_logged_in?
+        run_command('whoami')
+        Logger.debug "Checking pulumi login status... #{$CHILD_STATUS.success?}"
+        $CHILD_STATUS.success?
+      end
+
+      def init_stack(stack_name)
+        run_command("stack init --stack #{stack_name}")
+      end
+
+      def select_stack(stack_name)
+        run_command("stack select --stack #{stack_name}")
+      end
+
+      def stack_initialized?(stack_name)
+        Logger.debug "Checking if stack #{stack_name} is initialized..."
+        run_command('stack ls').include?(stack_name)
+      end
+    end
+  end
+end

data/lib/bauble/resources/api_gateway_v2.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require_relative 'resource'
+
+# Api Gateway v2
+module Bauble
+  module Resources
+    # AWS API Gateway v2
+    class ApiGatewayV2 < Resource
+      attr_accessor :name, :routes, :app
+
+      def initialize(app, name:)
+        super(app)
+        @app = app
+        @name = name
+        @routes = []
+      end
+
+      def synthesize
+        base_hash = api_hash
+        base_hash.merge!(routes_hash)
+        base_hash.merge!(deploymeny_hash)
+        base_hash.merge!(synthesize_permissions)
+        base_hash
+      end
+
+      def add_route(route_key:, function:)
+        routes << { route_key: route_key, target_lambda_arn: "${#{function.name}.arn}", function_name: function.name }
+      end
+
+      def bundle
+        true
+      end
+
+      private
+
+      def routes_hash
+        routes.each_with_index.each_with_object({}) do |(route, index), route_hash|
+          route_name = "#{name}-route-#{index}"
+          route_hash[route_name] = {
+            'type' => 'aws:apigatewayv2:Route',
+            'properties' => {
+              'apiId' => "${#{name}.id}",
+              'routeKey' => route[:route_key],
+              'target' => "integrations/${#{route_name}-integration.id}"
+            }
+          }
+          route_hash.merge!(synthesize_integration(route, route_name))
+        end
+      end
+
+      def synthesize_integration(route, route_name)
+        {
+          "#{route_name}-integration" => {
+            'type' => 'aws:apigatewayv2:Integration',
+            'properties' => {
+              'apiId' => "${#{name}.id}",
+              'integrationUri' => route[:target_lambda_arn],
+              'integrationType' => 'AWS_PROXY',
+              'payloadFormatVersion' => '2.0'
+            }
+          }
+        }
+      end
+
+      def synthesize_permissions
+        routes.uniq { |route| route[:function_name] }.each_with_object({}) do |route, permissions_hash|
+          permissions_hash.merge!(function_permission_hash(route[:function_name]))
+        end
+      end
+
+      def function_permission_hash(function_name)
+        {
+          "#{function_name}-api-gateway-permission" => {
+            'type' => 'aws:lambda:Permission',
+            'properties' => {
+              'action' => 'lambda:InvokeFunction',
+              'function' => "${#{function_name}.name}",
+              'principal' => 'apigateway.amazonaws.com',
+              'sourceArn' => "${#{name}.executionArn}/*/*"
+            }
+          }
+        }
+      end
+
+      def deploymeny_hash
+        {
+          "#{name}-deployment" => {
+            'type' => 'aws:apigatewayv2:Deployment',
+            'properties' => {
+              'apiId' => "${#{name}.id}"
+            },
+            'options' => {
+              'dependsOn' => routes_hash.keys.map { |route_name| "${#{route_name}}" }
+            }
+          }
+        }
+      end
+
+      def api_hash
+        {
+          name => {
+            'type' => 'aws:apigatewayv2:Api',
+            'properties' => {
+              'name' => name,
+              'protocolType' => 'HTTP'
+            }
+          },
+          "#{name}-stage" => {
+            'type' => 'aws:apigatewayv2:Stage',
+            'properties' => {
+              'apiId' => "${#{name}.id}",
+              'name' => app.current_stack.name,
+              'autoDeploy' => true
+            }
+          }
+        }
+      end
+    end
+  end
+end

data/lib/bauble/resources/event_bridge_rule.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require_relative 'resource'
+
+module Bauble
+  module Resources
+    # EventBridgeRule class
+    class EventBridgeRule < Resource
+      def initialize(app, rule_name:, **kwargs)
+        super(app)
+        @rule_name = rule_name
+        @description = kwargs.fetch(:description, 'Bauble EventBridge Rule')
+        @event_pattern = kwargs.fetch(:event_pattern, nil)
+        @schedule_expression = kwargs.fetch(:schedule_expression, nil)
+        @state = kwargs.fetch(:state, 'ENABLED')
+        @event_bus_name = kwargs.fetch(:event_bus_name, 'default')
+        @targets = []
+
+        validate_inputs
+      end
+
+      def synthesize
+        event_rule_hash = {
+          @rule_name => {
+            'type' => 'aws:cloudwatch:EventRule',
+            'properties' => {
+              'name' => @rule_name,
+              'description' => @description,
+              'eventBusName' => @event_bus_name,
+              'state' => @state
+            }
+          }
+        }
+
+        event_rule_hash[@rule_name]['properties']['eventPattern'] = @event_pattern.to_json if @event_pattern
+        event_rule_hash[@rule_name]['properties']['scheduleExpression'] = @schedule_expression if @schedule_expression
+
+        @targets.each do |target|
+          event_rule_hash.merge!(target)
+        end
+
+        event_rule_hash
+      end
+
+      def bundle
+        true
+      end
+
+      def add_target(function)
+        @targets << {
+          "#{@rule_name}-#{function.name}-target" => {
+            'type' => 'aws:cloudwatch:EventTarget',
+            'properties' => {
+              'rule' => "${#{@rule_name}.name}",
+              'arn' => "${#{function.name}.arn}"
+            }
+          },
+          "#{function.name}-permission" => {
+            'type' => 'aws:lambda:Permission',
+            'properties' => {
+              'action' => 'lambda:InvokeFunction',
+              'function' => "${#{function.name}.name}",
+              'principal' => 'events.amazonaws.com',
+              'sourceArn' => "${#{@rule_name}.arn}"
+            }
+          }
+        }
+      end
+
+      private
+
+      def validate_inputs
+        name_present?
+        pattern_or_schedule?
+        pattern_and_schedule?
+      end
+
+      def pattern_or_schedule?
+        return if @event_pattern || @schedule_expression
+
+        raise 'EventBridgeRule must have an event_pattern or a schedule_expression'
+      end
+
+      def pattern_and_schedule?
+        return unless @event_pattern && @schedule_expression
+
+        raise 'EventBridgeRule cannot have both an event_pattern and a schedule_expression'
+      end
+
+      def name_present?
+        return if @rule_name
+
+        raise 'EventBridgeRule must have a rule_name'
+      end
+    end
+  end
+end

data/lib/bauble/resources/gem_layer.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'zip'
+require_relative 'resource'
+require_relative '../cli/code_bundler'
+
+# Ruby function
+module Bauble
+  module Resources
+    # a ruby lambda function
+    class GemLayer < Resource
+      def bundle
+        Bauble::Cli::CodeBundler.docker_bundle_gems(bundle_hash: @app.bundle_hash)
+      end
+
+      def synthesize
+        {
+          'gemLayer' => {
+            'type' => 'aws:lambda:LayerVersion',
+            'name' => 'gem_layer',
+            'properties' => {
+              'code' => {
+                'fn::fileArchive' => "#{@app.config.asset_dir}/#{@app.bundle_hash}/gem-layer"
+              },
+              'layerName' => "#{@app.config.app_name}-gem-layer",
+              'compatibleRuntimes' => %w[ruby3.2]
+            }
+          }
+        }
+      end
+    end
+  end
+end

data/lib/bauble/resources/lambda_role.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require_relative 'resource'
+
+# Lambda role
+module Bauble
+  module Resources
+    # aws lambda role
+    class LambdaRole < Resource
+      attr_accessor :role_name, :policy_statements
+
+      def initialize(app, role_name:, policy_statements: [])
+        super(app)
+        @role_name = role_name
+        @policy_statements = policy_statements
+      end
+
+      def synthesize
+        role_hash = {
+          role_name => {
+            'type' => 'aws:iam:Role',
+            'properties' => {
+              'assumeRolePolicy' => assume_role_policy,
+              'managedPolicyArns' => ['arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole']
+            }
+          }
+        }
+
+        return role_hash.merge(role_policy) if policy_statements.any?
+
+        role_hash
+      end
+
+      def add_policy_statement(effect:, actions:, resources:)
+        policy_statements << { effect: effect, actions: actions, resources: resources }
+      end
+
+      def bundle
+        true
+      end
+
+      private
+
+      def role_policy
+        {
+          "#{role_name}-policy" => {
+            'type' => 'aws:iam:RolePolicy',
+            'properties' => {
+              'name' => "#{role_name}-policy",
+              'role' => "${#{role_name}}",
+              'policy' => synth_policies
+            }
+          }
+        }
+      end
+
+      def synth_policies
+        {
+          Version: '2012-10-17',
+          Statement: policy_statements.map do |statement|
+            {
+              Effect: statement[:effect].downcase == 'allow' ? 'Allow' : 'Deny',
+              Action: statement[:actions],
+              Resource: statement[:resources]
+            }
+          end
+        }.to_json
+      end
+
+      def assume_role_policy
+        {
+          'Version' => '2012-10-17',
+          'Statement' => [
+            {
+              'Action' => 'sts:AssumeRole',
+              'Principal' => {
+                'Service' => 'lambda.amazonaws.com'
+              },
+              'Effect' => 'Allow'
+            }
+          ]
+        }.to_json
+      end
+    end
+  end
+end

data/lib/bauble/resources/postgres_layer.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative 'resource'
+require_relative '../cli/docker_command_builder'
+require_relative '../cli/logger'
+
+module Bauble
+  module Resources
+    # Postgres layer
+    class PostgresLayer < Resource
+      def bundle
+        IO.popen("docker build -t bauble_postgres_layer #{__dir__}/../cli/Dockerfile.postgres } 2>&1") do |io|
+          io.each do |line|
+            Bauble::Cli::Logger.docker(line)
+          end
+        end
+
+        IO.popen("#{docker_command} 2>&1") do |io|
+          io.each do |line|
+            Bauble::Cli::Logger.docker(line)
+          end
+        end
+      end
+
+      def synthesize
+        {}
+      end
+
+      private
+
+      def docker_command
+        Bauble::Cli::DockerCommandBuilder
+          .new
+          .with_rm
+          .with_volume('pg-layer:/opt/pgsql')
+          .with_platform('linux/amd64')
+          .with_image('bauble_postgres_layer')
+          .build
+      end
+    end
+  end
+end

data/lib/bauble/resources/resource.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Bauble
+  module Resources
+    # Base resource
+    # TODO: this should just be Resource not base resource
+    class Resource
+      attr_accessor :app
+
+      def initialize(app)
+        @app = app
+        app.add_resource(self)
+      end
+
+      def synthesize
+        raise 'Not implemented'
+      end
+
+      def bundle
+        raise 'Not implemented'
+      end
+    end
+  end
+end