mos-eisley-lambda 0.4.1 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 588396c579300500ee9480c4d1582e000fb1d92722ad0f6ae4a44e9f1cc2aefd
-  data.tar.gz: 9f5ee17355c48a5550f561853b8ce6075978b52f71a6de6fe1f47838d4f5f681
+  metadata.gz: 4e38c9c1ecdcab343fc118677a1f7b515d4fe4ce19a0b4a056b50f515f81f87b
+  data.tar.gz: a0b90f7bfb4c67bf383ce059fab48a7ce93d0588bd0766603dc879ea14783789
 SHA512:
-  metadata.gz: 004a47f7f3e51a3d891c2912993365a61ced40cc1ba7bb82ac383c4a8543d19142b66d622097e8b10cae14e7003fb1e2d8aa4f4eeea3e59718a3543d4d5d69a3
-  data.tar.gz: 6b171f129793e822e3c7755460d93a81c33827c1ce0755fef3c02484cd92d5e487d63f6353d6d6504369b31393fef10e1e4ed62b95a9fa9a520570aa0268c171
+  metadata.gz: 31a6c405c9b10616063c4c7d99579d16bbfbd816ba1476640662a9123aa631d8d51886ee39a1f1007ff7fa1b2b7c46ecf10cbf24dd7f6b45629bbc102c47f43f
+  data.tar.gz: 3dca76f821c4d4be95544eccdc599be61eef6715cdf0f7083649b3ac8ac8cc934d138c7757a31d2d3461491070d6327f8444abc143028f8d438b14a3b3540606

data/README.md

@@ -4,13 +4,12 @@
 
 “You will never find a more wretched hive of scum and villainy.” – Obi-Wan Kenobi
 
