File: //opt/saltstack/salt/lib/python3.10/site-packages/salt/netapi/__pycache__/__init__.cpython-310.pyc
o
�N�g�) � @ s� d Z ddlZddlZddlZddlZddlZddlZddlZddl Zddl
Zddl Zddl Zddl
ZddlZddlZddlZddlmZ e�e�Zdd� Zdd� ZG dd � d �Zd
d � ejedd �D �ZdS )
z
Make api awesomeness
� N)�DEFAULT_TARGET_DELIMc C sZ g }g }| D ] }t |t�r||v rq|�|� q||v r q|�|� qt|�t|td� S )zZ
Return a sorted list of the passed in permissions, de-duplicating in the process
��key)�
isinstance�str�append�sorted�repr)�permsZ
_str_permsZ_non_str_perms�entry� r �H/opt/saltstack/salt/lib/python3.10/site-packages/salt/netapi/__init__.py�sorted_permissions s
r c C sv |� | d g �}|�|� dg �� d| v r9| d r9t| d �}dd� |�� D �}||@ D ] }|�||� d� � q,|S )zN
Returns the sum of '*', user-specific and group specific permissions
�name�*�groupsc S s h | ] }|� d �r|�d ��qS )�%)�endswith�rstrip)�.0�ir r r
� <setcomp>5 s z"sum_permissions.<locals>.<setcomp>r )�get�extend�set�keys)�token�eauthr
Z user_groupsZ eauth_groups�groupr r r
�sum_permissions, s r c @ s� e Zd ZdZdd� Zdd� Zdd� Zdd � Zd
d � Zd d
� Z dd� Z
dd� Z dd� Z dd� Z
d dd�Zdd� Zd d � Zd d � ZdS )!� NetapiClienta'
Provide a uniform method of accessing the various client interfaces in Salt
in the form of low-data data structures. For example:
>>> client = NetapiClient(__opts__)
>>> lowstate = {'client': 'local', 'tgt': '*', 'fun': 'test.ping', 'arg': ''}
>>> client.run(lowstate)
c C s� || _ t�| j �}d|d< tj�|d d�|d< tj�|d �s't�|d � tj �
|�| _ tj � |�| _
tjj�|�| _tjj�|�| _d S )NTZenable_ssh_minionsZcachedirZsaltapi)�opts�copy�deepcopy�os�path�join�exists�makedirs�saltZauthZResolverZresolverZLoadAuth�loadauthZdaemonsZ masterapiZ access_keysr �utils�minionsZ CkMinions� ckminions)�selfr! Zapioptsr r r
�__init__F s zNetapiClient.__init__c C sD t jj�� rdS | jd dkrd}nd}tj�tj�| jd |��S )z�
Perform a lightweight check to see if the master daemon is running
Note, this will return an invalid success if the master crashed or was
not shut down cleanly.
TZ transportZtcpzpublish_pull.ipcz workers.ipcZsock_dir) r) r+ �platformZ
is_windowsr! r$ r% r' r& )r. Zipc_filer r r
�_is_master_runningR s z NetapiClient._is_master_runningc C sZ g }d }d|v rd}d}dg}||||fS d|v r'd}d}ddg}||||fS t j�d��)Nr ZTokenAuthenticationErrorr �EauthAuthenticationError�username�password�#No authentication credentials given)r) �
exceptionsr2 )r. Z
clear_load�sensitive_load_keysr � auth_type�err_namer r r
�_prep_auth_infod s �z NetapiClient._prep_auth_infoc C s� | � |�\}}}}| jj|||d�}|�dg �}|�d�}|r%tj�|��|�di ��dt�} | j� |d |�dd�| �}
|
�d t
� �} |
�d
t
� �} | jj ||d |�d g �|d |�dd�| d
�}
|
sktj�d��d S )Nr � auth_list�error�kwargs� delimiterZtgtZtgt_type�globr, �missing�fun�arg)r, z Authorization error occurred.) r: r* Zcheck_authenticationr r) r6 r2 r r- Z
check_minions�list�
auth_check)r. �lowr8 r9 r r7 rD r; r< r> Z_resr, r@ Z
authorizedr r r
�_authorize_sshu s2
�
���zNetapiClient._authorize_sshc C s� | � � s
tj�d��|�d�tvr tj�d�|�d����|�d�| j�d�vr4tj�d�|�d����d|v sBd|v sBtj� d��|�d �rS| j�d
�sStj� d ��|d d kr^| �
|� t | |d �}tj j
�||�}||�d
d�i |�di ���S )zh
Execute the specified function in the specified client by passing the
lowstate
z Salt Master is not available.�clientz Invalid client specified: '{}'Znetapi_enable_clientszUClient disabled: '{}'. Add to 'netapi_enable_clients' master config option to enable.r r r5 Z raw_shellZnetapi_allow_raw_shellz Raw shell option not allowed.�ssh�argsr r= )r1 r) r6 ZSaltDaemonNotRunningr �CLIENTSZSaltInvocationError�formatr! r2 rF �getattrr+ rI Z format_call)r. rE Zl_funZf_callr r r
�run� s2 �����
zNetapiClient.runc O �D t jj| jd��}|j|i |��W d � S 1 sw Y dS )z�
Run :ref:`execution modules <all-salt.modules>` asynchronously
Wraps :py:meth:`salt.client.LocalClient.run_job`.
:return: job ID
��moptsN)r) rG �get_local_clientr! Zrun_job�r. rI r= rG r r r
� local_async� � $�zNetapiClient.local_asyncc O rN )a
Run :ref:`execution modules <all-salt.modules>` synchronously
See :py:meth:`salt.client.LocalClient.cmd` for all available
parameters.
Sends a command from the master to the targeted minions. This is the
same interface that Salt's own CLI uses. Note the ``arg`` and ``kwarg``
parameters are sent down to the minion(s) and the given function,
``fun``, is called with those parameters.
:return: Returns the result from the execution module
rO N)r) rG rQ r! �cmdrR r r r
�local� s $�zNetapiClient.localc O rN )z�
Run :ref:`execution modules <all-salt.modules>` against subsets of minions
.. versionadded:: 2016.3.0
Wraps :py:meth:`salt.client.LocalClient.cmd_subset`
rO N)r) rG rQ r! Z
cmd_subsetrR r r r
� local_subset� rT zNetapiClient.local_subsetc O rN )a
Run :ref:`execution modules <all-salt.modules>` against batches of minions
.. versionadded:: 0.8.4
Wraps :py:meth:`salt.client.LocalClient.cmd_batch`
:return: Returns the result from the exeuction module for each batch of
returns
rO N)r) rG rQ r! Z cmd_batchrR r r r
� local_batch� s $�zNetapiClient.local_batchc O sD t jjjj| jdd��
}|�|�W d � S 1 sw Y dS )z�
Run salt-ssh commands synchronously
Wraps :py:meth:`salt.client.ssh.client.SSHClient.cmd_sync`.
:return: Returns the result from the salt-ssh command
T)rP Zdisable_custom_rosterN)r) rG rH Z SSHClientr! �cmd_syncrR r r r
rH � s
�$�zNetapiClient.sshNFc K s& ||d< t j�| j�}|j|||d�S )a<
Run `runner modules <all-salt.runners>` synchronously
Wraps :py:meth:`salt.runner.RunnerClient.cmd_sync`.
Note that runner functions must be called using keyword arguments.
Positional arguments are not supported.
:return: Returns the result from the runner module
rA )�timeout� full_return)r) �runner� RunnerClientr! rY )r. rA rZ r[ r= r\ r r r
r\ � s zNetapiClient.runnerc K � ||d< t j�| j�}|�|�S )aG
Run `runner modules <all-salt.runners>` asynchronously
Wraps :py:meth:`salt.runner.RunnerClient.cmd_async`.
Note that runner functions must be called using keyword arguments.
Positional arguments are not supported.
:return: event data and a job ID for the executed function.
rA )r) r\ r] r! � cmd_async)r. rA r= r\ r r r
� runner_async �
zNetapiClient.runner_asyncc K r^ )a=
Run :ref:`wheel modules <all-salt.wheel>` synchronously
Wraps :py:meth:`salt.wheel.WheelClient.master_call`.
Note that wheel functions must be called using keyword arguments.
Positional arguments are not supported.
:return: Returns the result from the wheel module
rA )r) �wheel� WheelClientr! rY �r. rA r= rb r r r
rb ra zNetapiClient.wheelc K r^ )a>
Run :ref:`wheel modules <all-salt.wheel>` asynchronously
Wraps :py:meth:`salt.wheel.WheelClient.master_call`.
Note that wheel functions must be called using keyword arguments.
Positional arguments are not supported.
:return: Returns the result from the wheel module
rA )r) rb rc r! r_ rd r r r
� wheel_async& ra zNetapiClient.wheel_async)NF)�__name__�
__module__� __qualname__�__doc__r/ r1 r: rF rM rS rV rW rX rH r\ r` rb re r r r r
r < s (
r c C s& g | ]\}}|d ks|� d�s|�qS )rM �_)�
startswith)r r rj r r r
�
<listcomp>6 s
�rl )� predicate)ri r" �inspect�loggingr$ Z salt.authr) Z salt.clientZsalt.client.ssh.clientZ salt.configZsalt.daemons.masterapiZsalt.exceptionsZ salt.runnerZ
salt.syspathsZsalt.utils.argsZsalt.utils.minionsZ
salt.wheelZ
salt.defaultsr � getLoggerrf �logr r r �
getmembersrJ r r r r
�<module> s2
{
