mos-eisley-lambda 0.5.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7f47807ff37bc9efd5d01b8745fc9cfb36796876b03dc50cf5b1f5504d75cfb5
-  data.tar.gz: a9fef8a47a8f9a7c2a7ca36122f047ecfef781f019e40bbcbf5f7eb6d423861d
+  metadata.gz: 1c7bb756dd5b280ff9fb49dc6d7a52776d1e86eea6d0295585317d8bcf36c079
+  data.tar.gz: 3747893c11d3255af90bc925700020ce8b4be4b77c2fd29c9de009c3e436bb8e
 SHA512:
-  metadata.gz: 19c4a11da675e07f0cd1fd405dbdd1013be87086ad3f93afad9c85f64de9bbc6620beb4a6ff441892ca1590b0e9e3977bfbb2cc343e82b3868ec9bd7a804ec42
-  data.tar.gz: 4c0421f4ad6e9655845c11fac9e981e2cb7f44856744a839df504f314947afdc888e475e801aa30572815495fba9da879fb4dc867ece6e52ab1b9fc002dcb462
+  metadata.gz: 12d43754b4fafe23f9b83997b014a3884fecda7d269f65e10ef33799bcf7f9dce20748196252757b2cffe2cb3b3e6a9f82ced3cab5aa32b6d90ed2c6a2bcb2ca
+  data.tar.gz: 88801d7784949fdb5cedb9ff44cfcac774447ade46c844f9c23ff59b83a42e8615d1c989928520b680a9d4022cec81037fc958fa8e426c3caeca52360c4dbae0

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,12 @@ 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_HANDLERS_DIR`: _optional_, if other than `./handlers` 
+- `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.
 
@@ -32,12 +33,8 @@ require 'mos-eisley-lambda'
 # Or, you can just copy the `lib` directory to your Lambda and...
 # require_relative './lib/mos-eisley-lambda'
 
-MosEisley::Handler.import
-# Or, if you store your handlers in a non-default location, dictate by...
-# MosEisley::Handler.import_from_path('./my-handlers')
-
 def lambda_handler(event:, context:)
-  MosEisley::lambda_event(event)
+  MosEisley::lambda_event(event, context)
 end
 ```
 
@@ -52,21 +49,26 @@ Create a Slack app and configure the following.
 
 ### Handlers
 
-Create your own Mos Eisley handlers as blocks and register them. By default, store these Ruby files in the `handlers` directory.
+Create your own Mos Eisley handlers as blocks and register them. By default, store these Ruby files in the `handlers` directory. Add handlers by passing a block to `MosEisley::Handler.add()` for the types below.
+
+```ruby
+:action
+:command_response
+:command
+:event
+:menu
+:nonslack
+```
 
-`ME::Handler.command_acks` holds `[Hash<String, Hash>]` which are Slack command keyword and response pair. The response is sent as-is back to Slack as an [immediate response](https://api.slack.com/interactivity/slash-commands#responding_immediate_response).
+`:command_response` types are Slack command keyword and response pair. The response is sent as-is back to Slack as an [immediate response](https://api.slack.com/interactivity/slash-commands#responding_immediate_response). `ME` is an alias to `MosEisley`.
 
 ```ruby
-ME::Handler.command_acks.merge!({
-  '/command' => {
-    response_type: 'in_channel',
-    text: '_Working on it…_',
-  },
-  '/secret' => {
-    response_type: 'ephemeral',
-    text: '_Just for you…_',
-  },
-})
+ME::Handler.add(:command_response, '/sample') do |event, myself|
+  {
+    response_type: "in_channel",
+    text: "_Working on `#{event[:command]}`..._",
+  }
+end
 ```
 
 Add handlers to process the Slack event.
@@ -85,46 +87,55 @@ ME::Handler.add(:command, 'A Slack command') do |event, myself|
 end
 ```
 
-## Protocols
-
-### SQS
+If your function receives non-Slack events, you can add handlers for that as well.
 
