Current File : //proc/self/root/proc/thread-self/root/lib/python2.7/site-packages/salt/pillar/sql_base.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 m Z d d l m
Z
d d l m Z e j
e � Z d � Z d e j e j e � f d � � YZ d S(
u>
Retrieve Pillar data by doing a SQL query
This module is not meant to be used directly as an ext_pillar.
It is a place to put code common to PEP 249 compliant SQL database adapters.
It exposes a python ABC that can be subclassed for new database providers.
:maturity: new
:platform: all
Theory of sql_base ext_pillar
=============================
Ok, here's the theory for how this works...
- First, any non-keyword args are processed in order.
- Then, remaining keywords are processed.
We do this so that it's backward compatible with older configs.
Keyword arguments are sorted before being appended, so that they're predictable,
but they will always be applied last so overall it's moot.
For each of those items we process, it depends on the object type:
- Strings are executed as is and the pillar depth is determined by the number
of fields returned.
- A list has the first entry used as the query, the second as the pillar depth.
- A mapping uses the keys "query" and "depth" as the tuple
You can retrieve as many fields as you like, how they get used depends on the
exact settings.
Configuring a sql_base ext_pillar
=================================
The sql_base ext_pillar cannot be used directly, but shares query configuration
with its implementations. These examples use a fake 'sql_base' adapter, which
should be replaced with the name of the adapter you are using.
A list of queries can be passed in
.. code-block:: yaml
ext_pillar:
- sql_base:
- "SELECT pillar,value FROM pillars WHERE minion_id = %s"
- "SELECT pillar,value FROM more_pillars WHERE minion_id = %s"
Or you can pass in a mapping
.. code-block:: yaml
ext_pillar:
- sql_base:
main: "SELECT pillar,value FROM pillars WHERE minion_id = %s"
extras: "SELECT pillar,value FROM more_pillars WHERE minion_id = %s"
The query can be provided as a string as we have just shown, but they can be
provided as lists
.. code-block:: yaml
ext_pillar:
- sql_base:
- "SELECT pillar,value FROM pillars WHERE minion_id = %s"
2
Or as a mapping
.. code-block:: yaml
ext_pillar:
- sql_base:
- query: "SELECT pillar,value FROM pillars WHERE minion_id = %s"
depth: 2
The depth defines how the dicts are constructed.
Essentially if you query for fields a,b,c,d for each row you'll get:
- With depth 1: {a: {"b": b, "c": c, "d": d}}
- With depth 2: {a: {b: {"c": c, "d": d}}}
- With depth 3: {a: {b: {c: d}}}
Depth greater than 3 wouldn't be different from 3 itself.
Depth of 0 translates to the largest depth needed, so 3 in this case.
(max depth == key count - 1)
Then they are merged in a similar way to plain pillar data, in the order
returned by the SQL database.
Thus subsequent results overwrite previous ones when they collide.
The ignore_null option can be used to change the overwrite behavior so that
only non-NULL values in subsequent results will overwrite. This can be used
to selectively overwrite default values.
.. code-block:: yaml
ext_pillar:
- sql_base:
- query: "SELECT pillar,value FROM pillars WHERE minion_id = 'default' and minion_id != %s"
depth: 2
- query: "SELECT pillar,value FROM pillars WHERE minion_id = %s"
depth: 2
ignore_null: True
If you specify `as_list: True` in the mapping expression it will convert
collisions to lists.
If you specify `with_lists: '...'` in the mapping expression it will
convert the specified depths to list. The string provided is a sequence
numbers that are comma separated. The string '1,3' will result in::
a,b,c,d,e,1 # field 1 same, field 3 differs
a,b,c,f,g,2 # ^^^^
a,z,h,y,j,3 # field 1 same, field 3 same
a,z,h,y,k,4 # ^^^^
^ ^
These columns define list grouping
.. code-block:: python
{a: [
{c: [
{e: 1},
{g: 2}
]
},
{h: [
{j: 3, k: 4 }
]
}
]}
The range for with_lists is 1 to number_of_fields, inclusive.
Numbers outside this range are ignored.
Finally, if you pass the queries in via a mapping, the key will be the
first level name where as passing them in as a list will place them in the
root. This isolates the query results into their own subtrees.
This may be a help or hindrance to your aims and can be used as such.
You can basically use any SELECT query that gets you the information, you
could even do joins or subqueries in case your minion_id is stored elsewhere.
It is capable of handling single rows or multiple rows per minion.
Configuration of the connection depends on the adapter in use.
More complete example for MySQL (to also show configuration)
============================================================
.. code-block:: yaml
mysql:
user: 'salt'
pass: 'super_secret_password'
db: 'salt_db'
ext_pillar:
- mysql:
fromdb:
query: 'SELECT col1,col2,col3,col4,col5,col6,col7
FROM some_random_table
WHERE minion_pattern LIKE %s'
depth: 5
as_list: True
with_lists: [1,3]
i ( t absolute_importt print_functiont unicode_literalsN( t OrderedDict( t range( t sixc C@ s t S( N( t False( ( ( s8 /usr/lib/python2.7/site-packages/salt/pillar/sql_base.pyt __virtual__� s t SqlBaseExtPillarc B@ s� e Z d Z d
Z d
Z d
Z d Z d Z e Z
d
Z e Z d � Z
e e j d � � � Z e j d � � Z d � Z d � Z d � Z d � Z d � Z RS( u]
This class receives and processes the database rows in a database
agnostic way.
i c C@ s i | _ | _ d S( N( t resultt focus( t self( ( s8 /usr/lib/python2.7/site-packages/salt/pillar/sql_base.pyt __init__� s c C@ s d S( ut
Return a friendly name for the database, e.g. 'MySQL' or 'SQLite'.
Used in logging output.
N( ( t cls( ( s8 /usr/lib/python2.7/site-packages/salt/pillar/sql_base.pyt _db_name� s c C@ s d S( uH
Yield a PEP 249 compliant Cursor as a context manager.
N( ( R ( ( s8 /usr/lib/python2.7/site-packages/salt/pillar/sql_base.pyt _get_cursor� s c C@ sQ g } | j g | D] } d
| g ^ q � t | j � � } | j � | j g | D] } | | | g ^ qU � g | D]� } t | d t j � r� t | d � st | d t t f � r� t | d � d k r� | d d st | d t
� ry d | d k ry t | d d � ry | ^ qy } x%| D] } i d d 6d d 6t d 6d
d 6t d 6} t | d t j � r�| d | d <n� t | d t t f � r�| d d | d <t | d � d k r?| d d | d <q?nd | j | d � | d r?t | d t j � r?g | d j
d � D] }
t |
� ^ q | d <n | | d <q,W| S( u�
This function normalizes the config block into a set of queries we
can use. The return is a list of consistently laid out dicts.
i i u queryu u depthu as_listu
with_listsu ignore_nullu ,N( t extendt Nonet listt keyst sortt
isinstanceR t string_typest lent tuplet dictR t updatet splitt int( R t argst kwargst qbuffert st klistt kt xt qbt defaultst i( ( s8 /usr/lib/python2.7/site-packages/salt/pillar/sql_base.pyt extract_queries� s4 &
*
&=C
3c C@ s- | r i | j | <| _ n | j | _ d S( u2
Set self.focus for kwarg queries
N( R R
( R t root( ( s8 /usr/lib/python2.7/site-packages/salt/pillar/sql_base.pyt
enter_root s c C@ sS | | _ t | � | _ | d k s3 | | j k rF | j d | _ n | | _ d S( u�
The primary purpose of this function is to store the sql field list
and the depth to which we process.
i i N( t field_namesR t
num_fieldst depth( R R* R, ( ( s8 /usr/lib/python2.7/site-packages/salt/pillar/sql_base.pyt process_fields( s
c
C@ s_ t � } t � } x�| D]�} | j } x�t d | j d � D]i} | d | j k r� t | � | k r� g | t | � <| | t | � <n | | | t | � k r� | t | � j | | � q� n | | | k r� i | | | <| | | } q? t | | | � } | t k r;i } | | | j | � | } q? | t k r�| j
r{i } | | | | g | | | <| } q�i | | | <| | | } q? | | | } q? W| j | j d k r�| j d } | j
r�| | | k s�| d | j k rr| | | k rAt | | | t � sO| | | g | | | <qOn g | | | <| | | j | | j d � q�| j
s�| | j d d k r�| | j d | | | <q�q | | j d | k r�i | | | j d <n | j | j k rqt | � | k r(g | t | � <| | t | � <n | | j d | t | � k rq| t | � j | | j d � qqn | | | j d } x+t | j | j � D]} | j | } | d | j k r*t | � | k r�g | t | � <| | t | � <n | | t | � k r*| t | � j | � q*n | j
r�| | k r�t | | t � rj| | j | | � q�| | | | g | | <q�| j
s�| | d k r�| | | | <q�q�Wq Wt | j � � }
|
j � x� |
D]| } | | } xi | | D]] } t | | t � r,t | | j � � | | <q�t | | t � r�| | g | | <q�q�Wq�Wd S( uz
This function takes a list of database results and iterates over,
merging them into a dict form.
i i i N( R R
R R, t
with_listst idt appendt typeR R t as_listR+ R t ignore_nullR R* R t reverset values(
R t rowst listifyt
listify_dictst rett crdR& t tyt tempt nkt kst dR" ( ( s8 /usr/lib/python2.7/site-packages/salt/pillar/sql_base.pyt process_results7 s�
!
#! !(
c
O@ s | j � } t j d | | � | j | | � } | j � �� } x� | D]� \ } } | j | d | f � | j g | j D] }
|
d ^ qz | d � | j | � | d | _ | d r� | d | _
n g | _
| d | _ | j | j
� � t j d | | � qG WWd QX| j S(
u>
Execute queries, merge and return as a dict.
u" Querying %s for information for %su queryi u depthu as_listu
with_listsu ignore_nullu ext_pillar %s: Return data: %sN( R t logt infoR' R t executeR- t descriptionR) R2 R. R3 R@ t fetchallt debugR ( R t minion_idt pillarR R t db_nameR t cursorR( t detailst row( ( s8 /usr/lib/python2.7/site-packages/salt/pillar/sql_base.pyt fetch� s .
N( t __name__t
__module__t __doc__R R R
R* R+ R, R R2 R. R3 R t classmethodt abct abstractmethodR R R' R) R- R@ RM ( ( ( s8 /usr/lib/python2.7/site-packages/salt/pillar/sql_base.pyR � s$ 8
k( RP t
__future__R R R t loggingRR t salt.utils.odictR t salt.ext.six.movesR t salt.extR t getLoggerRN RA R t with_metaclasst ABCMetat objectR ( ( ( s8 /usr/lib/python2.7/site-packages/salt/pillar/sql_base.pyt <module>� s
Mini Shell