lambit 0.0.1

data/lib/lambit/aws/cloud_watch_events/rule.rb

@@ -0,0 +1,62 @@
+# encoding: UTF-8
+
+module Lambit
+  module Aws
+    module CloudWatchEvents
+      class Rule
+        OPTIONS = [
+              :name,
+              :rule,
+              :schedule_expression,
+              :event_pattern,
+              :state,
+              :description,
+              :role_arn,
+              :targets
+          ].each { |option| attr_reader option }
+
+        attr_reader :client
+        attr_reader :options
+
+        def initialize(config)
+          @client = ::Aws::CloudWatchEvents::Client.new
+
+          OPTIONS.each do |option|
+            if config.has_key?(option)
+              instance_variable_set("@#{option}", config[option])
+            end
+          end
+        end
+
+        def options
+          options = {}
+
+          OPTIONS.each do |option|
+            value = self.send(option)
+            options[option] = value unless value.nil?
+          end
+          options
+        end
+
+        def put_rule
+          self.client.put_rule options
+        end
+
+        def delete_rule
+          opts = {name: options[:name]}
+          self.client.delete_rule opts
+        end
+
+        def put_targets
+          opts = {rule: options[:rule], targets: options[:targets]}
+          self.client.put_targets opts
+        end
+
+        def remove_targets
+          opts = {rule: options[:rule], ids: options[:targets].map{|i| i.map{|k,v| v if k == :id}.compact}.flatten}
+          self.client.remove_targets opts
+        end
+      end
+    end
+  end
+end

data/lib/lambit/aws/lambda/function.rb

@@ -0,0 +1,53 @@
+# encoding: UTF-8
+
+module Lambit
+  module Aws
+    module Lambda
+      class Function
+        OPTIONS = [
+              :function_name,
+              :runtime,
+              :role,
+              :handler,
+              :code,
+              :description,
+              :timeout,
+              :memory_size,
+              :publish,
+              :vpc_config
+          ].each { |option| attr_reader option }
+
+        attr_reader :client
+
+        def initialize(config)
+          @client = ::Aws::Lambda::Client.new
+
+          OPTIONS.each do |option|
+            if config.has_key?(option)
+              instance_variable_set("@#{option}", config[option])
+            end
+          end
+        end
+
+        def options
+          options = {}
+
+          OPTIONS.each do |option|
+            value = self.send(option)
+            options[option] = value unless value.nil?
+          end
+          options
+        end
+
+        def create_function
+          self.client.create_function options
+        end
+
+        def delete_function
+          opts = {function_name: options[:function_name]}
+          self.client.delete_function opts
+        end
+      end
+    end
+  end
+end

data/lib/lambit/aws/lambda/permission.rb

@@ -0,0 +1,52 @@
+# encoding: UTF-8
+
+module Lambit
+  module Aws
+    module Lambda
+      class Permission
+        OPTIONS = [
+              :function_name,
+              :statement_id,
+              :action,
+              :principal,
+              :source_arn,
+              :source_account,
+              :event_source_token,
+              :qualifier
+          ].each { |option| attr_reader option }
+
+        attr_reader :client
+        attr_reader :options
+
+        def initialize(config)
+          @client = ::Aws::Lambda::Client.new
+
+          OPTIONS.each do |option|
+            if config.has_key?(option)
+              instance_variable_set("@#{option}", config[option])
+            end
+          end
+        end
+
+        def options
+          options = {}
+
+          OPTIONS.each do |option|
+            value = self.send(option)
+            options[option] = value unless value.nil?
+          end
+          options
+        end
+
+        def add
+          self.client.add_permission options
+        end
+
+        def remove
+          opts = {function_name: options[:function_name], statement_id: options[:statement_id]}
+          self.client.remove_permission opts
+        end
+      end
+    end
+  end
+end

data/lib/lambit/aws/s3/bucket_notification_configuration.rb