-- 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
+```ruby
+ME::Handler.add(:nonslack, 'A CloudWatch event') do |event, myself|
+  next unless event['source'] == 'aws.events'
+  myself.stop
+  channel = 'C123SLCK'
+  txt = 'Shceduled event was received.'
+  ME::SlackWeb.chat_postmessage(channel: channel, text: txt)
+end
+```
 
 ### Helpers
 
-- `ME::S3PO` – collection of helpers to analyze/create Slack messages.
-- `ME::SlackWeb` – methods for sending payloads to Slack Web API calls.
+- `MosEisley::S3PO` – collection of helpers to analyze/create Slack messages.
+- `MosEisley::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. 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
-
-### Event Processing
-
-1. Slack event is recieved by SQS trigger
-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
+To an incoming Slack event, Mos Eisley will quickly respond with a blank HTTP 200. This is to keep [Slack's 3-second rule](https://api.slack.com/apis/connections/events-api#the-events-api__responding-to-events). To do this, handlers are not called yet, but the Slack event is passed on to a recursive asynchronous invoke and then the handlers are called.
+
+The exception is when the incoming Slack event is for a slash command. You can define `:command_response` handlers for the purpose of generating a simple response message, but nothing more.
+
+```mermaid
+sequenceDiagram
+  participant S as Slack
+  participant L as Lambda MosEisley
+  S->>+L: Slack event via API Gateway
+  alt Slash command
+    L-->>S: Response message
+    Note left of L: If a response handler is defined
+  else All other events
+    L-->>-S: HTTP 200 (blank)
+  end
+  L->>+L: Slack event
+  Note right of L: Handlers are called
+  opt
+  L-->>-S: E.g., chat.postMessage
+  end
+```
 
-<!-- ### 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
 

data/handlers/sample.rb

@@ -0,0 +1,55 @@
+##
+## Sample handlers for Mos Eisley
+##
+ME::Handler.add(:event, 'DEBUG') do |event, myself|
+  l = ME.logger
+  l.debug("[Slack-Event]\n#{event}")
+end
+
+ME::Handler.add(:event, 'Request - diagnostics') do |event, myself|
+  se = event[:event]
+  next unless se[:type] == 'app_mention' && /\bdiag/i =~ se[:text]
+  myself.stop
+  l = ME.logger
+  bk = ME::S3PO::BlockKit
+  fs = []
+  ME.config.info[:handlers].each{ |k, v| fs << "*#{k}*\n#{v}" }
+  blks = [
+    bk.sec_text('Handler Count'),
+    bk.sec_fields(fs),
+  ]
+  fs = []
+  ME.config.info[:versions].each{ |k, v| fs << "*#{k}*\n#{v}" }
+  blks << bk.sec_text('Software Versions')
+  blks << bk.sec_fields(fs)
+  ME::SlackWeb.chat_postmessage(channel: se[:channel], text: "Diagnostics", blocks: blks)
+end
+
+ME::Handler.add(:nonslack, 'DEBUG') do |event, myself|
+  l = ME.logger
+  l.debug("[Non-Slack]\n#{event}")
+end
+
+ME::Handler.add(:command_response, '/sample') do |event, myself|
+  {
+    response_type: "in_channel",
+    text: "_Working on `#{event[:command]}`..._",
+  }
+end
+
+ME::Handler.add(:command, 'DEBUG') do |event, myself|
+  l = ME.logger
+  l.debug("[Slack-Command]\n#{event}")
+end
+
+ME::Handler.add(:command, 'Request - /sample') do |event, myself|
+  next unless event[:command] == '/sample'
+  myself.stop
+  bk = ME::S3PO::BlockKit
+  t = "`S A M P L E` I did it!"
+  blks = [
+    bk.sec_text(t),
+    bk.con_text('By: Mos Eisley sampler'),
+  ]
+  ME::SlackWeb.chat_postmessage(channel: event[:command], text: t, blocks: blks)
+end

data/lib/handler.rb