-Episode 2 of the Ruby based [Slack app](https://api.slack.com/) framework, this time for [AWS Lambda](https://aws.amazon.com/lambda/). Pure ruby, no external dependency.
+Episode 2 of the Ruby based [Slack app](https://api.slack.com/) framework, this time for [AWS Lambda](https://aws.amazon.com/lambda/). Pure Ruby, no external gem/library dependency.
 
 ## Setup
 
 ### AWS
 
-1. Create an SQS queue for MosEisley
 1. Create an IAM role for MosEisley Lambda function
 1. Create a Lambda function for MosEisley
    - You can install this gem using [Lambda Layer](#using-with-lambda-layers) or just copy the `lib` directory to your Lambda code.
@@ -20,10 +19,11 @@ Episode 2 of the Ruby based [Slack app](https://api.slack.com/) framework, this
 
 Configure Lambda environment variable.
 
-- `SLACK_SIGNING_SECRET`: your Slack app credentials
-- `SLACK_BOT_ACCESS_TOKEN`: your Slack app OAuth token
-- `MOSEISLEY_SQS_URL`: AWS SQS URL used for the event pipeline
-- `MOSEISLEY_LOG_LEVEL` – optional, could be `DEBUG`, `INFO`, `WARN`, or `ERROR` 
+- `SLACK_CREDENTIALS_SSMPS_PATH`: hierarchy path to System Managers Parameter Store; e.g., `/slack/credentials/` would reference two parameters:
+  - `/slack/credetials/signing_secret`
+  - `/slack/credetials/bot_access_token`
+- `MOSEISLEY_LOG_LEVEL`: _optional_, could be `DEBUG`, `INFO`, `WARN`, or `ERROR` 
+- `SLACK_LOG_CHANNEL_ID`: _optional_, if you want to use `ME::SlackWeb.post_log()`
 
 Configure Lambda code in your `lambda_function.rb` file.
 
@@ -37,7 +37,7 @@ MosEisley::Handler.import
 # MosEisley::Handler.import_from_path('./my-handlers')
 
 def lambda_handler(event:, context:)
-  MosEisley::lambda_event(event)
+  MosEisley::lambda_event(event, context)
 end
 ```
 
@@ -85,50 +85,36 @@ ME::Handler.add(:command, 'A Slack command') do |event, myself|
 end
 ```
 
-## Protocols
-
-### SQS
-
-- Attributes
-  - `source`: `slack`, `moseisley`, or other
-    - `endpoint`: if source is `slack`, which endpoint it arrived at
-  - `destination`: `slack` or `moseisley`
-    - `api`: if destination is `slack`
-- Message (JSON)
-  - `params`: object, meant to be passed to Slack API 
-  - `payload`: the data/payload itself
-
 ### Helpers
 
-`ME::S3PO` – collection of helpers to analyze/create Slack messages.
-`ME::SlackWeb` – methods for sending payloads to Slack Web API calls.
+- `ME::S3PO` – collection of helpers to analyze/create Slack messages.
+- `ME::SlackWeb` – methods for sending payloads to Slack Web API calls.
 
 ## Event Lifecycle
 
 ### Inbound
 
 1. Slack event is sent to Mos Eisley Lambda function via API Gateway
-1. Slack event is verified and returned with parsed object
+1. Slack event is verified and produces a parsed object
 1. If it's a slash command, MosEisley::Handler.command_acks is referenced and immediate response is sent
-1. The original Slack event JSON is sent to SQS with attributes
+1. The original Slack event JSON is sent to the function in a recursive fashion (this is to return the inital response ASAP)
 
 ### Event Processing
 
-1. Slack event is recieved by SQS trigger
+1. Lambda function is invoked by itself with the original Slack event
 1. Handlers are called and processed according to original endpoint the event was sent to; actions, commands, events, menus
-1. Should send a Slack message to complete the event cycle
+1. Send a Slack message as necessary and the Slack event cycle is complete
 
-<!-- ### Message Publishing
+<!-- ### Outbound, Messaging Only
 
-Send a message to SQS from another app to send a Slack message
+Invoke the function from another app to send a Slack message
 
-1. Create a Slack message packaged to be sent to the API and send to SQS
-1. Message event is recieved by SQS trigger
-1. Message is sent to Slack API -->
+1. Create a Slack message packaged to be sent to the API and invoke the function
+1. Message is received, then sent to Slack API according to payload-->
 
 ## Using with Lambda Layers
 
-Used the Makefile to create a zip file which can be uploaded as a Lambda Layer.
+Used the Makefile to create a zip file which can be uploaded to a Lambda Layer.
 
 ```sh
 make

data/lib/handler.rb

@@ -19,17 +19,26 @@ module MosEisley
     end
 
     # Call as often as necessary to add handlers with blocks; each call creates a MosEisley::Handler object
-    # @param type [Symbol] :action | :command | :event | :menu
-    # @param name [String]
+    # @param type [Symbol] :action | :command_response | :command | :event | :menu
+    # @param name [String] required for type = :command_response, otherwise optional
     def self.add(type, name = nil, &block)
+      if type == :command_response && name.nil?
+        raise ArgumentError.new('Name required for :command_response.')
+      end
       @handlers ||= {
         action: [],
+        command_response: {},
         command: [],
         event: [],
         menu: [],
       }
-      @handlers[type] << MosEisley::Handler.new(type, name, &block)
-      MosEisley.logger.debug("Added #{type} handler: #{@handlers[type].last}")
+      h = MosEisley::Handler.new(type, name, &block)
+      if type == :command_response
+        @handlers[type][name] = h 
+      else
+        @handlers[type] << h
+      end
+      MosEisley.logger.debug("Added #{type} handler: #{h}")
     end
 
     # Example: {'/command' => {response_type: 'ephemeral', text: nil}}
@@ -48,14 +57,22 @@ module MosEisley
     def self.run(type, event)
       logger = MosEisley.logger
       response = nil
-      @handlers[type].each do |h|
-        response = h.run(event)
-        if h.stopped?
-          logger.debug('Handler stop was requested.')
-          break
+      if type == :command_response
+        h = @handlers[type][event[:command]]
+        if h
+          response = h.run(event)
+          logger.info("Done running #{type} handlers.")
+        end
+      else
+        @handlers[type].each do |h|
+          response = h.run(event)
+          if h.stopped?
+            logger.debug('Handler stop was requested.')
+            break
+          end
         end
+        logger.info("Done running #{type} handlers.")
       end
-      logger.info("Done running #{type} handlers.")
       response
     end
 

data/lib/mos-eisley-lambda.rb

@@ -2,52 +2,88 @@ require_relative './logger'
 require_relative './slack'
 require_relative './s3po/s3po'
 require_relative './handler'
-require 'aws-sdk-sqs'
+require 'aws-sdk-lambda'
+require 'aws-sdk-ssm'
 require 'base64'
 require 'json'
 
 ME = MosEisley
-SQS = Aws::SQS::Client.new
 
 module MosEisley
-  def self.lambda_event(event)
-    abort unless preflightcheck
-    # Inbound Slack event (via API GW)
-    if event['routeKey']
+  def self.config
+    @config ||= {}
+  end
+
+  def self.lambda_event(event, context)
+    raise 'Pre-flight check failed!' unless preflightcheck
+    case
+    when event['routeKey']
+      # Inbound Slack event (via API GW)
       MosEisley.logger.info('API GW event')
-      return apigw_event(event)
-    end
-    # Internal event (via SQS)
-    if event.dig('Records',0,'eventSource') == 'aws:sqs'
-      MosEisley.logger.info('SQS event')
-      return sqs_event(event)
+      return apigw_event(event, context)
+    when event.dig('Records',0,'eventSource') == 'MosEisley:Slack_event'
+      # Internal event (via invoke)
+      MosEisley.logger.info('Invoke event')
+      MosEisley.logger.debug("#{event}")
+      return invoke_event(event)
+    else
+      # Unknown event
+      MosEisley.logger.info('Unknown event')
+      return unknown_event(event)
     end
   end
 
   def self.preflightcheck
-    l = ENV['MOSEISLEY_LOG_LEVEL']
-    if String === l && ['DEBUG', 'INFO', 'WARN', 'ERROR'].include?(l.upcase)
-      MosEisley.logger.level = eval("Logger::#{l.upcase}")
+    if config[:timestamp]
+      MosEisley.logger.debug("Confing already loaded at: #{config[:timestamp]}")
+      return true
     end
     env_required = [
-      'MOSEISLEY_SQS_URL',
-      'SLACK_SIGNING_SECRET',
-      'SLACK_BOT_ACCESS_TOKEN',
+      'SLACK_CREDENTIALS_SSMPS_PATH',
     ]
     env_optional = [
       'MOSEISLEY_LOG_LEVEL',
+      'SLACK_LOG_CHANNEL_ID',
     ]
-    env_required.each do |e|
-      if ENV[e].nil?
-        MosEisley.logger.error("Missing environment variable: #{e}")
+    config_required = [
+      :signing_secret,
+      :bot_access_token,
+    ]
+    l = ENV['MOSEISLEY_LOG_LEVEL']
+    if String === l && ['DEBUG', 'INFO', 'WARN', 'ERROR'].include?(l.upcase)
+      MosEisley.logger.level = eval("Logger::#{l.upcase}")
+    end
+    env_required.each do |v|
+      if ENV[v].nil?
+        MosEisley.logger.error("Missing environment variable: #{v}")
         return false
       end
+      case v
+      when 'SLACK_CREDENTIALS_SSMPS_PATH'
+        ssm = Aws::SSM::Client.new
+        rparams = {
+          path: ENV['SLACK_CREDENTIALS_SSMPS_PATH'],
+          with_decryption: true,
+        }
+        ssm.get_parameters_by_path(rparams).parameters.each do |prm|
+          k = prm[:name].split('/').last.to_sym
+          config[k] = prm[:value]
+          config_required.delete(k)
+        end
+      end
     end
+    unless config_required.empty?
+      t = "Missing config values: #{config_required.join(', ')}"
+      MosEisley.logger.error(t)
+      return false
+    end
+    config[:timestamp] = Time.now
+    MosEisley.logger.info('Config loaded')
     return true
   end
 
-  def self.apigw_event(event)
-    se = ME::SlackEvent.validate(event)
+  def self.apigw_event(event, context)
+    se = MosEisley::SlackEvent.validate(event)
     unless se[:valid?]
       MosEisley.logger.warn("#{se[:msg]}")
       return {statusCode: 401}
@@ -57,23 +93,21 @@ module MosEisley
     MosEisley.logger.debug("Inbound Slack request to: #{ep}")
     case ep
     when '/actions'
-      # Nothing to do, just pass to SQS
+      ## Slack Interactivity & Shortcuts
+      # Nothing to do, through-pass data
     when '/commands'
-      ser = {}
-      ack = ME::Handler.command_acks[se[:event][:command]]
-      if ack
-        ser[:response_type] = ack[:response_type]
-        ser[:text] =
-          if ack[:text]
-            ack[:text]
-          else
-            text = sep[:text].empty? ? '' : " #{se[:event][:text]}"
-            "Received: `#{se[:event][:command]}#{text}`"
-          end
+      ## Slack Slash Commands
+      MosEisley.logger.debug("Slash command event:\n#{se[:event]}")
+      r = MosEisley::Handler.run(:command_response, se[:event])
+      if String === r
+        r = {text: r}
+      end
+      if Hash === r
         # AWS sets status code and headers by passing JSON string
-        resp = JSON.fast_generate(ser)
+        resp = JSON.fast_generate(r)
       end
     when '/events'
+      ## Slack Event Subscriptions
       # Respond to Slack challenge request
       if se[:event][:type] == 'url_verification'
         c = se[:event][:challenge]
@@ -81,65 +115,55 @@ module MosEisley
         return "{\"challenge\": \"#{c}\"}"
       end
     when '/menus'
-      # ME::Handler.run(:menu, se)
+      # MosEisley::Handler.run(:menu, se)
       # TODO to be implemented
       return "{\"options\": []}"
     else
       MosEisley.logger.warn('Unknown request, ignored.')
       return {statusCode: 400}
     end
-    m = {
-      queue_url: ENV['MOSEISLEY_SQS_URL'],
-      message_attributes: {
-        'source' => {
-          data_type: 'String',
-          string_value: 'slack',
-        },
-        'destination' => {
-          data_type: 'String',
-          string_value: 'moseisley',
-        },
-        'endpoint' => {
-          data_type: 'String',
-          string_value: ep,
-        },
-      },
-      message_body: "{\"payload\":#{se[:json]}}",
+    pl = {
+      Records: [
+        {
+          eventSource: 'MosEisley:Slack_event',
+          endpoint: ep,
+          body: se[:json],
+        }
+      ]
     }
-    SQS.send_message(m)
-    s = m[:message_body].length
-    MosEisley.logger.debug("Sent message to SQS with body size #{s}.")
-    return resp
+    lc = Aws::Lambda::Client.new
+    params = {
+      function_name: context.function_name,
+      invocation_type: 'Event',
+      payload: JSON.fast_generate(pl),
+    }
+    r = lc.invoke(params)
+    if r.status_code >= 200 && r.status_code < 300
+      MosEisley.logger.debug("Successfullly invoked with playload size: #{params[:payload].length}")
+    else
+      MosEisley.logger.warn("Problem with invoke, status code: #{r.status_code}")
+    end
+    resp
   end
 
-  def self.sqs_event(event)
-    a = event.dig('Records',0,'messageAttributes')
-    src = a.dig('source','stringValue')
-    dst = a.dig('destination','stringValue')
-    ep = a.dig('endpoint','stringValue')
+  def self.invoke_event(event)
+    ep = event.dig('Records',0,'endpoint')
     se = JSON.parse(event.dig('Records',0,'body'), {symbolize_names: true})
-    se = se[:payload]
-    MosEisley.logger.debug("Event src: #{src}, dst: #{dst}")
-    if src == 'slack'
-      # Inbound Slack event
-      case ep
-      when '/actions'
-        ME::Handler.run(:action, se)
-      when '/commands'
-        ME::Handler.run(:command, se)
-      when '/events'
-        ME::Handler.run(:event, se)
-      when '/menus'
-        MosEisley.logger.warn('Menu request cannot be processed here.')
-      else
-        MosEisley.logger.warn("Unknown request: #{ep}")
-      end
-    elsif dst == 'slack'
-      # An event to be sent to Slack
-      MosEisley.logger.debug a.dig('api','stringValue')
+    case ep
+    when '/actions'
+      MosEisley::Handler.run(:action, se)
+    when '/commands'
+      MosEisley::Handler.run(:command, se)
+    when '/events'
+      MosEisley::Handler.run(:event, se)
+    when '/menus'
+      MosEisley.logger.warn('Menu request cannot be processed here.')
     else
-      MosEisley.logger.warn('Unknown event, ignored.')
+      MosEisley.logger.warn("Unknown request: #{ep}")
     end
-    return 0
+  end
+
+  def self.unknown_event(event)
+    # TODO hand off to a handler
   end
 end

data/lib/s3po/blockkit.rb

@@ -1,6 +1,32 @@
+# S3PO - Slack protocol droid in Mos Eisley
+#     ::BlockKit - Block Kit tools
+#
+# v.20220201
+
 module MosEisley
   module S3PO
     module BlockKit
+      # @param txt [String]
+      # @param type [Symbol] :plain | :emoji | :mrkdwn
+      # @return [Hash] Block Kit section object
+      def self.con_text(txt, type = :mrkdwn)
+        {
+          type: :context,
+          elements: [
+            text(txt, type),
+          ]
+        }
+      end
+
+      # @param txt [String]
+      # @return [Hash] Block Kit header object
+      def self.header(txt)
+        {
+          type: :header,
+          text: text(txt, :emoji),
+        }
+      end
+
       # @param txt [String]
       # @param type [Symbol] :plain | :emoji | :mrkdwn
       # @return [Hash] Block Kit section object

data/lib/s3po/s3po.rb

@@ -1,3 +1,7 @@
+# S3PO - Slack protocol droid in Mos Eisley
+#
+# v.20210626
+
 require 'json'
 require 'time'
 require_relative './blockkit'

data/lib/slack.rb

@@ -15,7 +15,7 @@ module MosEisley
       end
       b = e['isBase64Encoded'] ? Base64.decode64(e['body']) : e['body']
       s = "v0:#{t}:#{b}"
-      k = ENV['SLACK_SIGNING_SECRET']
+      k = MosEisley.config[:signing_secret]
       sig = "v0=#{OpenSSL::HMAC.hexdigest('sha256', k, s)}"
       if e.dig('headers', 'x-slack-signature') != sig
         return {valid?: false, msg: 'Invalid signature.'}
@@ -48,11 +48,23 @@ module MosEisley
       post_to_slack('chat.meMessage', data)
     end
 
-    def self.chat_postephemeral()
+    def self.chat_postephemeral(channel:, blocks: nil, text: nil, thread_ts: nil)
+      chat_send(:postEphemeral, channel, blocks, text, thread_ts)
     end
 
     def self.chat_postmessage(channel:, blocks: nil, text: nil, thread_ts: nil)
+      chat_send(:postMessage, channel, blocks, text, thread_ts)
+    end
+
+    def self.chat_schedulemessage(channel:, post_at:, blocks: nil, text: nil, thread_ts: nil)
+      chat_send(:scheduleMessage, channel, blocks, text, thread_ts, post_at)
+    end
+
+    def self.chat_send(m, channel, blocks, text, thread_ts, post_at = nil)
       data = {channel: channel}
+      if m == :scheduleMessage
+        post_at ? data[:post_at] = post_at : raise
+      end
       if blocks
         data[:blocks] = blocks
         data[:text] = text if text
@@ -60,10 +72,7 @@ module MosEisley
         text ? data[:text] = text : raise
       end
       data[:thread_ts] = thread_ts if thread_ts
-      post_to_slack('chat.postMessage', data)
-    end
-
-    def self.chat_schedulemessage()
+      post_to_slack("chat.#{m}", data)
     end
 
     def self.post_response_url(url, payload)
@@ -111,16 +120,65 @@ module MosEisley
     def self.views_push(trigger_id:, view:)
     end
 
-    # def self.auth_test
-    #   post_to_slack('auth.test')
-    # end
+    def self.conversations_members(channel:, cursor: nil, limit: nil)
+      params = {channel: channel}
+      params[:cursor] = cursor if cursor
+      params[:limit] = limit if limit
+      get_from_slack('conversations.members', params)
+    end
+
+    def self.users_info(user)
+      get_from_slack('users.info', {user: user})
+    end
+
+    def self.users_list(cursor: nil, limit: nil)
+      params = {include_locale: true}
+      params[:cursor] = cursor if cursor
+      params[:limit] = limit if limit
+      get_from_slack('users.list', params)
+    end
+
+    def self.users_lookupbyemail(email)
+      get_from_slack('users.lookupByEmail', {email: email})
+    end
+
+    def self.users_profile_get(user)
+      get_from_slack('users.profile.get', {user: user})
+    end
+
+    def self.auth_test
+      post_to_slack('auth.test', '')
+    end
 
     private
 
+    def self.get_from_slack(m, params)
+      l = MosEisley.logger
+      url ||= BASE_URL + m
+      head = {authorization: "Bearer #{MosEisley.config[:bot_access_token]}"}
+      r = Neko::HTTP.get(url, params, head)
+      if r[:code] != 200
+        l.warn("#{m} HTTP failed: #{r[:message]}")
+        return nil
+      end
+      begin
+        h = JSON.parse(r[:body], {symbolize_names: true})
+        if h[:ok]
+          return h
+        else
+          l.warn("#{m} Slack failed: #{h[:error]}")
+          l.debug("#{h[:response_metadata]}")
+          return nil
+        end
+      rescue
+        return {body: r[:body]}
+      end
+    end
+
     def self.post_to_slack(method, data, url = nil)
       l = MosEisley.logger
       url ||= BASE_URL + method
-      head = {authorization: "Bearer #{ENV['SLACK_BOT_ACCESS_TOKEN']}"}
+      head = {authorization: "Bearer #{MosEisley.config[:bot_access_token]}"}
       r = Neko::HTTP.post_json(url, data, head)
       if r[:code] != 200
         l.warn("post_to_slack HTTP failed: #{r[:message]}")

data/mos-eisley-lambda.gemspec

@@ -1,10 +1,10 @@
 Gem::Specification.new do |s|
   s.name          = 'mos-eisley-lambda'
-  s.version       = '0.4.1'
+  s.version       = '0.6.0'
   s.authors       = ['Ken J.']
   s.email         = ['kenjij@gmail.com']
   s.summary       = %q{Ruby based Slack bot framework, for AWS Lambda use}
-  s.description   = %q{Ruby based Slack bot framework, for AWS Lambda use. Also provides helpers to analyze/build messages. Event based utilizing SQS.}
+  s.description   = %q{Ruby based Slack bot framework, for AWS Lambda; event queue based. Also provides Block Kit helper.}
   s.homepage      = 'https://github.com/kenjij/mos-eisley-lambda'
   s.license       = 'MIT'
 

metadata

@@ -1,17 +1,17 @@
 --- !ruby/object:Gem::Specification
 name: mos-eisley-lambda
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.6.0
 platform: ruby
 authors:
 - Ken J.
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-07-27 00:00:00.000000000 Z
+date: 2022-02-24 00:00:00.000000000 Z
 dependencies: []
-description: Ruby based Slack bot framework, for AWS Lambda use. Also provides helpers
-  to analyze/build messages. Event based utilizing SQS.
+description: Ruby based Slack bot framework, for AWS Lambda; event queue based. Also
+  provides Block Kit helper.
 email:
 - kenjij@gmail.com
 executables: []
@@ -49,7 +49,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
+rubygems_version: 3.1.4
 signing_key:
 specification_version: 4
 summary: Ruby based Slack bot framework, for AWS Lambda use