@@ -0,0 +1,81 @@
+# encoding: UTF-8
+
+using Lambit::Common::HashHelper
+
+module Lambit
+  module Aws
+    module S3
+      class BucketNotificationConfiguration
+        OPTIONS = [
+              :bucket,
+              :notification_configuration,
+              :use_accelerate_endpoint
+          ].each { |option| attr_reader option }
+
+        attr_reader :client
+        attr_reader :options
+
+        def initialize(config)
+          @client = ::Aws::S3::Client.new
+
+          OPTIONS.each do |option|
+            if config.has_key?(option)
+              instance_variable_set("@#{option}", config[option])
+            end
+          end
+        end
+
+        def options
+          options = {}
+
+          OPTIONS.each do |option|
+            value = self.send(option)
+            options[option] = value unless value.nil?
+          end
+          options
+        end
+
+        def notification_configuration_types
+          types = [
+            :topic_configurations,
+            :lambda_function_configurations,
+            :queue_configurations
+          ]
+        end
+
+        def add
+          config = self.client.get_bucket_notification_configuration(:bucket => options[:bucket])
+
+          notification_configuration_types.each do |type|
+            options_hash = options[:notification_configuration][type].to_a.map { |r| [r[:id], r] }.to_h
+            config_hash  = config.send(type).to_a.map { |r| [r[:id], r.to_hash] }.to_h
+            options[:notification_configuration][type] = config_hash.merge(options_hash).values
+          end
+
+          put(options)
+        end
+
+        def remove
+          config = self.client.get_bucket_notification_configuration(:bucket => options[:bucket])
+
+          notification_configuration_types.each do |type|
+            options_hash = options[:notification_configuration][type].to_a.map { |r| [r[:id], r] }.to_h
+            config_hash  = config.send(type).to_a.map { |r| [r[:id], r.to_hash] }.to_h
+            options[:notification_configuration][type] = config_hash.difference(options_hash).values
+          end
+
+          put(options)
+        end
+
+        def put(opts)
+          r = self.client.put_bucket_notification_configuration(opts)
+          notification_configuration_types.each do |type|
+            puts self.client.get_bucket_notification_configuration(:bucket => opts[:bucket]).send type
+          end if Lambit.is_debug?
+
+          r
+        end
+      end
+    end
+  end
+end

data/lib/lambit/commands.rb

@@ -0,0 +1,6 @@
+# encoding: UTF-8
+
+require_relative 'commands/common'
+require_relative 'commands/subcommand'
+require_relative 'commands/build'
+require_relative 'commands/lambdas'

data/lib/lambit/commands/build.rb