@@ -19,23 +19,27 @@ 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: [],
+        nonslack: [],
       }
-      @handlers[type] << MosEisley::Handler.new(type, name, &block)
-      MosEisley.logger.debug("Added #{type} handler: #{@handlers[type].last}")
-    end
-
-    # Example: {'/command' => {response_type: 'ephemeral', text: nil}}
-    # @return [Hash<String, Hash>] commands to acknowledge
-    def self.command_acks
-      @command_acks ||= {}
+      h = MosEisley::Handler.new(type, name, &block)
+      if type == :command_response
+        @handlers[type][name] = h 
+      else
+        @handlers[type] << h
+      end
+      MosEisley.logger.debug("Added handler: #{h}")
     end
 
     # @return [Hash<Symbol, Array>] containing all the handlers
@@ -48,14 +52,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
 
@@ -89,7 +101,7 @@ module MosEisley
     end
 
     def to_s
-      "#<#{self.class}:#{self.object_id.to_s(16)}(#{name})>"
+      "#<#{self.class}:#{self.object_id.to_s(16)}(#{type}:#{name})>"
     end
   end
 end

data/lib/mos-eisley-lambda.rb

@@ -2,52 +2,111 @@ require_relative './logger'
 require_relative './slack'
 require_relative './s3po/s3po'
 require_relative './handler'
-require 'aws-sdk-sqs'
+require_relative './version'
+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']
-      MosEisley.logger.info('API GW event')
-      return apigw_event(event)
+  def self.config(context = nil, data = nil)
+    if data
+      unless @config
+        @config = Config.new(context, data)
+        MosEisley.logger.info('Config loaded')
+      else
+        MosEisley.logger.warn('Ignored, already configured')
+      end
     end
-    # Internal event (via SQS)
-    if event.dig('Records',0,'eventSource') == 'aws:sqs'
-      MosEisley.logger.info('SQS event')
-      return sqs_event(event)
+    @config
+  end
+
+  def self.lambda_event(event, context)
+    raise 'Pre-flight check failed!' unless preflightcheck(context)
+    case
+    when event['initializeOnly']
+      MosEisley.logger.info('Dry run, initializing only')
+      return
+    when event['routeKey']
+      # Inbound Slack event (via API GW)
+      MosEisley.logger.info('API GW 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)
+    when event.dig('Records',0,'eventSource').start_with?('MosEisley:Slack_message:')
+      # Outbound Slack messaging request (via invoke)
+      MosEisley.logger.info('Messaging event')
+      MosEisley.logger.debug("#{event}")
+      return # TODO implement
+    else
+      # Non-Slack event
+      MosEisley.logger.info('Non-Slack event')
+      return nonslack_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}")
+  def self.preflightcheck(context)
+    if config
+      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_HANDLERS_DIR',
       'MOSEISLEY_LOG_LEVEL',
+      'SLACK_LOG_CHANNEL_ID',
+    ]
+    config_required = [
+      :signing_secret,
+      :bot_access_token,
     ]
-    env_required.each do |e|
-      if ENV[e].nil?
-        MosEisley.logger.error("Missing environment variable: #{e}")
+    l = ENV['MOSEISLEY_LOG_LEVEL']
+    if String === l && ['DEBUG', 'INFO', 'WARN', 'ERROR'].include?(l.upcase)
+      MosEisley.logger.level = eval("Logger::#{l.upcase}")
+    end
+    if dir = ENV['MOSEISLEY_HANDLERS_DIR']
+      MosEisley::Handler.import_from_path(dir)
+    else
+      MosEisley::Handler.import
+    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,
+        }
+        c = {}
+        ssm.get_parameters_by_path(rparams).parameters.each do |prm|
+          k = prm[:name].split('/').last.to_sym
+          c[k] = prm[:value]
+          config_required.delete(k)
+        end
+        unless config_required.empty?
+          t = "Missing config values: #{config_required.join(', ')}"
+          MosEisley.logger.error(t)
+          return false
+        end
+        config(context, c)
+      end
     end
     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 +116,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 +138,90 @@ 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],
