def test_connect_to_new_endpoint(self):
client = SocketModeClient(
app_token="xapp-A111-222-xyz",
web_client=self.web_client,
)
client.connect_to_new_endpoint()
self.assertFalse(client.is_connected())
def process(client: SocketModeClient, req: SocketModeRequest):
if req.type == "events_api":
response = SocketModeResponse(envelope_id=req.envelope_id)
client.send_socket_mode_response(response)
client.web_client.reactions_add(
name="eyes",
channel=req.payload["event"]["channel"],
timestamp=req.payload["event"]["ts"],
)
class SlackHelper:
def __init__(self, bot_token, app_token, channel):
self.bot_token = bot_token
self.app_token = app_token
self.channel = channel
self.message_queue = Queue()
self.last_connect_try: Optional[float] = None
print("Initializing SlackHelper")
self.socket_client = SocketModeClient(
app_token=self.app_token,
web_client=WebClient(token=self.bot_token))
self.socket_client.socket_mode_request_listeners.append(
lambda client, req: self._process_event(client, req))
self.check_connected()
print("Finished initializing SlackHelper")
def __del__(self):
self.socket_client.close()
def check_connected(self):
if not self.socket_client.is_connected():
now = time.time()
if self.last_connect_try is not None and self.last_connect_try + 10 > now:
return # We've tried in the last 10 seconds
print("Going to try to connect")
try:
self.socket_client.connect()
print("Connected")
except URLError:
print("Could not connect")
self.last_connect_try = now
def _process_event(self, client: SocketModeClient, req: SocketModeRequest):
if req.type == "events_api":
# Acknowledge the request anyway
response = SocketModeResponse(envelope_id=req.envelope_id)
client.send_socket_mode_response(response)
# Add a reaction to the message if it's a new message
message = req.payload["event"]
if message["type"] == "message" and message.get("subtype") is None:
self.message_queue.put(message)
# This doesn't work for some reason
# print(client.web_client.reactions_add(
# name="eyes",
# channel=message["channel"],
# timestamp=message["ts"],
# ))
def new_messages(self) -> list:
self.check_connected() # We don't really care if this blocks
messages = []
while not self.message_queue.empty():
messages.append(self.message_queue.get())
return messages
def _process_event(self, client: SocketModeClient, req: SocketModeRequest):
if req.type == "events_api":
# Acknowledge the request anyway
response = SocketModeResponse(envelope_id=req.envelope_id)
client.send_socket_mode_response(response)
# Add a reaction to the message if it's a new message
message = req.payload["event"]
if message["type"] == "message" and message.get("subtype") is None:
self.message_queue.put(message)
def test_issue_new_wss_url(self):
client = SocketModeClient(
app_token="xapp-A111-222-xyz",
web_client=self.web_client,
)
url = client.issue_new_wss_url()
self.assertTrue(url.startswith("wss://"))
legacy_client = LegacyWebClient(
token="xoxb-api_test", base_url="http://localhost:8888"
)
response = legacy_client.apps_connections_open(app_token="xapp-A111-222-xyz")
self.assertIsNotNone(response["url"])
def process(self, client: SocketModeClient, req: SocketModeRequest):
if req.type != "events_api":
return
# Acknowledge the request anyway
response = SocketModeResponse(envelope_id=req.envelope_id)
client.send_socket_mode_response(response)
if (req.payload["event"]["type"] == "message"
or req.payload["event"]["type"] == "app_mention"
) and req.payload["event"].get("subtype") is None:
with self.app.app_context():
bot.run_action(req.payload, req.payload["event"]["channel"])
def test_enqueue_message(self):
client = SocketModeClient(
app_token="xapp-A111-222-xyz",
web_client=self.web_client,
on_message_listeners=[lambda message: None],
)
client.enqueue_message("hello")
client.process_message()
client.enqueue_message(
"""{"type":"hello","num_connections":1,"debug_info":{"host":"applink-111-222","build_number":10,"approximate_connection_time":18060},"connection_info":{"app_id":"A111"}}"""
)
client.process_message()
def process(client: SocketModeClient, req: SocketModeRequest):
if req.type == "events_api":
# Acknowledge the request anyway
response = SocketModeResponse(envelope_id=req.envelope_id)
client.send_socket_mode_response(response)
# Add a reaction to the message if it's a new message
if req.payload["event"]["type"] == "message" \
and req.payload["event"].get("subtype") is None:
client.web_client.reactions_add(
name="eyes",
channel=req.payload["event"]["channel"],
timestamp=req.payload["event"]["ts"],
)
def __init__(self, bot_token, app_token, channel):
self.bot_token = bot_token
self.app_token = app_token
self.channel = channel
self.message_queue = Queue()
self.last_connect_try: Optional[float] = None
print("Initializing SlackHelper")
self.socket_client = SocketModeClient(
app_token=self.app_token,
web_client=WebClient(token=self.bot_token))
self.socket_client.socket_mode_request_listeners.append(
lambda client, req: self._process_event(client, req))
self.check_connected()
print("Finished initializing SlackHelper")
def main():
parser = argparse.ArgumentParser(
description='Simple Bugzilla triage helper bot for Slack.')
parser.add_argument('-c',
'--config',
metavar='FILE',
default='~/.triagebot',
help='config file')
parser.add_argument('-d',
'--database',
metavar='FILE',
default='~/.triagebot-db',
help='database file')
args = parser.parse_args()
# Read config
with open(os.path.expanduser(args.config)) as fh:
config = DottedDict(yaml.safe_load(fh))
config.database = os.path.expanduser(args.database)
env_map = (('TRIAGEBOT_SLACK_APP_TOKEN',
'slack-app-token'), ('TRIAGEBOT_SLACK_TOKEN', 'slack-token'),
('TRIAGEBOT_BUGZILLA_KEY', 'bugzilla-key'))
for env, config_key in env_map:
v = os.environ.get(env)
if v:
setattr(config, config_key, v)
# Connect to services
client = WebClient(token=config.slack_token)
# store our user ID
config.bot_id = client.auth_test()['user_id']
bzapi = bugzilla.Bugzilla(config.bugzilla,
api_key=config.bugzilla_key,
force_rest=True)
if not bzapi.logged_in:
raise Exception('Did not authenticate')
db = Database(config)
# Start socket-mode listener in the background
socket_client = SocketModeClient(
app_token=config.slack_app_token,
web_client=WebClient(token=config.slack_token))
socket_client.socket_mode_request_listeners.append(
lambda socket_client, req: process_event(config, socket_client, req))
socket_client.connect()
# Run scheduler
Scheduler(config, client, bzapi, db).run()
def __init__(self, setting):
xoxb_token = setting['slack']['xoxb_token']
xapp_token = setting['slack']['xapp_token']
self._web_client = WebClient(token=xoxb_token)
self._sm_client = SocketModeClient(app_token=xapp_token,
web_client=self._web_client)
self.plugins_setting = setting['plugins']
self.plugins_path = setting['bot']['plugins_dir']
self.plugin_modules = []
self.plugin_classes = []
self.plugin_instances = []
self._self = None
self._team = None
self._users_list = {} # [ 'id' ] => SlackUser
self._channels_list = {}
self._data = None
def test_client_with_ssl(self):
self.web_client.ssl = sentinel.ssl_context
client = SocketModeClient(
app_token="xapp-A111-222-xyz",
web_client=self.web_client,
)
self.assertEqual(client.web_client.ssl, sentinel.ssl_context)
def test_buffer_size_validation(self):
try:
SocketModeClient(app_token="xapp-A111-222-xyz",
receive_buffer_size=1)
self.fail("SlackClientConfigurationError is expected here")
except SlackClientConfigurationError:
pass
def main():
parser = argparse.ArgumentParser(
description='Slack bot to send periodic 1:1 invitations.')
parser.add_argument('-c',
'--config',
metavar='FILE',
default='~/.11bot',
help='config file')
parser.add_argument('-d',
'--database',
metavar='FILE',
default='~/.11bot-db',
help='database file')
args = parser.parse_args()
# Self-test
Grouping.selftest()
# Read config
with open(os.path.expanduser(args.config)) as fh:
config = DottedDict(yaml.safe_load(fh))
config.database = os.path.expanduser(args.database)
env_map = (
('ELEVENBOT_APP_TOKEN', 'app-token'),
('ELEVENBOT_TOKEN', 'token'),
)
for env, config_key in env_map:
v = os.environ.get(env)
if v:
setattr(config, config_key, v)
# Connect to services
client = WebClient(token=config.token)
# store our user ID
config.bot_id = client.auth_test()['user_id']
db = Database(config)
# Start socket-mode listener in the background
socket_client = SocketModeClient(app_token=config.app_token,
web_client=WebClient(token=config.token))
socket_client.socket_mode_request_listeners.append(
lambda socket_client, req: process_event(config, socket_client, req))
socket_client.connect()
# Run scheduler
Scheduler(config, client, db).run()
def on_socket_mode_request(self, client: SocketModeClient,
req: SocketModeRequest):
if req.type == "events_api":
# Acknowledge the request anyway
response = SocketModeResponse(envelope_id=req.envelope_id)
client.send_socket_mode_response(response)
if req.payload['event']['type'] == 'open':
self.on_open(req.payload['event'])
elif req.payload['event']['type'] == 'message':
self.on_message(req.payload['event'])
elif req.payload['event']['type'] == 'channel_joined':
self.on_channel_joined(req.payload['event'])
elif req.payload['event']['type'] == 'channel_left':
self.on_channel_left(req.payload['event'])
elif req.payload['event']['type'] == 'member_joined_channel':
self.on_member_joined_channel(req.payload['event'])
elif req.payload['event']['type'] == 'member_left_channel':
self.on_member_left_channel(req.payload['event'])
def test_init_close(self):
on_message_listeners = [lambda message: None]
client = SocketModeClient(app_token="xapp-A111-222-xyz",
on_message_listeners=on_message_listeners)
try:
self.assertIsNotNone(client)
self.assertFalse(client.is_connected())
self.assertIsNone(client.session_id()) # not yet connected
finally:
client.close()
def test_send_message_while_disconnection(self):
if is_ci_unstable_test_skip_enabled():
return
t = Thread(target=start_socket_mode_server(self, 3011))
t.daemon = True
t.start()
time.sleep(2) # wait for the server
try:
self.reset_sever_state()
client = SocketModeClient(
app_token="xapp-A111-222-xyz",
web_client=self.web_client,
auto_reconnect_enabled=False,
trace_enabled=True,
)
client.wss_uri = "ws://0.0.0.0:3011/link"
client.connect()
time.sleep(1) # wait for the connection
client.send_message("foo")
client.disconnect()
time.sleep(1) # wait for the connection
try:
client.send_message("foo")
self.fail("SlackClientNotConnectedError is expected here")
except SlackClientNotConnectedError as _:
pass
client.connect()
time.sleep(1) # wait for the connection
client.send_message("foo")
finally:
client.close()
self.server.stop()
self.server.close()
import os
from slack_sdk.web import WebClient
from slack_sdk.socket_mode import SocketModeClient
bot_token = 'xoxb-878537608886-1694511546722-izEl5QrcB353Fk5tEQ6RgQjQ'
app_token = 'xapp-1-A01LT4177KK-1691430861685-afad308087194061b8dcd5c4378f18e084fcfd462562a6467a92bd2f9e787c31'
# Initialize SocketModeClient with an app-level token + WebClient
client = SocketModeClient(
# This app-level token will be used only for establishing a connection
app_token=app_token, # xapp-A111-222-xyz
# You will be using this WebClient for performing Web API calls in listeners
web_client=WebClient(token=bot_token) # xoxb-111-222-xyz
)
from slack_sdk.socket_mode.response import SocketModeResponse
from slack_sdk.socket_mode.request import SocketModeRequest
def process(client: SocketModeClient, req: SocketModeRequest):
if req.type == "events_api":
# Acknowledge the request anyway
response = SocketModeResponse(envelope_id=req.envelope_id)
client.send_socket_mode_response(response)
# Add a reaction to the message if it's a new message
if req.payload["event"]["type"] == "message" \
and req.payload["event"].get("subtype") is None:
client.web_client.reactions_add(
name="eyes",
def test_interactions(self):
if is_ci_unstable_test_skip_enabled():
return
t = Thread(target=start_socket_mode_server(self, 3011))
t.daemon = True
t.start()
time.sleep(2) # wait for the server
try:
buffer_size_list = [1024, 9000, 35, 49] + list(
[randint(16, 128) for _ in range(10)])
for buffer_size in buffer_size_list:
self.reset_sever_state()
received_messages = []
received_socket_mode_requests = []
def message_handler(message):
self.logger.info(f"Raw Message: {message}")
time.sleep(randint(50, 200) / 1000)
received_messages.append(message)
def socket_mode_request_handler(client: BaseSocketModeClient,
request: SocketModeRequest):
self.logger.info(f"Socket Mode Request: {request}")
time.sleep(randint(50, 200) / 1000)
received_socket_mode_requests.append(request)
self.logger.info(
f"Started testing with buffer size: {buffer_size}")
client = SocketModeClient(
app_token="xapp-A111-222-xyz",
web_client=self.web_client,
on_message_listeners=[message_handler],
receive_buffer_size=buffer_size,
auto_reconnect_enabled=False,
trace_enabled=True,
)
try:
client.socket_mode_request_listeners.append(
socket_mode_request_handler)
client.wss_uri = "ws://0.0.0.0:3011/link"
client.connect()
self.assertTrue(client.is_connected())
time.sleep(2) # wait for the message receiver
repeat = 2
for _ in range(repeat):
client.send_message("foo")
client.send_message("bar")
client.send_message("baz")
self.assertTrue(client.is_connected())
expected = (socket_mode_envelopes +
[socket_mode_hello_message] +
["foo", "bar", "baz"] * repeat)
expected.sort()
count = 0
while count < 5 and len(received_messages) < len(expected):
time.sleep(0.1)
self.logger.debug(
f"Received messages: {len(received_messages)}")
count += 0.1
received_messages.sort()
self.assertEqual(len(received_messages), len(expected))
self.assertEqual(received_messages, expected)
self.assertEqual(len(socket_mode_envelopes),
len(received_socket_mode_requests))
finally:
pass
# client.close()
self.logger.info(f"Passed with buffer size: {buffer_size}")
finally:
client.close()
self.server.stop()
self.server.close()
self.logger.info(f"Passed with buffer size: {buffer_size_list}")
class SlackBot():
def __init__(self, setting):
xoxb_token = setting['slack']['xoxb_token']
xapp_token = setting['slack']['xapp_token']
self._web_client = WebClient(token=xoxb_token)
self._sm_client = SocketModeClient(app_token=xapp_token,
web_client=self._web_client)
self.plugins_setting = setting['plugins']
self.plugins_path = setting['bot']['plugins_dir']
self.plugin_modules = []
self.plugin_classes = []
self.plugin_instances = []
self._self = None
self._team = None
self._users_list = {} # [ 'id' ] => SlackUser
self._channels_list = {}
self._data = None
def _get_rtm_client(self):
return self._rtm_client
def _set_rtm_client(self, rc):
self._rtm_client = rc
rtm_client = property(_get_rtm_client, _set_rtm_client)
def _get_web_client(self):
return self._web_client
def _set_web_client(self, rc):
self._web_client = rc
web_client = property(_get_web_client, _set_web_client)
# plugin loader
def load_plugins(self):
for ps in self.plugins_setting:
mod = importlib.import_module(ps['module'])
klass_name = ps['name']
klass = getattr(mod, klass_name)
self.plugin_classes.append(klass)
self.plugin_instances.append(klass(self, ps))
def load_plugins_filename_based(self):
plugins_dir = os.listdir(self.plugins_path)
# current_dir = os.path.dirname( os.path.abspath( __file__ ) )
for filename in plugins_dir:
if filename.endswith('.py'):
if filename == "__init__.py":
continue
klass_name = os.path.splitext(filename)[0]
klass_name = klass_name[0].upper() + klass_name[1:]
modulePath = self.plugins_path + '/' + filename
cpath = os.path.splitext(modulePath)[0].replace(
os.path.sep, '.')
try:
mod = importlib.import_module(cpath)
self.plugin_modules.append(mod)
klass = getattr(mod, klass_name)
self.plugin_classes.append(klass)
self.plugin_instances.append(klass(self, klass_name))
except ModuleNotFoundError:
print('Module not found')
except AttributeError:
print('Method not found')
def unload_plugins(self):
for ins in self.plugin_instances:
del (ins)
self.plugin_instances = []
for cls in self.plugin_classes:
del (cls)
self.plugin_classes = []
for mod in self.plugin_modules:
del (mod)
self.plugin_modules = []
def reload_plugins(self):
self.unload_plugins()
self.load_plugins()
# bot information
def self_user(self):
return self._self
def self_id(self):
u = self.self_user()
return u.id
def self_name(self):
return self.self_user().name
def team_info(self):
return self._team
def team_id(self):
return self.team_info()['id']
def team_name(self):
return self.team_info()['name']
def update_self_user(self, user):
self._self = user
def update_team_info(self, info):
self._team = info
def update_users_list(self, users):
for user in users:
self._users_list[user['id']] = SlackUser(user)
def update_groups_list(self, groups):
for group in groups:
self._channels_list[group['id']] = SlackGroup(group)
def update_ims_list(self, ims):
for im in ims:
self._channels_list[im['id']] = SlackIM(im)
def update_channels_list(self, channels):
for channel in channels:
self._channels_list[channel['id']] = SlackChannel(channel)
def resolve_channel_id_from_name(self, name):
pass
# plugin commands
def send_message(self, channel, message, attachments_json=None):
self._web_client.chat_postMessage(channel=channel.id,
text=message,
attachments=attachments_json)
def send_mention_message(self,
channel,
user,
message,
attachments_json=None):
mention_message = "<@" + user.id + "> " + message
self._web_client.chat_postMessage(channel=channel.id,
text=mention_message,
attachments=attachments_json)
def send_kick(self, channel, user):
self._web_client.channels_kick(channel=channel.id, user=user.id)
# plugin events
def on_server_connect(self):
for plugin in self.plugin_instances:
plugin.on_server_connect()
def process_message(self, data):
channel = self._channels_list[data['channel']]
user = self._users_list[data['user']]
text = data['text']
# if user.id != self.self_id(): # ignore own message
for plugin in self.plugin_instances:
plugin.on_message(channel, user, text)
def process_message_changed(self, data):
channel = self._channels_list[data['channel']]
user = self._users_list[data['message']['user']]
text = data['message']['text']
prev_user = data['previous_message']['user']
prev_text = data['previous_message']['text']
# if user.id != self.self_id(): # ignore own message
for plugin in self.plugin_instances:
plugin.on_message_changed(channel, user, text, prev_user,
prev_text)
def on_message(self, payload):
data = payload
if 'bot_id' in data:
return
if 'subtype' in data:
if data['subtype'] == 'message_changed':
self.process_message_changed(data)
else:
self.process_message(data)
def on_channel_joined(self, **payload):
data = payload
channel = data['channel']
self._channels_list[channel['id']] = SlackChannel(channel)
def on_channel_left(self, **payload):
data = payload
del self._channels_list[data['channel']]
# TODO: It should be not delete the channel and It must be update the status such as a 'is_member'.
# self._channels_list[ data[ 'channel' ] ].is_member = False
def on_member_joined_channel(self, **payload):
data = payload
channel = self._channels_list[data['channel']]
user = self._users_list[data['user']]
for plugin in self.plugin_instances:
plugin.on_joined(channel, user)
def on_member_left_channel(self, **payload):
data = payload
channel = self._channels_list[data['channel']]
user = self._users_list[data['user']]
for plugin in self.plugin_instances:
plugin.on_left(channel, user)
# process slack rtm
def on_socket_mode_request(self, client: SocketModeClient,
req: SocketModeRequest):
if req.type == "events_api":
# Acknowledge the request anyway
response = SocketModeResponse(envelope_id=req.envelope_id)
client.send_socket_mode_response(response)
if req.payload['event']['type'] == 'open':
self.on_open(req.payload['event'])
elif req.payload['event']['type'] == 'message':
self.on_message(req.payload['event'])
elif req.payload['event']['type'] == 'channel_joined':
self.on_channel_joined(req.payload['event'])
elif req.payload['event']['type'] == 'channel_left':
self.on_channel_left(req.payload['event'])
elif req.payload['event']['type'] == 'member_joined_channel':
self.on_member_joined_channel(req.payload['event'])
elif req.payload['event']['type'] == 'member_left_channel':
self.on_member_left_channel(req.payload['event'])
def start(self):
self._sm_client.socket_mode_request_listeners.append(
self.on_socket_mode_request)
self._sm_client.connect()
response = self._web_client.users_list()
self.update_users_list(response['members'])
response = self._web_client.conversations_list()
self.update_channels_list(response['channels'])
response = self._web_client.team_info()
self.update_team_info(response['team'])
response = self._web_client.auth_test()
self_id = response['user_id']
self.update_self_user(self._users_list[self_id])
self.load_plugins()
self.on_server_connect()
from threading import Event
Event().wait()
logging.basicConfig(
level=logging.DEBUG,
format="%(asctime)s.%(msecs)03d %(levelname)s %(pathname)s (%(lineno)s): %(message)s",
datefmt="%Y-%m-%d %H:%M:%S",
)
import os
from threading import Event
from slack_sdk.web import WebClient
from slack_sdk.socket_mode.response import SocketModeResponse
from slack_sdk.socket_mode.request import SocketModeRequest
from slack_sdk.socket_mode import SocketModeClient
client = SocketModeClient(
app_token=os.environ.get("SLACK_SDK_TEST_SOCKET_MODE_APP_TOKEN"),
web_client=WebClient(token=os.environ.get("SLACK_SDK_TEST_SOCKET_MODE_BOT_TOKEN")),
trace_enabled=True,
all_message_trace_enabled=True,
)
if __name__ == "__main__":
def process(client: SocketModeClient, req: SocketModeRequest):
if req.type == "events_api":
response = SocketModeResponse(envelope_id=req.envelope_id)
client.send_socket_mode_response(response)
client.web_client.reactions_add(
name="eyes",
channel=req.payload["event"]["channel"],
timestamp=req.payload["event"]["ts"],
)
from threading import Event
from slack_sdk.web import WebClient
from slack_sdk.socket_mode.response import SocketModeResponse
from slack_sdk.socket_mode.request import SocketModeRequest
from slack_sdk.socket_mode import SocketModeClient
# https://github.com/seratch/my-proxy-server
# go build && ./my-proxy-sever -a
proxy_url = "http://*****:*****@localhost:9000"
client = SocketModeClient(
app_token=os.environ.get("SLACK_SDK_TEST_SOCKET_MODE_APP_TOKEN"),
web_client=WebClient(
token=os.environ.get("SLACK_SDK_TEST_SOCKET_MODE_BOT_TOKEN"),
proxy=proxy_url,
),
proxy=proxy_url,
# proxy="http://localhost:9000",
# proxy_headers={"Proxy-Authorization": "Basic dXNlcjpwYXNz"},
trace_enabled=True,
all_message_trace_enabled=True,
)
if __name__ == "__main__":
def process(client: SocketModeClient, req: SocketModeRequest):
if req.type == "events_api":
response = SocketModeResponse(envelope_id=req.envelope_id)
client.send_socket_mode_response(response)
client.web_client.reactions_add(
name="eyes",
channel=req.payload["event"]["channel"],
