Current File : //usr/lib/python2.7/site-packages/salt/engines/slack.pyo
�
���^c @@ s� d Z d d l m Z m Z m Z d d l Z d d l Z d d l Z d d l Z d d l Z d d l
Z
d d l Z e j e
� Z y d d l Z e Z Wn e k
r� e Z n Xd d l Z d d l Z d d l Z d d l Z d d l Z d d l Z d d l Z d d l Z d d l Z d d l Z d d l Z d d l m! Z! d Z" d � Z# d e$ f d � � YZ% e d e& e& e d
d � Z' d S( uc
An engine that reads messages from Slack and can act on them
.. versionadded: 2016.3.0
:depends: `slackclient <https://pypi.org/project/slackclient/>`_ Python module
.. important::
This engine requires a bot user. To create a bot user, first go to the
**Custom Integrations** page in your Slack Workspace. Copy and paste the
following URL, and replace ``myworkspace`` with the proper value for your
workspace:
``https://myworkspace.slack.com/apps/manage/custom-integrations``
Next, click on the ``Bots`` integration and request installation. Once
approved by an admin, you will be able to proceed with adding the bot user.
Once the bot user has been added, you can configure it by adding an avatar,
setting the display name, etc. You will also at this time have access to
your API token, which will be needed to configure this engine.
Finally, add this bot user to a channel by switching to the channel and
using ``/invite @mybotuser``. Keep in mind that this engine will process
messages from each channel in which the bot is a member, so it is
recommended to narrowly define the commands which can be executed, and the
Slack users which are allowed to run commands.
This engine has two boolean configuration parameters that toggle specific
features (both default to ``False``):
1. ``control`` - If set to ``True``, then any message which starts with the
trigger string (which defaults to ``!`` and can be overridden by setting the
``trigger`` option in the engine configuration) will be interpreted as a
Salt CLI command and the engine will attempt to run it. The permissions
defined in the various ``groups`` will determine if the Slack user is
allowed to run the command. The ``targets`` and ``default_target`` options
can be used to set targets for a given command, but the engine can also read
the following two keyword arguments:
- ``target`` - The target expression to use for the command
- ``tgt_type`` - The match type, can be one of ``glob``, ``list``,
``pcre``, ``grain``, ``grain_pcre``, ``pillar``, ``nodegroup``, ``range``,
``ipcidr``, or ``compound``. The default value is ``glob``.
Here are a few examples:
.. code-block:: text
!test.ping target=*
!state.apply foo target=os:CentOS tgt_type=grain
!pkg.version mypkg target=role:database tgt_type=pillar
2. ``fire_all`` - If set to ``True``, all messages which are not prefixed with
the trigger string will fired as events onto Salt's ref:`event bus
<event-system>`. The tag for these veents will be prefixed with the string
specified by the ``tag`` config option (default: ``salt/engines/slack``).
The ``groups_pillar_name`` config option can be used to pull group
configuration from the specified pillar key.
.. note::
In order to use ``groups_pillar_name``, the engine must be running as a
minion running on the master, so that the ``Caller`` client can be used to
retrieve that minions pillar data, because the master process does not have
pillar data.
Configuration Examples
======================
.. versionchanged:: 2017.7.0
Access control group support added
This example uses a single group called ``default``. In addition, other groups
are being loaded from pillar data. The group names do not have any
significance, it is the users and commands defined within them that are used to
determine whether the Slack user has permission to run the desired command.
.. code-block:: text
engines:
- slack:
token: 'xoxb-xxxxxxxxxx-xxxxxxxxxxxxxxxxxxxxxxxx'
control: True
fire_all: False
groups_pillar_name: 'slack_engine:groups_pillar'
groups:
default:
users:
- '*'
commands:
- test.ping
- cmd.run
- list_jobs
- list_commands
aliases:
list_jobs:
cmd: jobs.list_jobs
list_commands:
cmd: 'pillar.get salt:engines:slack:valid_commands target=saltmaster tgt_type=list'
default_target:
target: saltmaster
tgt_type: glob
targets:
test.ping:
target: '*'
tgt_type: glob
cmd.run:
target: saltmaster
tgt_type: list
This example shows multiple groups applying to different users, with all users
having access to run test.ping. Keep in mind that when using ``*``, the value
must be quoted, or else PyYAML will fail to load the configuration.
.. code-block:: text
engines:
- slack:
groups_pillar: slack_engine_pillar
token: 'xoxb-xxxxxxxxxx-xxxxxxxxxxxxxxxxxxxxxxxx'
control: True
fire_all: True
tag: salt/engines/slack
groups_pillar_name: 'slack_engine:groups_pillar'
groups:
default:
users:
- '*'
commands:
- test.ping
aliases:
list_jobs:
cmd: jobs.list_jobs
list_commands:
cmd: 'pillar.get salt:engines:slack:valid_commands target=saltmaster tgt_type=list'
gods:
users:
- garethgreenaway
commands:
- '*'
i ( t absolute_importt print_functiont unicode_literalsN( t sixu slackc C@ s t s t d f St S( Nu3 The 'slackclient' Python module could not be loaded( t HAS_SLACKCLIENTt Falset __virtualname__( ( ( s6 /usr/lib/python2.7/site-packages/salt/engines/slack.pyt __virtual__� s
t SlackClientc B@ s� e Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z
d � Z d
� Z d � Z
d � Z d
� Z d � Z d d � Z d � Z RS( c C@ s= t j j t � | _ t j | � | _ | j j � | _ d S( N(
t saltt miniont MasterMiniont __opts__t
master_miniont slackclientR t sct rtm_connectt
slack_connect( t selft token( ( s6 /usr/lib/python2.7/site-packages/salt/engines/slack.pyt __init__� s c C@ s� t j j j d d d | d t � } i } d | k r� xU | d D]F } d | k rA | d s� | d | | d <| d | | d <q� qA qA Wn | S( u*
Get all users from Slack
t functionu userst api_keyt optsu messageu is_botu idu name( R t utilst slackt queryR ( R R t rett userst item( ( s6 /usr/lib/python2.7/site-packages/salt/engines/slack.pyt get_slack_users� s
c C@ sr t j j j d d d | d i t d 6t d 6� } i } d | k rn x' | d D] } | d | | d <qO Wn | S(
u2
Get all channel names from Slack
R u roomsR R u exclude_archivedu exclude_membersu messageu nameu id( R R R R t True( R R R t channelsR ( ( s6 /usr/lib/python2.7/site-packages/salt/engines/slack.pyt get_slack_channels� s
c C@ s i i t � d 6t � d 6i d 6i d 6i d 6d 6} | sE i } n | } t j d | � y+ t j | j | � j � | j � � } Wn6 t k
r� t j d | | j | � | � g } n Xx?| D]7\ } } t j d | | � | j
| i t � d 6t � d 6i d 6i d 6i d 6� y� | | d j t | j d g � � � | | d j t | j d g � � � | | d j | j d i � � | | d j | j d i � � | | d j | j d i � � Wq� t
t f k
r�t j d
| � q� Xq� Wt j d | � | S( u�
get info from groups in config, and from the named pillar
todo: add specification for the minion to use to recover pillar
u usersu commandsu aliasesu default_targetu targetsu defaultu
use_groups %su3 Failed to get groups from %s: %s or from config: %su$ Trying to get %s and %s to be usefuluH Couldn't use group %s. Check that targets is a dictionary and not a listu Got the groups: %s( t sett logt debugt itertoolst chaint _groups_from_pillart itemst AttributeErrort warningt infot
setdefaultt updatet gett
IndexError( R t groups_conft groups_pillar_namet
ret_groupst
use_groupst
groups_gent namet config( ( s6 /usr/lib/python2.7/site-packages/salt/engines/slack.pyt get_config_groups� sD
+
''!!%c C@ so | re t d d k re t d | i � } t j d | | � t j d | � t j d t | � � n i } | S( u�
pillar_prefix is the pillar.get syntax for the pillar to be queried.
Group name is gotten via the equivalent of using
``salt['pillar.get']('{}:{}'.format(pillar_prefix, group_name))``
in a jinja template.
returns a dictionary (unless the pillar is mis-formatted)
XXX: instead of using Caller, make the minion to use configurable so there could be some
restrictions placed on what pillars can be used.
u __roleu minionu
pillar.getu# Got pillar groups %s from pillar %su pillar groups is %su pillar groups type is %s( R t __salt__R# R$ t type( R t pillar_namet
pillar_groups( ( s6 /usr/lib/python2.7/site-packages/salt/engines/slack.pyR' s c C@ sh t j d � d k r7 t j j j t t d � j } n d } | rS | | | � n t d | | � d S( un
This replaces a function in main called 'fire'
It fires an event into the salt bus.
u __roleu masteru sock_diru
event.sendN( R R. R R t eventt get_master_eventt fire_mastert NoneR8 ( R t tagt msgR> ( ( s6 /usr/lib/python2.7/site-packages/salt/engines/slack.pyt fire4 s c C@ s� t j d | | | � x� | j � D]� \ } } | | d k rX d | d k rX q# qX n | | d k r� | | j d i � j � k r� d | d k r� q# q� n t j d | | � | | f SWt j d | | � d S( u�
Break out the permissions into the following:
Check whether a user is in any group, including whether a group has the '*' membership
:type user: str
:param user: The username being checked against
:type command: str
:param command: The command that is being invoked (e.g. test.ping)
:type groups: dict
:param groups: the dictionary with groups permissions structure.
:rtype: tuple
:returns: On a successful permitting match, returns 2-element tuple that contains
the name of the group that successfully matched, and a dictionary containing
the configuration of the group so it can be referenced.
On failure it returns an empty tuple
u! %s wants to run %s with groups %su usersu *u commandsu aliasesu! Slack user %s permitted to run %su% Slack user %s denied trying to run %s( ( R# R+ R( R. t keys( R t usert commandt groupst keyt val( ( s6 /usr/lib/python2.7/site-packages/salt/engines/slack.pyt can_user_runF s . c C@ s� t j j j | t | � � } g } xr | D]j } d } t j | | � } | r� | j d � | j d � | j d � } | j | � q, | j | � q, W| S( u{
cmdline_str is the string of the command line
trigger_string is the trigger string, to be removed
u3 (?P<begin>.*)(<.*\|)(?P<url>.*)(>)(?P<remainder>.*)u beginu urlu remainder( R R t argst shlex_splitt lent ret matcht groupt append( R t cmdline_strt trigger_stringt cmdlinet cmdlistt cmditemt patternt mtcht origtext( ( s6 /usr/lib/python2.7/site-packages/salt/engines/slack.pyt commandline_to_listj s
)c @ s1 | j | | � } | j | | d | � } t j d | | � | sU t d
| d f S| sl t d
| d f S| d | d j d i � j � k r� | j | d d | d j d d � d � } | j | d � n | } | j | | | � } g | D]( � t
� f d � d D� � r� � ^ q� } t | | f S( u# Returns a tuple of (target, cmdline,) for the response
Raises IndexError if a user can't be looked up from all_slack_users
Returns (False, False) if the user doesn't have permission
These are returned together because the commandline and the targeting
interact with the group config (specifically aliases and targeting configuration)
so taking care of them together works out.
The cmdline that is returned is the actual list that should be
processed by salt, and not the alias.
i u3 slack_user_name is %s and the permitted group is %si u aliasesu cmdu c 3@ s | ] } � j | � Vq d S( N( t
startswith( t .0t x( R ( s6 /usr/lib/python2.7/site-packages/salt/engines/slack.pys <genexpr>� s u targetu tgt_typeN( u targetu tgt_type( RY RI R# R$ R R? R. RC t extendt
get_targett allR ( R t slack_user_namet textt
loaded_groupsRR RS t permitted_groupt use_cmdlinet target( ( R s6 /usr/lib/python2.7/site-packages/salt/engines/slack.pyt control_message_target~ s &.
(c C@ s� | j d � d k r$ t d � � n | j d d � pQ | j d i � j d d � } y t j d | � Wn# t k
r� } t j d | � n Xt j j j
| � } t j j j | � } | s� t
d � � n | S( us
Raises ValueError if a value doesn't work out, and TypeError if
this isn't a message type
u typeu messageu This is not a messageu textu
Message is %su5 Got a message that I could not log. The reason is: %su _text has no valueN( R. t TypeErrorR? R# R+ t UnicodeEncodeErrorR* R R t jsont dumpst yamlt safe_loadt
ValueError( R t m_datat _textt uee( ( s6 /usr/lib/python2.7/site-packages/salt/engines/slack.pyt message_text� s 0c #@ sl � j � � � � j � � � � � � � f d � } xY d D]9 } � j rP Pq= t j d � j j | � t j | � q= Wt d j
� j � � � x�t rg� j j � } x�| D]�} y � j
| � } Wn8 t t f k
r}
t j d |
� i | d 6Vq� n X� j j j j | d
� } | | � } | j | � rL� j | | � }
| j d � s�t j d | j d
� � | j d j
| d | � � i | d 6Vq� n � j | d | |
| � \ } } } t j d | | � | r$i | d 6| d
d
6| d d
6| d d 6| d 6| d 6Vq� qT| j d j
| d | � � | Vq� q� | Vq� q� Wi t d 6Vq� Wd S( u�
slack_token = string
trigger_string = string
input_valid_users = set
input_valid_commands = set
When the trigger_string prefixes the message text, yields a dictionary
of::
{
'message_data': m_data,
'cmdline': cmdline_list, # this is a list
'channel': channel,
'user': m_data['user'],
'slack_client': sc
}
else yields {'message_data': m_data} and the caller can handle that
When encountering an error (e.g. invalid message), yields {}, the caller can proceed to the next message
When the websocket being read from has given up all its messages, yields {'done': True} to
indicate that the caller has read all of the relevant data for now, and should continue
its own processing and check back for more data later.
This relies on the caller sleeping between checks, otherwise this could flood
c @ sw d | k r� d | k rF d | d k rF t j d � | d d } q� d | k r� d | d k r� t j d � | d d } q� n | j d � } | j d � } | j d � r� d } n � j | � } i | d 6| d
6� j | � d 6| d 6} | d s3� j � � j � j � � � � j | � | d <n | d ss� j � � j � j � � � � j | � | d <n | S(
u0 Always try to return the user and channel anywayu useru messageu@ Message was edited, so we look for user in the original message.u commentu6 Comment was added, so we look for user in the comment.u channelu Du private chatu message_datau user_idu user_nameu channel_name( R# R$ R. RZ t clearR- R R! ( Rn t user_idt
channel_idt channel_namet data( t all_slack_channelst all_slack_usersR R ( s6 /usr/lib/python2.7/site-packages/salt/engines/slack.pyt just_data� s4
i i
i i< u4 Slack connection is invalid. Server: %s, sleeping %su3 Connection to slack is still invalid, giving up: {}u3 Got an error from trying to get the message text %su message_datau channelu user_nameuC The user %s can not be looked up via slack. What has happened here?u useru; The user {} can not be looked up via slack. Not running {}u user_idu Got target: %s, cmdline: %su cmdlineu targetu& {0} is not allowed to use command {1}.u doneN( i i
i i< ( R R! R R# R* R t servert timet sleept UserWarningt formatR t rtm_readRq Rm Rg R$ R t findRZ R7 R. t errort send_messageRf ( R R RR RF R1 Ry t sleepsRA Rn t msg_textt msg_errt channelRv Rb t allowedRe RS ( ( Rw Rx R R s6 /usr/lib/python2.7/site-packages/salt/engines/slack.pyt generate_triggered_messages� sb $
c @ s i d d 6d d 6� � � f d � } x� | | f D]� } | j | � \ } } d | k r3 t j d | � d | k r� t j d | � i | d d 6| d d 6Si | d d 6d d 6Sq3 WxG | | f D]9 } | | d � } t j d | � | j d � r� | Sq� W� S(
u�
When we are permitted to run a command on a target, look to see
what the default targeting is for that group, and for that specific
command (if provided).
It's possible for None or False to be the result of either, which means
that it's expected that the caller provide a specific target.
If no configured target is provided, the command line will be parsed
for target=foo and tgt_type=bar
Test for this::
h = {'aliases': {}, 'commands': {'cmd.run', 'pillar.get'},
'default_target': {'target': '*', 'tgt_type': 'glob'},
'targets': {'pillar.get': {'target': 'you_momma', 'tgt_type': 'list'}},
'users': {'dmangot', 'jmickle', 'pcn'}}
f = {'aliases': {}, 'commands': {'cmd.run', 'pillar.get'},
'default_target': {}, 'targets': {},'users': {'dmangot', 'jmickle', 'pcn'}}
g = {'aliases': {}, 'commands': {'cmd.run', 'pillar.get'},
'default_target': {'target': '*', 'tgt_type': 'glob'},
'targets': {}, 'users': {'dmangot', 'jmickle', 'pcn'}}
Run each of them through ``get_configured_target(('foo', f), 'pillar.get')`` and confirm a valid target
u *u targetu globu tgt_typec @ s� � \ } } | j d � } | s* � } n | j d � r` | d j | � r` | d | } q` n | j d � s� t j d | | � n | S( u_
Validate cmd against the group to return the target, or a null target
u default_targetu targetsu targetu7 Group %s is not configured to have a target for cmd %s.( R. R# R$ ( t cmdR5 t group_configRe ( t null_targetRc ( s6 /usr/lib/python2.7/site-packages/salt/engines/slack.pyt check_cmd_against_groupZ s u target is in kwargs %s.u tgt_type is in kwargs %s.i u this cmdline has target %s.( t parse_args_and_kwargsR# R$ R. ( R Rc RS t
alias_cmdlineR� t this_clt _t kwargst checked( ( R� Rc s6 /usr/lib/python2.7/site-packages/salt/engines/slack.pyR^ ; s c K@ s� yv y# | t t | � � j d � } Wn t t f k
rE d } n Xt j j d � t j
| � D� d | d t �SWn9 t k
r� } d d l
} t j d | j | � � d SXd S( u5
Print out YAML using the block mode
u outc S@ s# i | ] \ } } | d | � q S( u return( ( R[ R\ t y( ( s6 /usr/lib/python2.7/site-packages/salt/engines/slack.pys
<dictcomp>� s t outR i Nu1 Exception encountered when trying to serialize %su5 Got an error trying to serialze/clean up the response( t nextt iterR. t
StopIterationR) R? R t outputt
string_formatR t iteritemsR t Exceptiont pprintR# t exceptiont pformat( R Rv R R� t outputtert excR� ( ( s6 /usr/lib/python2.7/site-packages/salt/engines/slack.pyt format_return_texty s #
c C@ s~ g } i } t | � d k rt xS | d D]D } d | k r` | j d d � \ } } | | | <q) | j | � q) Wn | | f S( uU
cmdline: list
returns tuple of: args (list), kwargs (dict)
i u =( RL t splitRP ( R RS RJ R� R RG t value( ( s6 /usr/lib/python2.7/site-packages/salt/engines/slack.pyR� � s
c C@ s� t j j t � } t j d � } | s9 t j d � } n i } x� | D]� } | j j d j | � | � rF | j d | g � } | j d i � } | j d i � } i t j j
j t j j
j | � � d 6| d 6| | <qF qF W| S( uV
Given a list of job_ids, return a dictionary of those job_ids that have
completed and their results.
Query the salt event bus via the jobs runner. jobs.list_job will show
a job in progress, jobs.lookup_jid will return a job that has
completed.
returns a dictionary of job id: result
u
ext_job_cacheu master_job_cacheu
{}.get_jidu
jobs.list_jobu Resultu Functionu datau function(
R t runnert RunnerClientR R. R
t returnersR~ R� R Ri t loadsRj ( R t outstanding_jidsR� t sourcet resultst jidt
job_resultt
jid_resultt jid_function( ( s6 /usr/lib/python2.7/site-packages/salt/engines/slack.pyt get_jobs_from_runner� s
%i c C@ st i } xgt rot j d | � t j | � d } xo| D]g} t j d | j � � | d k rr t j d � Pn | s� | d 7} t j d � q9 n | j d � r� t j d � Pn | r
t j d
| � t j d | | � | j d j
| | d
j d � � | � n | r�t | � d k r�| j d � r�| j j
j j | d � } | j | � }
t j d |
� | | |
<| j d j
| d |
� � n | d 7} q9 Wt j � } | j | j � � } t j d t | � t j � | � x�| D]y}
| |
d }
| |
d } |
r�t j d |
� | |
} | j j
j j | d � } | j |
| � } d j
| d | d |
| d � } | j | � t j � } t j j | � j d � } d j
| � } | j j d d | j d | d | �} t j d | � t j j j t j j j | � � } d! | k r^| d! t k r^| d j d" j
| d# � � n | |
=q�q�Wq Wd$ S(% u�
Pull any pending messages from the message_generator, sending each
one to either the event bus, the command_async or both, depending on
the values of fire_all and command
u Sleeping for interval of %si u$ Got a message from the generator: %si
u6 Breaking in getting messages because count is exceededi u Skipping an empty message.u doneu msg is doneu& Firing message to the bus with tag: %su %s %su {0}/{1}u message_datau typeu cmdlineu channelu Submitted a job and got jid: %su% @{}'s job is submitted as salt jid {}u user_nameu& Getting %s jobs status took %s secondsu datau functionu ret to send back is %su- @{}'s job `{}` (id: {}) (target: {}) returnedu targetu %Y%m%d%H%M%S%fu salt-results-{0}.yamlu files.uploadR t filenamet contentu Got back %s via the slack clientu oku
Error: {0}u errorN( R R# t traceR{ R| RC R* R. R$ RB R~ RL R Rz R R� t run_command_asyncR� R� R� t datetimet
fromtimestampt strftimet api_callt idR R Rk Rl Ri Rj R ( R t message_generatort fire_allR@ t controlt intervalt outstandingt countRA R� R� t
start_timet
job_statust resultR t this_jobt return_textt
return_prefixt tst stR� t rt resp( ( s6 /usr/lib/python2.7/site-packages/salt/engines/slack.pyt run_commands_from_slack_async� sj
,'
#
$ !c
C@ s� t j d � t t j j t � j � } | d d } | j | d � \ } } d | k r{ | j d t
j | d � � n | d d } | d d } t j d | � | | k rt j j t � } t j d | � | j
| i | d
6| d 6� } | d }
n� t j j � } t j d
| | � t j d | | | | | � | j t j | � | d | d | d t j | � �}
t j d |
� |
S( u�
:type message_generator: generator of dict
:param message_generator: Generates messages from slack that should be run
:type fire_all: bool
:param fire_all: Whether to also fire messages to the event bus
:type tag: str
:param tag: The tag to send to use to send to the event bus
:type interval: int
:param interval: time to wait between ending a loop and beginning the next
u# Going to run a command asynchronousu cmdlinei u pillart pillaru targetu tgt_typeu target_type is: %su( Command %s will run via runner_functionsu argsu kwargsu jidu5 Command %s will run via local.cmd_async, targeting %su Running %s, %s, %s, %s, %st argt kwargt tgt_typeu ret from local.cmd_async is %s( R# R$ t sortedR R� t RunnerR t functionsR� R- t astt literal_evalR� t asynchronoust clientt LocalClientt cmd_asyncR t text_typeR+ ( R RA t runner_functionsR� RJ R� Re R� R� t job_id_dictt job_idt local( ( s6 /usr/lib/python2.7/site-packages/salt/engines/slack.pyR� s(
6( t __name__t
__module__R R R! R7 R' RB RI RY Rf Rq R� R^ R� R� R� R� R� ( ( ( s6 /usr/lib/python2.7/site-packages/salt/engines/slack.pyR � s" 7 $ , { > Du !u salt/engines/slackc C@ s� | s | j d � r@ t j d � t j d � t d � � n yA t d | � } | j | | | | � } | j | | | | � Wn, t k
r� t d j
t j � � � � n Xd S( uF
Listen to slack events and forward them to salt, new version
u xoxbi u% Slack bot token not found, bailing...u% Slack Engine bot token not configuredR u {}N(
RZ R{ R| R# R� R} R R� R� R� R~ t tracebackt
format_exc( R R� t triggerRF R1 R� R@ R� R� ( ( s6 /usr/lib/python2.7/site-packages/salt/engines/slack.pyt start< s
(( t __doc__t
__future__R R R R� R� R% t loggingR{ RM R� t getLoggerR� R# R R R t ImportErrorR t salt.clientR t salt.loadert salt.miniont salt.runnert salt.utils.argst salt.utils.eventt salt.utils.httpt salt.utils.jsont salt.utils.slackt salt.utils.yamlt salt.outputt salt.extR R R t objectR R? R� ( ( ( s6 /usr/lib/python2.7/site-packages/salt/engines/slack.pyt <module>� sJ
� � �
Mini Shell