+        }
+      ]
+    }
+    lc = Aws::Lambda::Client.new
+    params = {
+      function_name: context.function_name,
+      invocation_type: 'Event',
+      payload: JSON.fast_generate(pl),
     }
-    SQS.send_message(m)
-    s = m[:message_body].length
-    MosEisley.logger.debug("Sent message to SQS with body size #{s}.")
-    return resp
+    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
+  end
+
+  def self.nonslack_event(event)
+    MosEisley::Handler.run(:nonslack, event)
+  end
+
+  class Config
+    attr_reader :context, :info, :timestamp
+    attr_reader :bot_access_token, :signing_secret
+
+    def initialize(context, data)
+      data.each do |k, v|
+        instance_variable_set("@#{k}", v)
+      end
+      @context = context
+      @info = {
+        handlers: {
+          action: MosEisley.handlers[:action].length,
+          command_response: MosEisley.handlers[:command_response].length,
+          command: MosEisley.handlers[:command].length,
+          event: MosEisley.handlers[:event].length,
+        },
+        versions: {
+          mos_eisley: MosEisley::VERSION,
+          neko_http: Neko::HTTP::VERSION,
+          s3po: MosEisley::S3PO::VERSION,
+          s3po_blockkit: MosEisley::S3PO::BlockKit::VERSION,
+        },
+      }
+      @timestamp = Time.now
+    end
+
+    def arn
+      context.invoked_function_arn
+    end
+
+    def remaining_time
+      context.get_remaining_time_in_millis
     end
-    return 0
   end
 end

data/lib/neko-http.rb

@@ -1,7 +1,6 @@
+#
 # NekoHTTP - Pure Ruby HTTP client using net/http
-# 
-# v.20200629
-
+#
 require 'json'
 require 'logger'
 require 'net/http'
@@ -17,6 +16,8 @@ module Neko
   end
 
   class HTTP
+    VERSION = '20220224'.freeze
+
     METHOD_HTTP_CLASS = {
       get: Net::HTTP::Get,
       put: Net::HTTP::Put,
@@ -25,6 +26,11 @@ module Neko
       delete: Net::HTTP::Delete
     }
 
+    # Simple GET request
+    # @param url [String] full URL string
+    # @param params [Array, Hash] it will be converted to URL encoded query
+    # @param hdrs [Hash] HTTP headers
+    # @return [Hash] contains: :code, :headers, :body, :message
     def self.get(url, params, hdrs = nil)
       h = HTTP.new(url, hdrs)
       data = h.get(params: params)
@@ -32,6 +38,11 @@ module Neko
       return data
     end
 
+    # Send POST request with form data URL encoded body
+    # @param url [String] full URL string
+    # @param params [Array, Hash] it will be converted to URL encoded body
+    # @param hdrs [Hash] HTTP headers
+    # @return (see #self.get)
     def self.post_form(url, params, hdrs = nil)
       h = HTTP.new(url, hdrs)
       data = h.post(params: params)
@@ -43,7 +54,8 @@ module Neko
     # It will set the Content-Type to application/json.
     # @param url [String] full URL string
     # @param obj [Array, Hash, String] Array/Hash will be converted to JSON
-    # @param hdrs [Array, Hash, String] Array/Hash will be converted to JSON
+    # @param hdrs [Hash] HTTP headers
+    # @return (see #self.get)
     def self.post_json(url, obj, hdrs = {})
       hdrs['Content-Type'] = 'application/json'
       h = HTTP.new(url, hdrs)
@@ -63,6 +75,9 @@ module Neko
     attr_reader :init_uri, :http
     attr_accessor :logger, :headers
 
+    # Instance constructor for tailored use
+    # @param url [String] full URL string
+    # @param hdrs [Hash] HTTP headers
     def initialize(url, hdrs = nil)
       @logger = Neko.logger
       @init_uri = URI(url)

data/lib/s3po/blockkit.rb

