File manager - Edit - /opt/saltstack/salt/lib/python3.10/site-packages/salt/engines/__pycache__/slack_bolt_engine.cpython-310.pyc
Back
o ;j � � @ s d Z ddlZddlZddlZddlZddlZddlZddlZddlZddl Z ddl Z ddl Z ddl Z ddlZ ddlZ ddlZ ddlZ ddlZ ddlZ ddlZ z ddlZddlZdZW n eye dZY nw e�e�ZdZ dd� Z G dd � d �Z dd d �Z dS )a� An engine that reads messages from Slack and can act on them .. versionadded:: 3006.0 :depends: `slack_bolt <https://pypi.org/project/slack_bolt/>`_ Python module .. important:: This engine requires a Slack app and a Slack 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 log in with account credentials with administrative privileges: ``https://api.slack.com/apps/new`` Next, click on the ``From scratch`` option from the ``Create an app`` popup. Give your new app a unique name, eg. ``SaltSlackEngine``, select the workspace where your app will be running, and click ``Create App``. Next, click on ``Socket Mode`` and then click on the toggle button for ``Enable Socket Mode``. In the dialog give your Socket Mode Token a unique name and then copy and save the app level token. This will be used as the ``app_token`` parameter in the Slack engine configuration. Next, click on ``Event Subscriptions`` and ensure that ``Enable Events`` is in the on position. Then add the following bot events, ``message.channel`` and ``message.im`` to the ``Subcribe to bot events`` list. Next, click on ``OAuth & Permissions`` and then under ``Bot Token Scope``, click on ``Add an OAuth Scope``. Ensure the following scopes are included: - ``channels:history`` - ``channels:read`` - ``chat:write`` - ``commands`` - ``files:read`` - ``files:write`` - ``im:history`` - ``mpim:history`` - ``usergroups:read`` - ``users:read`` Once all the scopes have been added, click the ``Install to Workspace`` button under ``OAuth Tokens for Your Workspace``, then click ``Allow``. Copy and save the ``Bot User OAuth Token``, this will be used as the ``bot_token`` parameter in the Slack engine configuration. 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 events 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 minion's pillar data, because the master process does not have pillar data. Configuration Examples ====================== .. versionchanged:: 2017.7.0 Access control group support added .. versionchanged:: 3006.0 Updated to use slack_bolt Python library. This example uses a single group called ``default``. In addition, other groups are being loaded from pillar data. The users and commands defined within these groups are used to determine whether the Slack user has permission to run the desired command. .. code-block:: text engines: - slack_bolt: app_token: "xapp-x-xxxxxxxxxxx-xxxxxxxxxxxxx-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" bot_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_bolt: groups_pillar: slack_engine_pillar app_token: "xapp-x-xxxxxxxxxxx-xxxxxxxxxxxxx-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" bot_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: - '*' � NTF� slack_boltc C s t sdS tS )N)Fz2The 'slack_bolt' Python module could not be loaded)� HAS_SLACKBOLT�__virtualname__� r r �R/opt/saltstack/salt/lib/python3.10/site-packages/salt/engines/slack_bolt_engine.py� __virtual__� s r c @ s� e Zd Zdd� Zdd� Zdd� Zdd� Zd d � Zd d � Zd d� Z dd� Z dd� Z dd� Z dd� Z dd� Zdd� Zdd � Zd d � Zd d � Zd!d"� Z #d)d$d%�Zd&d'� Zd(S )*� SlackClientc C sx t j�t�| _tj|d�| _tjj � | j|�| _ | j � � || _ || _t�� | _d|� d�}| j�t�|��| j� d S )N)�tokenz(^z.*))�salt�minionZ MasterMinion�__opts__� master_minionr ZApp�appZadapterZ socket_modeZSocketModeHandler�handler�connect� app_token� bot_token� collections�deque� msg_queue�message�re�compile�message_trigger)�selfr r �trigger_stringZtrigger_patternr r r �__init__� s � zSlackClient.__init__c C s dS )NTr )r r r r � _run_until� s zSlackClient._run_untilc C s | j �|� d S �N)r �append)r r r r r r � s zSlackClient.message_triggerc C sb t jjjd|td�}i }d|v r/|d D ]}d|v r.|d s.|d ||d < |d ||d < q|S )z� Get all users from Slack :type user: str :param token: The Slack token being used to allow Salt to interact with Slack. �users��functionZapi_key�optsr Zis_bot�id�name)r �utils�slack�queryr )r r �retr �itemr r r �get_slack_users� s �zSlackClient.get_slack_usersc C sH t jjjd|ddd�d�}i }d|v r"|d D ] }|d ||d < q|S )z� Get all channel names from Slack :type token: str :param token: The Slack token being used to allow Salt to interact with Slack. ZroomsT)Zexclude_archivedZexclude_membersr! r r% r$ )r r& r' r( )r r r) �channelsr* r r r �get_slack_channels s � z SlackClient.get_slack_channelsc C sv dt � t � i i i d�i}|si }n|}t�d|� zt�| �|��� |�� �}W n ty> t�d|| �|�|� g }Y nw |D ]q\}}t� d||� |� |t � t � i i i d�� zG|| d � t |� dg ��� || d � t |� dg ��� || d � |� di �� || d � |� d i �� || d � |� d i �� W qA t tfy� t�d |� Y qAw t�d |� |S ) a� get info from groups in config, and from the named pillar :type group_conf: dict :param group_conf: The dictionary containing the groups, group members, and the commands those group members have access to. :type groups_pillar_name: str :param groups_pillar_name: can be used to pull group configuration from the specified pillar key. �default)r �commands�aliases�default_target�targetsz use_groups %sz3Failed to get groups from %s: %s or from config: %sz$Trying to get %s and %s to be usefulr r/ r0 r1 r2 zHCouldn't use group %s. Check that targets is a dictionary and not a listzGot the groups: %s)�set�log�debug� itertools�chain�_groups_from_pillar�items�AttributeError�warning�info� setdefault�update�get� IndexError)r Z groups_conf�groups_pillar_nameZ ret_groupsZ use_groupsZ groups_genr% Zconfigr r r �get_config_groups sh �� � �� �� � �� z SlackClient.get_config_groupsc C sT |r&t d dkr&td |i �}t�d||� t�d|� t�dt|�� |S i }|S )z� :type pillar_name: str :param pillar_name: The pillar.get syntax for the pillar to be queried. returns a dictionary (unless the pillar is mis-formatted) �__roler z pillar.getz#Got pillar groups %s from pillar %szpillar groups is %szpillar groups type is %s)r �__salt__r4 r5 �type)r Z pillar_nameZ pillar_groupsr r r r8 m s �z SlackClient._groups_from_pillarc C sN t �d�dkrtjj�t t d �j}nd}|r |||� dS td ||� dS )a4 This replaces a function in main called 'fire' It fires an event into the salt bus. :type tag: str :param tag: The tag to use when sending events to the Salt event bus. :type msg: dict :param msg: The msg dictionary to send to the Salt event bus. rC ZmasterZsock_dirNz event.send)r r? r r& �eventZget_master_event� fire_masterrD )r �tag�msgrG r r r �fire~ s ��zSlackClient.firec C s� t �d|||� |�� D ]4\}}||d vr d|d vr q ||d vr4||�di ��� vr4d|d vr4q t �d||� ||f S t �d||� dS ) a� 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 z!%s wants to run %s with groups %sr �*r/ r0 z!Slack user %s permitted to run %sz%Slack user %s denied trying to run %sr )r4 r< r9 r? �keys)r �userZcommand�groups�key�valr r r � can_user_run� s �zSlackClient.can_user_runc C st t jj�|t|�d� �}g }|D ]&}d}t�||�}|r2|�d�|�d� |�d� }|�|� q|�|� q|S )z{ cmdline_str is the string of the command line trigger_string is the trigger string, to be removed Nz3(?P<begin>.*)(<.*\|)(?P<url>.*)(>)(?P<remainder>.*)�begin�url� remainder) r r& �argsZ shlex_split�lenr �match�groupr ) r Z cmdline_strr �cmdlineZcmdlistZcmditem�patternZmtchZorigtextr r r �commandline_to_list� s � z SlackClient.commandline_to_listc C s� | � ||�}| �||d |�}t�d||� |s dd|d fS |s(dd|d fS |d |d �di ��� v rR| � |d d |d �dd�d�}|�|dd� � n|}| �|||�}d d � |D �}d ||fS ) a# 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. r z3slack_user_name is %s and the permitted group is %sFN� r0 �cmd� c s& g | ]� t � fd d�dD ��r� �qS )c 3 s � | ] }� � |� V qd S r )� startswith)�.0�x�r* r r � <genexpr> s � z@SlackClient.control_message_target.<locals>.<listcomp>.<genexpr>��target�tgt_type)�all)r` r rb r � <listcomp> s ��z6SlackClient.control_message_target.<locals>.<listcomp>T)r[ rQ r4 r5 r? rL �extend� get_target) r Zslack_user_name�text� loaded_groupsr rY �permitted_groupZ use_cmdlinere r r r �control_message_target� s, � �� z"SlackClient.control_message_targetc C s� |� d�dkr td��|� dd�p|� di �� dd�}zt�d|� W n ty; } z t�d|� W Y d}~nd}~ww tjj� |�}tjj � |�}|sPt d��|S ) z� Raises ValueError if a value doesn't work out, and TypeError if this isn't a message type :type m_data: dict :param m_data: The message sent from Slack rE r zThis is not a messagerk Nz Message is %sz5Got a message that I could not log. The reason is: %sz_text has no value) r? � TypeErrorr4 r< �UnicodeEncodeErrorr; r r& �json�dumpsZyamlZ safe_load� ValueError)r �m_dataZ_textZueer r r � message_text s ��zSlackClient.message_textc # s� � �� �������� � ���fdd�}dD ]}�jr nt�d|� t�|� qtd��j����� � rֈj rˈj � � }z�� |�}W n t tfyc } zt�d| � d|iV W Y d} ~ q5d} ~ ww |d } ||�} |�|�rLj�||�} | �d �s�t�d |�d �� | �d �| d |�� d|iV q5��| d || |�\} }}| r�||d | d | d ||d�}|V q5| �d�| d |�� | V q5| V q5ddiV �� � s5dS dS )a� 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 sD d}d}d| vrKd| v r d| d v r t �d� | d d }n2d| v r4d| d v r4t �d� | d d }n | �d�dkrJt �d � | �d �}| �d �}n| �d�}| �d �}|�d �r]d}n� �|�}|du rk��|�}| |||d�}|d s���� ������� ��|�|d< |d s�� �� � ������ � �|�|d< |S )z0Always try to return the user and channel anywayNrM r z@Message was edited, so we look for user in the original message.Zcommentz6Comment was added, so we look for user in the comment.�subtypeZ bot_messagezHMessage was posted by a bot/workflow, so we use the bot id and username.Zbot_id�username�channel�Dz private chat)� message_data�user_id� user_name� channel_namer| r} )r4 r5 r? r_ �clearr> r+ r- )rt r{ r| Z channel_idr} �data�Zall_slack_channelsZall_slack_usersr r r r � just_dataI sN � � � �z:SlackClient.generate_triggered_messages.<locals>.just_data)� � � �< z(Slack connection is invalid, sleeping %sz3Connection to slack is still invalid, giving up: {}z.Got an error trying to get the message text %srz Nrx r| zCThe user %s can not be looked up via slack. What has happened here?rM z;The user {} can not be looked up via slack. Not running {}r{ )rz rx rM r| rY re z${} is not allowed to use command {}.�doneT)r+ r- r r4 r; �time�sleep� UserWarning�formatr r �popleftru rs ro r5 r_ rB r? �error� send_messagern )r r r rN rA r� ZsleepsrI Zmsg_textZmsg_errrx r rl �allowedre rY r) r r� r �generate_triggered_messages$ s� � ��3���� �� � � ���� �z'SlackClient.generate_triggered_messagesc s� ddd�� � �fdd�}||fD ]1}| � |�\}}d|v rAt�d|� d|v r8t�d |� |d |d d� S |d dd� S q||fD ]}||d �}t�d |� |�d�r]| S qF� S ) aM 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 :type permitted_group: tuple :param permitted_group: A tuple containing the group name and group configuration to check for permission. :type cmdline: list :param cmdline: The command sent from Slack formatted as a list. :type alias_cmdline: str :param alias_cmdline: An alias to a cmdline. rK �globrd c sZ �\}}|� d�}|s � }|� d�r |d � | �r |d | }|� d�s+t�d|| � |S )z� Validate cmd against the group to return the target, or a null target :type cmd: list :param cmd: The command sent from Slack formatted as a list. r1 r2 re z7Group %s is not configured to have a target for cmd %s.)r? r4 r5 )r] r% Z group_configre �Z null_targetrm r r �check_cmd_against_group� s �z7SlackClient.get_target.<locals>.check_cmd_against_groupre ztarget is in kwargs %s.rf ztgt_type is in kwargs %s.r zthis cmdline has target %s.)�parse_args_and_kwargsr4 r5 r? ) r rm rY Z alias_cmdliner� Zthis_cl�_�kwargs�checkedr r� r rj � s$ & � �zSlackClient.get_targetc K s� z,z |t t|�� �d�}W n ttfy d}Y nw tjjdd� |�� D �|t d�W S t yL } zddl }t � d|�|�� W Y d}~dS d}~ww ) z� Print out YAML using the block mode :type user: dict :param token: The return data that needs to be formatted. :type user: str :param token: The function that was used to generate the return data. �outNc S s i | ] \}}||d �qS )�returnr )r` ra �yr r r � <dictcomp>$ s z2SlackClient.format_return_text.<locals>.<dictcomp>)r� r# r z1Exception encountered when trying to serialize %sz5Got an error trying to serialze/clean up the response)�next�iterr? � StopIterationr: r �outputZ string_formatr9 r � Exception�pprintr4 � exceptionZpformat)r r r" r� Z outputter�excr� r r r �format_return_text s( �����z SlackClient.format_return_textc C sZ g }i }t |�dkr)|dd� D ]}d|v r#|�dd�\}}|||< q|�|� q||fS )z� :type cmdline: list :param cmdline: The command sent from Slack formatted as a list. returns tuple of: args (list), kwargs (dict) r\ N�=)rV �splitr )r rY rU r� r* rO �valuer r r r� 1 s z!SlackClient.parse_args_and_kwargsc C s� t j�t�}t�d�}|st�d�}i }|D ]1}| jj|� d� |�rG|�d|g�}|�di �}|�di �}t jj � t jj � |��|d�||< q|S )a� 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. :type outstanding_jids: list :param outstanding_jids: The list of job ids to check for completion. returns a dictionary of job id: result Z ext_job_cacheZmaster_job_cachez.get_jidz jobs.list_jobZResultZFunction)r r" ) r �runner� RunnerClientr r? r Z returnersr] r& rq �loadsrr ) r Zoutstanding_jidsr� �source�results�jidZ job_resultZ jid_resultZ jid_functionr r r �get_jobs_from_runnerF s ��z SlackClient.get_jobs_from_runnerr\ c C sh i }| � � �r2t�d|� t�|� d}|D ]�}|r�t�d|�� � |dkr-t�d� nj|s9|d7 }t�d� q|�d�rEt�d � nR|rct�d |� t�d ||� | � d � ||d �d��|� |r�t |�dkr�|�d�r�| � |�} t�d| � ||| < d� |d | �} | j jj|d | d� |d7 }qt�� } | �|�� �} t�dt | �t�� | � | D ]z} | | d } | | d }| �r+t�d| � || }|d }| �| |�}d� |d |d | |d �}| j jj||d� t�� }tj�|��d�}d |� d �}| j jj|||d �}t�d |� d |v �r(|d d!u �r(|d �d"� |d# �� || = q�| � � sd$S d$S )%a� 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 :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 control: bool :param control: If set to True, whether Slack is allowed to control Salt. :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 zSleeping for interval of %sr z$Got a message from the generator: %sr� z6Breaking in getting messages because count is exceededr\ zSkipping an empty message.r� z msg is donez&Firing message to the bus with tag: %sz%s %sz{}/{}rz rE rY z Submitted a job and got jid: %sz%@{}'s job is submitted as salt jid {}r| rx )rx rk z&Getting %s jobs status took %s secondsr r" zret to send back is %sz-@{}'s job `{}` (id: {}) (target: {}) returnedre z%Y%m%d%H%M%S%fz salt-results-z.yaml)r, �filename�contentz Got back %s via the slack client�okFz Error: {}r� N)r r4 Ztracer� r� rL r; r? r5 rJ r� rV �run_command_asyncr �clientZchat_postMessager� r� �datetime� fromtimestamp�strftimeZ files_uploadr� )r �message_generator�fire_allrH �control�intervalZ outstanding�countrI r� Ztext_msgZ start_timeZ job_status�resultr" Zthis_jobrx Z return_textZ return_prefix�ts�str� Zrespr r r � run_commands_from_slack_asynci s� � � ����� � ��� � ���z)SlackClient.run_commands_from_slack_asyncc C s2 t �d� ttj�t�j�}|d d }| �|d �\}}d|v r,|j t � |d �d� |d d }|d d }t �d|� ||v r]tj� t�}t �d |� |� |||d ��} | d } | S t �d ||� t �d |||||� tj�� �} | jt|�|||t|�d�} W d � n1 s�w Y t �d| � | S )z| :type msg: dict :param msg: The message dictionary that contains the command and all information. z#Going to run a command asynchronousrY r �pillar)r� re rf ztarget_type is: %sz(Command %s will run via runner_functions)�arg�kwargr� z5Command %s will run via local.cmd_async, targeting %szRunning %s, %s, %s, %s, %s)r� r� rf Nz ret from local.cmd_async is %s)r4 r5 �sortedr r� ZRunnerr Z functionsr� r> �astZ literal_evalr� Z asynchronousr� Z LocalClientZ cmd_async�strr< ) r rI Zrunner_functionsr] rU r� re rf r� Z job_id_dictZjob_id�localr r r r� � s< �� � � z SlackClient.run_command_asyncN)r\ )�__name__� __module__� __qualname__r r r r+ r- rB r8 rJ rQ r[ rn ru r� rj r� r� r� r� r� r r r r r � s, M'6 !L!$ � qr �!�salt/engines/slackc C s| |r|� d�st�d� t�d� td��zt| ||d�}|�||||�} |�| |||� W dS t y= t t � � � ��w )a Listen to slack events and forward them to salt, new version :type app_token: str :param app_token: The Slack application token used by Salt to communicate with Slack. :type bot_token: str :param bot_token: The Slack bot token used by Salt to communicate with Slack. :type control: bool :param control: Determines whether or not commands sent from Slack with the trigger string will control Salt, defaults to False. :type trigger: str :param trigger: The string that should preface all messages in Slack that should be treated as commands to send to Salt. :type group: str :param group: The string that should preface all messages in Slack that should be treated as commands to send to Salt. :type groups_pillar: str :param group_pillars: A pillar key that can be used to pull group configuration. :type fire_all: bool :param 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 events will be prefixed with the string specified by the ``tag`` config option (default: ``salt/engines/slack``). :type tag: str :param tag: The tag to prefix all events sent to the Salt event bus. Zxoxb� z%Slack bot token not found, bailing...z%Slack Engine bot token not configured)r r r N) r_ r� r� r4 r� r� r r� r� r� � traceback� format_exc) r r r� ZtriggerrN rA r� rH r� r� r r r �start s * �� �r� )Fr� NNFr� ) �__doc__r� r r� r6 �loggingr r� r� Z salt.clientr Z salt.loaderZ salt.minionZ salt.outputZ salt.runnerZsalt.utils.argsZsalt.utils.eventZsalt.utils.httpZsalt.utils.jsonZsalt.utils.slackZsalt.utils.yamlr Z slack_bolt.adapter.socket_moder � ImportError� getLoggerr� r4 r r r r� r r r r �<module> sZ 3 � 5�
| ver. 1.4 |
Github
|
.
| PHP 8.2.30 | Generation time: 0 |
proxy
|
phpinfo
|
Settings