Current File : //lib/python2.7/site-packages/salt/proxy/fx2.pyc
�
���^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 g Z i Z
i Z e j 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 S( u�
Dell FX2 chassis
================
.. versionadded:: 2015.8.2
Proxy minion interface module for managing Dell FX2 chassis (Dell
Chassis Management Controller version 1.2 and above, iDRAC8 version 2.00
and above)
Dependencies
------------
- :mod:`iDRAC Remote execution module (salt.modules.dracr) <salt.modules.dracr>`
- :mod:`Chassis command shim (salt.modules.chassis) <salt.modules.chassis>`
- :mod:`Dell Chassis States (salt.states.dellchassis) <salt.states.dellchassis>`
- Dell's ``racadm`` command line interface to CMC and iDRAC devices.
**Special Note: SaltStack thanks** `Adobe Corporation <http://adobe.com/>`_
**for their support in creating this proxy minion integration.**
This proxy minion enables Dell FX2 and FX2s (hereafter referred to as
simply "chassis", "CMC", or "FX2") chassis to be treated individually
like a salt-minion.
Since the CMC embedded in the chassis does not run an OS capable of hosting a
Python stack, the chassis can't run a minion directly. Salt's "Proxy Minion"
functionality enables you to designate another machine to host a minion
process that "proxies" communication from the salt-master. The master does not
know nor care that the target is not a real minion.
More in-depth conceptual reading on Proxy Minions can be found
:ref:`in the Proxy Minion section <proxy-minion>` of
Salt's documentation.
To configure this integration, follow these steps:
Pillar
------
Proxy minions get their configuration from Salt's Pillar. Every proxy must
have a stanza in Pillar, and a reference in the Pillar topfile that matches
the ID. At a minimum for communication with the chassis the pillar should
look like this:
.. code-block:: yaml
proxy:
host: <ip or dns name of chassis controller>
admin_username: <iDRAC username for the CMC, usually 'root'>
fallback_admin_username: <username to try if the first fails>
passwords:
- first_password
- second_password
- third-password
proxytype: fx2
The ``proxytype`` line above is critical, it tells Salt which interface to load
from the ``proxy`` directory in Salt's install hierarchy, or from ``/srv/salt/_proxy``
on the salt-master (if you have created your own proxy module, for example).
The proxy integration will try the passwords listed in order. It is
configured this way so you can have a regular password, a potential
fallback password, and the third password can be the one you intend
to change the chassis to use. This way, after it is changed, you
should not need to restart the proxy minion--it should just pick up the
third password in the list. You can then change pillar at will to
move that password to the front and retire the unused ones.
Beware, many Dell CMC and iDRAC units are configured to lockout
IP addresses or users after too many failed password attempts. This can
generate user panic in the form of "I no longer know what the password is!!!".
To mitigate panic try the web interface from a different IP, or setup a
emergency administrator user in the CMC before doing a wholesale
password rotation.
The automatic lockout can be disabled via Salt with the following:
.. code-block:: bash
salt <cmc> chassis.cmd set_general cfgRacTuning cfgRacTuneIpBlkEnable 0
and then verified with
.. code-block:: bash
salt <cmc> chassis.cmd get_general cfgRacTuning cfgRacTuneIpBlkEnable
salt-proxy
----------
After your pillar is in place, you can test the proxy. The proxy can run on
any machine that has network connectivity to your salt-master and to the chassis in question.
SaltStack recommends that this machine also run a regular minion, though
it is not strictly necessary.
On the machine that will run the proxy, make sure there is an ``/etc/salt/proxy``
file with at least the following in it:
.. code-block:: yaml
master: <ip or hostname of salt-master>
You can start the proxy with
.. code-block:: bash
salt-proxy --proxyid <id you want to give the chassis>
You may want to add ``-l debug`` to run the above in the foreground in debug
mode just to make sure everything is OK.
Next, accept the key for the proxy on your salt-master, just like you would
for a regular minion:
.. code-block:: bash
salt-key -a <id you want to give the chassis>
You can confirm that the pillar data is in place for the proxy:
.. code-block:: bash
salt <id> pillar.items
And now you should be able to ping the chassis to make sure it is responding:
.. code-block:: bash
salt <id> test.ping
At this point you can execute one-off commands against the chassis. For
example, you can get the chassis inventory:
.. code-block:: bash
salt <id> chassis.cmd inventory
Note that you don't need to provide credentials or an ip/hostname. Salt knows
to use the credentials you stored in Pillar.
It's important to understand how this particular proxy works.
:mod:`Salt.modules.dracr <salt.modules.dracr>` is a standard Salt execution
module. If you pull up the docs for it you'll see that almost every function
in the module takes credentials and a target host. When credentials and a host
aren't passed, Salt runs ``racadm`` against the local machine. If you wanted
you could run functions from this module on any host where an appropriate
version of ``racadm`` is installed, and that host would reach out over the network
and communicate with the chassis.
``Chassis.cmd`` acts as a "shim" between the execution module and the proxy. It's
first parameter is always the function from salt.modules.dracr to execute. If the
function takes more positional or keyword arguments you can append them to the call.
It's this shim that speaks to the chassis through the proxy, arranging for the
credentials and hostname to be pulled from the pillar section for this proxy minion.
Because of the presence of the shim, to lookup documentation for what
functions you can use to interface with the chassis, you'll want to
look in :mod:`salt.modules.dracr <salt.modules.dracr>` instead
of :mod:`salt.modules.chassis <salt.modules.chassis>`.
States
------
Associated states are thoroughly documented in :mod:`salt.states.dellchassis <salt.states.dellchassis>`.
Look there to find an example structure for pillar as well as an example
``.sls`` file for standing up a Dell Chassis from scratch.
i ( t absolute_importt print_functiont unicode_literalsNu fx2c C@ s# t j j j d � s t d f St S( u6
Only return if all the modules are available
u racadmu0 fx2 proxy minion needs "racadm" to be installed.( t saltt utilst patht whicht Falset True( ( ( s2 /usr/lib/python2.7/site-packages/salt/proxy/fx2.pyt __virtual__� s
c C@ sF d | d k r! t j d � t S| d d t d <t � \ } } d S( u�
This function gets called when the proxy starts up.
We check opts to see if a fallback user and password are supplied.
If they are present, and the primary credentials don't work, then
we try the backup before failing.
Whichever set of credentials works is placed in the persistent
DETAILS dictionary and will be used for further communication with the
chassis.
u hostu proxyu, No "host" key found in pillar for this proxyN( t logt criticalR t DETAILSt find_credentials( t optst usernamet password( ( s2 /usr/lib/python2.7/site-packages/salt/proxy/fx2.pyt init� s
c C@ s t j d d � S( uc
Return the admin_username in the DETAILS dictionary, or root if there
is none present
u admin_usernameu root( R t get( ( ( s2 /usr/lib/python2.7/site-packages/salt/proxy/fx2.pyt admin_username� s c C@ s- d t k r t j d � d St j d d � S( uz
Return the admin_password in the DETAILS dictionary, or 'calvin'
(the Dell default) if there is none present
u admin_passwordu? proxy.fx2: No admin_password in DETAILS, returning Dell defaultu calvin( R R
t infoR ( ( ( s2 /usr/lib/python2.7/site-packages/salt/proxy/fx2.pyt admin_password� s
c C@ s t d S( Nu host( R ( ( ( s2 /usr/lib/python2.7/site-packages/salt/proxy/fx2.pyt host� s c C@ sJ t d d | d | d | � } | j d d � d k r@ | } n i } | S( u0
Get the grains from the proxied device
u dracr.system_infoR R R u retcodei ( t __salt__R ( R t userR t rt GRAINS_CACHE( ( s2 /usr/lib/python2.7/site-packages/salt/proxy/fx2.pyt _grains� s c C@ s& t s" t t d t d t d � St S( u0
Get the grains from the proxied device
u hostu admin_usernameu admin_password( R R R ( ( ( s2 /usr/lib/python2.7/site-packages/salt/proxy/fx2.pyt grains s
c C@ s
i } t � S( u4
Refresh the grains from the proxied device
( R ( R ( ( s2 /usr/lib/python2.7/site-packages/salt/proxy/fx2.pyt grains_refresh s c C@ sN t d j d d � g } d t j d � k rK | j t d j d � � n x� | D]� } x� t d d D]� } t d d t d d d | d
| � } yV | j d d � d k r� | t d <| t d <| t d d <| t d d <| | f SWqg t k
r4| t d <| t d <| t d d <| t d d <| | f SXqg WqR Wt j d
� d S( u\
Cycle through all the possible credentials and return the first one that
works
u proxyu admin_usernameu rootu fallback_admin_usernameu passwordsu dracr.get_chassis_nameR u hostR R u retcodeu admin_passworduI proxy fx2.find_credentials found no valid credentials, using Dell defaultu calvinN( u rootu calvin(
t
__pillar__R t appendR t NoneR t __opts__t AttributeErrorR
t debug( t usernamesR t pwdR ( ( s2 /usr/lib/python2.7/site-packages/salt/proxy/fx2.pyR
s.
c O@ s� x3 t | � D]% } | j d � r
| j | � q
q
Wd | t k re i d d 6d | d d 6} n t d | | | � } | d k r� d | k r� | d t d d
<| d t d
<n d | k r� | d t d d <| d t d <q� n | S(
u�
This function is called by the :mod:`salt.modules.chassis.cmd <salt.modules.chassis.cmd>`
shim. It then calls whatever is passed in ``cmd``
inside the :mod:`salt.modules.dracr <salt.modules.dracr>`
module.
:param cmd: The command to call inside salt.modules.dracr
:param args: Arguments that need to be passed to that command
:param kwargs: Keyword arguments that need to be passed to that command
:return: Passthrough the return from the dracr module.
u __pub_u dracr.i����u retcodeu is not availableu messageu change_passwordu usernameu proxyu admin_usernameu passwordu admin_password( t listt
startswitht popR R! R ( t cmdt argst kwargst kt ret( ( s2 /usr/lib/python2.7/site-packages/salt/proxy/fx2.pyt chconfig< s c C@ s| t d d t d d t d d t d � } | j d d � d
k rG t St Sy | d j d t � SWn t k
rw t SXd
S( up
Is the chassis responding?
:return: Returns False if the chassis didn't respond, True otherwise.
u dracr.system_infoR u hostR u admin_usernameR u admin_passwordu retcodei i u dictu retN( R R R R R t Exception( R ( ( s2 /usr/lib/python2.7/site-packages/salt/proxy/fx2.pyt ping_ s
c C@ s t j d � d S( u`
Shutdown the connection to the proxied device.
For this proxy shutdown is a no-op.
u fx2 proxy shutdown() called...N( R
R# ( R ( ( s2 /usr/lib/python2.7/site-packages/salt/proxy/fx2.pyt shutdowns s ( t __doc__t
__future__R R R t loggingt salt.utils.httpR t salt.utils.patht __proxyenabled__R R t getLoggert __file__R
R R R R R R R R R
R. R0 R1 ( ( ( s2 /usr/lib/python2.7/site-packages/salt/proxy/fx2.pyt <module>� s( # #
Mini Shell