@@ -1,6 +1,33 @@
+#
+# S3PO - Slack protocol droid in Mos Eisley
+#     ::BlockKit - Block Kit tools
+#
 module MosEisley
   module S3PO
     module BlockKit
+      VERSION = '20220224'.freeze
+
+      # @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
@@ -11,6 +38,16 @@ module MosEisley
         }
       end
 
+      # @param fields [Array<String>]
+      # @param type [Symbol] :plain | :emoji | :mrkdwn
+      # @return [Hash] Block Kit section object
+      def self.sec_fields(fields, type = :mrkdwn)
+        {
+          type: :section,
+          fields: fields.map{ |txt| text(txt, type) },
+        }
+      end
+
       # @param txt [String]
       # @param type [Symbol] :plain | :emoji | :mrkdwn
       # @return [Hash] Block Kit text object

data/lib/s3po/s3po.rb

@@ -1,9 +1,14 @@
+#
+# S3PO - Slack protocol droid in Mos Eisley
+#
 require 'json'
 require 'time'
 require_relative './blockkit'
 
 module MosEisley
   module S3PO
+    VERSION = '20210626'.freeze
+
     def self.parse_json(json)
       return JSON.parse(json, {symbolize_names: true})
     rescue => e

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.'}
@@ -120,33 +120,45 @@ module MosEisley
     def self.views_push(trigger_id:, view:)
     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)
-      users_send('info', {user: 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
-      users_send('list', params)
+      get_from_slack('users.list', params)
     end
 
     def self.users_lookupbyemail(email)
-      users_send('lookupByEmail', {email: email})
+      get_from_slack('users.lookupByEmail', {email: email})
     end
 
     def self.users_profile_get(user)
-      users_send('profile.get', {user: user})
+      get_from_slack('users.profile.get', {user: user})
+    end
+
+    def self.auth_test
+      post_to_slack('auth.test', '')
     end
 
-    def self.users_send(m, params)
+    private
+
+    def self.get_from_slack(m, params)
       l = MosEisley.logger
-      call = "users.#{m}"
-      url ||= BASE_URL + call
-      head = {authorization: "Bearer #{ENV['SLACK_BOT_ACCESS_TOKEN']}"}
+      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("#{call} HTTP failed: #{r[:message]}")
+        l.warn("#{m} HTTP failed: #{r[:message]}")
         return nil
       end
       begin
@@ -154,7 +166,7 @@ module MosEisley
         if h[:ok]
           return h
         else
-          l.warn("#{call} Slack failed: #{h[:error]}")
+          l.warn("#{m} Slack failed: #{h[:error]}")
           l.debug("#{h[:response_metadata]}")
           return nil
         end
@@ -163,16 +175,10 @@ module MosEisley
       end
     end
 
-    def self.auth_test
-      post_to_slack('auth.test', '')
-    end
-
-    private
-
     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/lib/version.rb

@@ -0,0 +1,3 @@
+module MosEisley
+  VERSION = '0.7.0'.freeze
+end

data/mos-eisley-lambda.gemspec

@@ -1,10 +1,12 @@
+require_relative './lib/version'
+
 Gem::Specification.new do |s|
   s.name          = 'mos-eisley-lambda'
-  s.version       = '0.5.0'
+  s.version       = MosEisley::VERSION
   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.5.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Ken J.
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-08-14 00:00:00.000000000 Z
+date: 2022-03-03 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: []
@@ -21,6 +21,7 @@ files:
 - LICENSE
 - Makefile
 - README.md
+- handlers/sample.rb
 - lib/handler.rb
 - lib/logger.rb
 - lib/mos-eisley-lambda.rb
@@ -28,6 +29,7 @@ files:
 - lib/s3po/blockkit.rb
 - lib/s3po/s3po.rb
 - lib/slack.rb
+- lib/version.rb
 - mos-eisley-lambda.gemspec
 - openapi3.yaml
 homepage: https://github.com/kenjij/mos-eisley-lambda
@@ -49,7 +51,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