def client(bot, client_type='bot'):
"""
Global Slack client.
"""
global _client
team_name = bot.team.name
if team_name not in _client:
_client[team_name] = {}
if bot.name not in _client[team_name]:
_client[team_name][bot.name] = {}
if bot.oauth_bot_token:
_client[team_name][bot.name]['bot'] = slackclient.SlackClient(
bot.oauth_bot_token
)
if bot.oauth_user_token:
_client[team_name][bot.name]['user'] = slackclient.SlackClient(
bot.oauth_user_token
)
if client_type == 'bot':
try:
return _client[team_name][bot.name]['bot']
except KeyError:
pass
elif client_type == 'user':
return _client[team_name][bot.name]['user']
def __init__(self, slack_token):
self.slack_token = slack_token
self.sc = slackclient.SlackClient(slack_token)
while not self.sc.rtm_connect():
logging.critical(
'Connection to slack failed, retrying in 5 minutes')
time.sleep(300)
self.sc = slackclient.SlackClient(slack_token)
def run():
# initialize slack client
jackbot_slack_client = slackclient.SlackClient(SLACK_TOKEN)
if jackbot_slack_client.rtm_connect():
print(SLACK_NAME + ' Initialized.')
while True:
try:
event_list = jackbot_slack_client.rtm_read()
except (TimeoutError, AttributeError, BrokenPipeError) as e:
print('Connection lost. Reconnecting. Reason: ' +
e.__class__.__name__)
event_list = []
jackbot_slack_client = slackclient.SlackClient(SLACK_TOKEN)
jackbot_slack_client.rtm_connect()
except Exception as e:
if e.__class__.__name__ == 'WebSocketConnectionClosedException':
print('Connection lost. Reconnecting. Reason: ' +
e.__class__.__name__)
event_list = []
jackbot_slack_client = slackclient.SlackClient(SLACK_TOKEN)
jackbot_slack_client.rtm_connect()
else:
raise
if len(event_list) > 0:
for event in event_list:
type = event.get('type')
# check if the event is a message
if type and type == 'message':
# get all the relevant parts of the event
text = event.get('text')
if text and isinstance(text, str):
user = event.get('user')
channel = event.get('channel')
# split the message into words
command_pieces = text.strip().split()
# check if first word is bot mention
if helper.is_command(command_pieces, user,
SLACK_ID, slack_mention):
# handle command options
print(text)
helper.handle_command(jackbot_slack_client,
command_pieces, text,
user, channel, commands)
elif helper.is_mention(command_pieces, user,
SLACK_ID, slack_mention):
# handle non-command mention
helper.handle_mention(jackbot_slack_client,
command_pieces, text,
user, channel)
time.sleep(SOCKET_DELAY)
else:
print('[!] Connection to Slack failed.')
def _notify_slack(token, request):
import os
import json
import traceback
import slackclient
try:
# token might be a file
token_file = os.path.expanduser(os.path.expandvars(token))
if os.path.isfile(token_file):
with open(token_file, "r") as f:
token = f.read().strip()
if "attachments" in request and not isinstance(request["attachments"],
six.string_types):
request["attachments"] = json.dumps([request["attachments"]])
sc = slackclient.SlackClient(token)
res = sc.api_call("chat.postMessage", **request)
if not res["ok"]:
logger.warning("unsuccessful Slack API call: {}".format(res))
except Exception as e:
t = traceback.format_exc()
logger.warning("could not send Slack notification: {}\n{}".format(
e, t))
def handle(self, *args, **kwargs):
"""Handle bot."""
del args, kwargs
ws_delay = 1
self.slack_client = slackclient.SlackClient(settings.SLACK_BOT_TOKEN)
if self.slack_client.rtm_connect():
try:
LOGGER.debug('Fluid Integrates Bot connected and running!')
start_msg = 'Fluid Integrates Admin Bot now available.'
self.slack_client.api_call('chat.postMessage',
channel=CHANNEL,
text=start_msg,
as_user=True)
while True:
command, channel, user = \
parse_slack_output(self.slack_client.rtm_read())
if command and channel and user:
self.handle_command(command, channel, user)
time.sleep(ws_delay)
except KeyboardInterrupt:
bye_msg = 'Fluid Integrates admin bot has disconnected.'
self.slack_client.api_call('chat.postMessage',
channel=CHANNEL,
text=bye_msg,
as_user=True)
else:
LOGGER.error('Connection failed. Invalid Slack token or bot ID?')
def __init__(self, logger=None):
super().__init__()
self.logger = logger or logging.getLogger(__name__)
self.logger.info('bot initialized!')
# Setup some bot metadata
# These are optional and will overwrite what the slack bot has.
self.name = settings.BOT_NAME
self.emoji = settings.BOT_EMOJI
# When we instantiate a new bot object, we can access the app
# credentials we set earlier in our local development environment.
self.oauth = {
"client_id": settings.CLIENT_ID,
"client_secret": settings.CLIENT_SECRET,
# Scopes provide and limit permissions to what our app
# can access. It's important to use the most restricted
# scope that your app will need.
"scope": settings.SCOPE
}
self.verification = os.environ.get("VERIFICATION_TOKEN")
# NOTE: Python-slack requires a client connection to generate
# an oauth token. We can connect to the client without authenticating
# by passing an empty string as a token and then reinstantiating the
# client with a valid OAuth token once we have one.
self.client = slackclient.SlackClient("")
# BotId is used to ignore messages from self, will be retrieved
# automatically once the OAuth token has been retrieved and installed.
self.botId = ''
def __init__(self):
self.now = datetime.datetime.now()
# print(self.now)
self.client = slck.SlackClient(os.getenv('SLACK_BOT_TOKEN'))
print("Slack bot authenticated!\nrequesting channel list...")
self.channel_list = self.list_channels()
print("{num} channels received!\nQuerying channels...".format(
num=len(self.channel_list)))
# print(self.channel_list)
self.messages_ch_list = self.list_messages("year")
if len(self.messages_ch_list) == 0:
self.messages_ch_list = self.list_messages("month")
if len(self.messages_ch_list) > 0:
self.message = self.messages_ch_list[self.max_emoji_msg()]
self.decorated_message = self.decorate_msg()
self.post_msg()
else:
msg = "DAMN! You guys should be talking more..."
channel_id = 'random'
for ch in self.channel_list:
if ch[CH_NAME] == 'random':
channel_id = ch[CH_ID]
break
self.client.api_call(method="chat.postMessage",
channel=channel_id,
text=msg,
username="******")
def execute(self):
self.print_title()
try:
if self.should_notify_a_new_release:
if not self.version:
raise Exception("The version is missing")
if not self.token or not self.channel:
self.log_warning(
"Slack token or channel is not specified and therefore, no notification will be sent"
)
return True
self.log_info("Announcing release [%s] on channel %s" %
(str(self.version), str(self.channel)))
payload = self.message.format(version=str(self.version))
sc = slackclient.SlackClient(self.token)
sc.api_call(
'chat.postMessage',
channel=str(self.channel),
text=payload,
)
else:
self.log_info("This is not a new release")
except:
self.log_error('Failed to notify of a new release')
return False
self.log_info("Done.")
return True
def start(self):
"""Run the Slack network connection."""
self.client = slackclient.SlackClient(self.api_token)
self.client.rtm_connect()
while True:
try:
for response in self.client.rtm_read():
self.log.debug(response)
if all(x in response for x in ("text", "channel", "user")):
r_channel = response["channel"]
r_user = response["user"]
try:
channel = self.client.server.channels.find(
r_channel).name
user = self.client.server.users.find(r_user).name
except AttributeError:
continue
msg = response["text"]
self.log.info("-#%s- <%s> %s" % (channel, user, msg))
_msg = message.Reply(self, msg, user, channel)
plugin.poll_messages(self, _msg)
time.sleep(.1)
except Exception:
# NOTE(jk0): Disconnected? Try to reconnect.
self.client.rtm_connect()
continue
def post_message_to_slack(self, channel, message, debug=False):
slack_response = {}
try:
# SlackHQ Repository for integrating with the Slack API:
# https://github.com/slackhq/python-slackclient
import slackclient
slack = slackclient.SlackClient(self.m_slack_token)
slack_response = slack.api_call("chat.postMessage",
channel=channel,
text=message,
username=self.m_bot_name,
as_user=True)
if "error" in slack_response:
print "\nERROR: Slack API call had an error(" + str(
slack_response["error"]) + ")\n"
except Exception, e:
err_msg = "Failed to post message to slack with Ex(" + str(
e) + ") SlackResponse(" + str(slack_response) + ")"
print "ERROR: " + str(err_msg)
def __init__(self, proxy, token: str) -> None:
self.client = slackclient.SlackClient(token)
self.proxy = proxy
self.users = self.get_usermap()
self.channels, self.id_map = self.get_channels()
self.membership = {}
self.connect()
def run(self):
self.slackclient = slackclient.SlackClient(self.api_key)
connect = self.slackclient.rtm_connect()
if connect:
self.connected = True
self.id = self.slackclient.server.users.find(
self.slackclient.server.username)
while True:
try:
msg = self.send_queue.get(block=False)
self.slackclient.rtm_send_message(
self.get_channel(), Config["servername"] + "> " + msg)
except queue.Empty:
responses = self.slackclient.rtm_read()
if responses == []:
continue
for msg in responses:
try:
if msg['type'] == 'message':
self._slack_respond(msg)
except KeyError:
continue
finally:
time.sleep(0.1)
else:
raise Exception("Could not connect to Slack.")
def setup(slack, channel):
logging.debug('Setting up Slack Bot.')
global slack_client
slack_client = slackclient.SlackClient(slack['api_key'])
logging.debug('\tSetting Slack API key.')
logging.debug('\tSetting Slack channel name.')
global channel_name
channel_name = channel
def run(self):
self.slack = slackclient.SlackClient(self.slack_token)
self.timestamp = self.get_last_bot_comment()
if not self.slack.rtm_connect():
raise RuntimeError('Could not connect to Slack RTM')
while self.slack.server.connected is True:
self.refresh_slack()
sleep(5)
def get_client_from_env_token():
slack_token = os.environ.get('SLACK_TOKEN')
if slack_token is None:
message = 'Environment variable SLACK_TOKEN is absent. Abort.'
print(message)
logging.error(message)
sys.exit(1)
return slackclient.SlackClient(slack_token)
def init(cls, token):
log.info('Initializing slack bot with token')
try:
cls.slack_client = slackclient.SlackClient(token=token)
log.info('Successfully initialized slack bot with token')
except Exception as e:
log.error('Error initializing slack bot with token. Error: %s', e)
raise e
def check_notification():
sc = slackclient.SlackClient(settings.token)
if sc.rtm_connect():
while True:
get_alert(sc.rtm_read()) # send dictionary
# print sc.rtm_read()
else:
print "Connection Failed, invalid token?"
def _connect_slack(self, token):
if not token:
raise Exception("Can't find a token to connect to Slack.")
try:
return slackclient.SlackClient(token)
except Exception as e:
self._logger.error("Error connecting to Slack: ", e)
raise
def _api_call(method, **kwargs):
"""Function for creating the slack client and doing the actual API call"""
if 'SLACK_API_TOKEN' in kwargs:
token = kwargs.get('SLACK_API_TOKEN')
else:
token = os.environ.get('SLACK_API_TOKEN')
sc = slackclient.SlackClient(token)
return sc.api_call(method, **kwargs)
def _send_message_to_slack(msg):
sc = slackclient.SlackClient(token=NFC_BOT_TOKEN)
sc.api_call(
'chat.postMessage',
channel='#pool',
text=msg,
username='******',
as_user=True,
)
def _connect_slack_client(self):
self.slacker = slackclient.SlackClient(self.config.slack_client_token)
resp = self._send_slack_message("fuzzer started with log " +
self.log_file_name)
if not resp["ok"]:
self.config.root_logger.log(
logging.ERROR, "failed to connect slack client to channel " +
self.config.slack_channel + " with token " +
self.config.slack_client_token)
def __init__(self, token):
"""
Initialize the Slack object given the provided bot token
:param token:
:param config:
"""
self.config = get_config('slack.json')
self.client = slackclient.SlackClient(token)
self.commands = self.load_commands('/jalbot/src/commands/')
def __init__(self, token, init=False):
self.last_ping = 0
self.slack = slackclient.SlackClient(token)
self.slack.rtm_connect()
if init:
self.init()
self.plugins = get_plugins(self.slack)
def _fetch_slack_client(config, secrets):
try:
slack_token = config.slack.token
slack_token = slack_token.strip()
except AttributeError:
return None
else:
if not slack_token:
return None
return slackclient.SlackClient(slack_token)
def slack_client():
import hubcommander.bot_components.slack_comm
sc = slackclient.SlackClient("testtoken")
sc.api_call = MagicMock(side_effect=slack_client_side_effect)
# Need to fix both:
hubcommander.bot_components.SLACK_CLIENT = sc
hubcommander.bot_components.slack_comm.bot_components.SLACK_CLIENT = sc
return sc
def __init__(self, token, user):
self._client = slackclient.SlackClient(token)
self._user = user
self._api_call = self._client.api_call
if self._client.rtm_connect():
print("Flipbot connected and running!")
self._find_users()
self._flipper = FlipMarkedupText(self._users)
else:
print("Connection failed. Invalid Slack token or bot ID?")
def __init__(self, config: Dict[str, Any]) -> None:
token = config['slack']['api_token']
self.slack_client = slackclient.SlackClient(token)
self.kafka_consumer = kafka.KafkaConsumer(
config['kafka']['to_slack']['topic'],
bootstrap_servers=config['kafka']['bootstrap_servers'],
group_id=config['kafka']['to_slack']['group_id'],
)
def __init__(self, token):
super(SlackClient, self).__init__()
self._log = logging.getLogger(__name__)
self.users = dict()
self.conversations = dict()
self.sleep_time = 0.33
self._notify_on_hello = True
self._run = True
self._token = token
self._slack = slackclient.SlackClient(self._token)
def __init__(self, config_dict, last_message=0):
"""Construct a new Slack channel message receiver using the given configuration dict and an
optional last-message timestamp (unix seconds).
"""
self.config = SlackConfig(config_dict)
self.slack = client.SlackClient(self.config.token)
self.channel_id = find_channel_id(self.slack, self.config.channel)
if self.channel_id is not None:
self.slack.api_call('channels.join', channel=self.channel_id)
def __init__(self, config):
"""Construct a new Slack channel message sender using the given configuration dict to specify a token and
channel name.
"""
self.config = config
self.slack = client.SlackClient(config.token)
self.channel_id = find_channel_id(self.slack, config.channel)
if self.channel_id is not None:
self.slack.api_call('channels.join', channel=self.channel_id)