@@ -0,0 +1,128 @@
+# encoding: UTF-8
+
+require 'json'
+require 'fileutils'
+
+using Lambit::Common::StringHelper
+
+module Lambit::Commands
+  module Build
+    def self.run(cmd, opts, args)
+      handler            = handler_for cmd
+      output, exitstatus = handler.run opts, args
+
+      # Send Subcommand output to STDOUT if :debug
+      if Lambit.is_debug?
+        puts output unless output.nil? || output.empty?
+      end
+
+      # Return exit status
+      exitstatus
+    end
+
+    def self.normalize_cmd(cmd)
+      cmd.to_s.downcase
+    end
+
+    def self.handler_for(cmd)
+      if @handlers
+        @handlers[normalize_cmd(cmd)]
+      else
+        raise 'Uh Oh!'
+      end
+    end
+
+    def self.register_handler_for(cmd, handler=nil)
+      normalized_cmd = normalize_cmd(cmd)
+      handler        = self.const_get(normalized_cmd.classify) if handler.nil?
+
+      @handlers ||= {}
+      @handlers[normalized_cmd] = handler
+    end
+
+    class PackageTemplatesCommand < Lambit::Commands::Common::Base
+      attr_reader :workspace
+      attr_reader :project_path
+      attr_reader :tmpl_name
+      attr_reader :tmpl_config
+
+      def initialize(opts, args)
+        super
+        @workspace = opts['workspace']
+        @project_path = opts['project_path']
+        @tmpl_name = args[0]
+        @tmpl_config = args[1]
+      end
+
+      def command
+        tmpl = JSON.parse(File.read("#{self.project_path}/templates/#{self.tmpl_name}"))
+        tmpl.merge!(self.tmpl_config) unless self.tmpl_config.nil?
+
+        begin
+          File.open("#{self.workspace}/#{self.tmpl_name}",'w') do |f|
+            f.write(tmpl.to_json)
+          end
+          @exitstatus = 0
+        rescue Exception => e
+          if Lambit.is_debug?
+            Lambit.logger.error e
+          else
+            Lambit.logger.error e.message
+          end
+          @exitstatus = 1
+        end
+
+        return '', self.exitstatus
+      end
+    end
+
+    register_handler_for :package_templates_command
+
+    class Base < Lambit::Commands::Subcommands::Base
+      attr_reader :workspace
+
+      def initialize(opts, args)
+        super
+        @workspace = opts['workspace']
+      end
+    end
+
+    class PackagePipCommand < Base
+      attr_reader :pip
+
+      def initialize(opts, args)
+        super
+        @pip = args[0]
+      end
+
+      def subcommand
+        @subcommand = "pip install #{self.pip} -q -t #{workspace}/."
+      end
+    end
+
+    register_handler_for :package_pip_command
+
+    class PackageSourceCommand < Base
+      attr_reader :project_path
+
+      def initialize(opts, args)
+        super
+        @project_path = opts['project_path']
+      end
+
+      def subcommand
+        @subcommand = "cp -r #{project_path}/function/* #{workspace}"
+      end
+    end
+
+    register_handler_for :package_source_command
+
+    class CompressPackageCommand < Base
+      def subcommand
+        @subcommand = "cd #{workspace} && zip -r package.zip *"
+      end
+    end
+
+    register_handler_for :compress_package_command
+  end
+end

data/lib/lambit/commands/common.rb

@@ -0,0 +1,92 @@
+# encoding: UTF-8
+
+require 'time'
+
+using Lambit::Common::StringHelper
+
+module Lambit::Commands
+  module Common
+    def self.run(cmd, opts, args)
+      handler            = handler_for cmd
+      output, exitstatus = handler.run opts, args
+
+      # Send Subcommand output to STDOUT if :debug
+      if Lambit.is_debug?
+        puts output unless output.nil? || output.empty?
+      end
+
+      # Return exit status
+      exitstatus
+    end
+
+    def self.normalize_cmd(cmd)
+      cmd.to_s.downcase
+    end
+
+    def self.handler_for(cmd)
+      if @handlers
+        @handlers[normalize_cmd(cmd)]
+      else
+        raise 'Uh Oh!'
+      end
+    end
+
+    def self.register_handler_for(cmd, handler=nil)
+      normalized_cmd = normalize_cmd(cmd)
+      handler        = self.const_get(normalized_cmd.classify) if handler.nil?
+
+      @handlers ||= {}
+      @handlers[normalized_cmd] = handler
+    end
+
+    class Base
+      attr_reader :run
+      attr_reader :dry_run
+      attr_reader :exitstatus
+
+      def initialize(opts, args)
+        @dry_run          = opts['dry-run']
+        @exitstatus       = 1
+      end
+
+      def self.run(opts, args)
+        output, exitstatus = self.new(opts, args).execute
+        return output, exitstatus
+      end
+
+      def command
+        return '', self.exitstatus
+      end
+
+      def execute
+        command
+      end
+    end
+
+    class CreateWorkspaceCommand < Base
+      attr_reader :workspace
+
+      def initialize(opts, args)
+        super
+        @workspace = opts['workspace']
+      end
+
+      def command
+        begin
+          FileUtils.mkdir_p self.workspace
+          @exitstatus = 0
+        rescue Exception => e
+          if Lambit.is_debug?
+            Lambit.logger.error e
+          else
+            Lambit.logger.error e.message
+          end
+          @exitstatus = 1
+        end
+        return '', self.exitstatus
+      end
+    end
+
+    register_handler_for :create_workspace_command
+  end
+end