Current File : //lib/python2.7/site-packages/salt/utils/docker/translate/helpers.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 d l m
Z
d d l m Z d d l
m Z m Z e � Z d d d � Z d
d � Z d � Z d
� Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z e d � Z d d � Z! d � Z" d S( u\
Functions to translate input in the docker CLI format to the format desired by
by the API.
i ( t absolute_importt print_functiont unicode_literalsN( t SaltInvocationError( t six( t ranget zipu ,i����c C@ s) g | j | | � D] } | j � ^ q S( N( t splitt strip( t itemt sept maxsplitt x( ( sG /usr/lib/python2.7/site-packages/salt/utils/docker/translate/helpers.pyR s u tcpc C@ s� y | j d � \ } } } Wn t k
r/ n X| r? | } n y& | j � d k rd t | � d f SWn t k
rx n Xt | � S( u`
Given a port number and protocol, returns the port definition expected by
docker-py. For TCP ports this is simply an integer, for UDP ports this is
(port_num, 'udp').
port_num can also be a string in the format 'port_num/udp'. If so, the
"proto" argument will be ignored. The reason we need to be able to pass in
the protocol separately is because this function is sometimes invoked on
data derived from a port range (e.g. '2222-2223/udp'). In these cases the
protocol has already been stripped off and the port range resolved into the
start and end of the range, and get_port_def() is invoked once for each
port number in that range. So, rather than munge udp ports back into
strings before passing them to this function, the function will see if it
has a string and use the protocol from it if present.
This function does not catch the TypeError or ValueError which would be
raised if the port number is non-numeric. This function either needs to be
run on known good input, or should be run within a try/except that catches
these two exceptions.
u /u udp( t partitiont AttributeErrort lowert int( t port_numt protot _t port_num_proto( ( sG /usr/lib/python2.7/site-packages/salt/utils/docker/translate/helpers.pyt get_port_def s
c C@ s� t | t j � r | | f Syv g t | d � D] } t | � ^ q/ } t | � d k rj | d } } n | \ } } | | k r� t d � � n Wn[ t t f k
r� } | j � d k r� d j | | � } n d j | � } t | � � n X| | f Sd S( u�
Given a port number or range, return a start and end to that range. Port
ranges are defined as a string containing two numbers separated by a dash
(e.g. '4505-4506').
A ValueError will be raised if bad input is provided.
u -i i u start > enduH Start of port range ({0}) cannot be greater than end of port range ({1})u- '{0}' is non-numeric or an invalid port rangeN(
t
isinstanceR t
integer_typesR R t lent
ValueErrort TypeErrort __str__t format( t port_defR t compst range_startt range_endt exct msg( ( sG /usr/lib/python2.7/site-packages/salt/utils/docker/translate/helpers.pyt get_port_range> s"
( c
O@ s@ | j d t � } t | � } t | � } xt | � D]\ } } t | t � s7 g | j d � D] } | j � ^ qb } t | � } | | k r� | t k r� t d j
| | | � � � n | j | g | | � nE | | k r t d j
| | | t k r| n d j
| � � � � n t t | | � � | | <q7 q7 W| S( u�
Many arguments come in as a list of VAL1:VAL2 pairs, but map to a list
of dicts in the format {NAME1: VAL1, NAME2: VAL2}. This function
provides common code to handle these instances.
u fillu :u* '{0}' contains {1} value(s) (expected {2})u up to {0}(
t popt NOTSETR t translate_stringlistt enumerateR t dictR R R R t extendR (
t valt namest
extra_optst fillt expected_num_elementst idxR R t elementst num_elements( ( sG /usr/lib/python2.7/site-packages/salt/utils/docker/translate/helpers.pyt map_vals` s, ( c C@ sI y1 t j j j | � s0 t d j | � � � n Wn t k
rD n Xd S( Nu '{0}' is not a valid IP address( t saltt utilst networkt is_ipR R t RuntimeError( R* ( ( sG /usr/lib/python2.7/site-packages/salt/utils/docker/translate/helpers.pyt validate_ip� s
c C@ sI y1 t j j j | � s0 t d j | � � � n Wn t k
rD n Xd S( Nu '{0}' is not a valid subnet( R3 R4 R5 t is_subnetR R R7 ( R* ( ( sG /usr/lib/python2.7/site-packages/salt/utils/docker/translate/helpers.pyt validate_subnet� s
c C@ s# t | t j � s t j | � S| S( N( R R t string_typest text_type( R* ( ( sG /usr/lib/python2.7/site-packages/salt/utils/docker/translate/helpers.pyt
translate_str� s c C@ sX t | t j � sT y t | � } WqT t t f k
rP t d j | � � � qT Xn | S( Nu '{0}' is not an integer( R R R R R R R R ( R* ( ( sG /usr/lib/python2.7/site-packages/salt/utils/docker/translate/helpers.pyt
translate_int� s c C@ s t | t � s t | � S| S( N( R t bool( R* ( ( sG /usr/lib/python2.7/site-packages/salt/utils/docker/translate/helpers.pyt translate_bool� s c C@ s+ t | t � s' t d j | � � � n | S( uN
Not really translating, just raising an exception if it's not a dict
u '{0}' is not a dictionary( R R( R R ( R* ( ( sG /usr/lib/python2.7/site-packages/salt/utils/docker/translate/helpers.pyt translate_dict� s c C@ s� t | t j � r | St | t � ru x\ t t | � � D]6 } t | | t j � s8 t j | | � | | <q8 q8 Wn t j | � } | S( u�
Input should either be a single string, or a list of strings. This is used
for the two args that deal with commands ("command" and "entrypoint").
( R R R; t listR R R< ( R* R/ ( ( sG /usr/lib/python2.7/site-packages/salt/utils/docker/translate/helpers.pyt translate_command� s !c C@ sR y t | � } Wn; t t f k
rM t | t j � sN t j | � } qN n X| S( uz
These values can be expressed as an integer number of bytes, or a string
expression (i.e. 100mb, 1gb, etc.).
( R R R R R R; R< ( R* ( ( sG /usr/lib/python2.7/site-packages/salt/utils/docker/translate/helpers.pyt translate_bytes� s c C@ s� t | t � sK y t | � } WqK t k
rG t t j | � � } qK Xn xJ t t | � � D]6 } t | | t j � s^ t j | | � | | <q^ q^ W| S( uj
On the CLI, these are passed as multiple instances of a given CLI option.
In Salt, we accept these as a comma-delimited list but the API expects a
Python list. This function accepts input and returns it back as a Python
list of strings. If the input is a string which is a comma-separated list
of items, split that string and return it.
( R RB R R R R< R R R; ( R* R/ ( ( sG /usr/lib/python2.7/site-packages/salt/utils/docker/translate/helpers.pyR& � s
c C@ s t | d d � } xt t | � � D]� } y t j j | | d � } Wn t k
rb t } n X| s� t d j | | � � � n y t
| | d � | | d <Wn t t f k
r� n X| r% y t
| | d � | | d <Wqt k
rt d j | | � � � qXq% q% W| S( u�
CLI input is a list of PATH:RATE pairs, but the API expects a list of
dictionaries in the format [{'Path': path, 'Rate': rate}]
u Pathu Rateu Path '{Path}' is not absoluteu. Rate '{Rate}' for path '{Path}' is non-numeric(
R2 R R t ost patht isabsR t FalseR R R R R ( R* t numeric_rateR/ t is_abs( ( sG /usr/lib/python2.7/site-packages/salt/utils/docker/translate/helpers.pyt translate_device_rates� s*
u =c C@ s� t | t � r | St | � } i } xi | D]a } y t | | d � \ } } Wn2 t t t f k
r� t d j | | � � � n X| | | <q, W| S( um
CLI input is a list of key/val pairs, but the API expects a dictionary in
the format {key: val}
i u '{0}' is not a key{1}value pair( R R( R& R R R R R R ( R* t delimitert new_valR t lvaluet rvalue( ( sG /usr/lib/python2.7/site-packages/salt/utils/docker/translate/helpers.pyt translate_key_val s
c C@ s. t | t � s*t | t � s- t | � } n i } x� | D]� } t | t � r� t | � d k rp t d � � n t t | � � } | | } n< y t | d d � \ } } Wn t k
r� | } d } n Xt | t j
� s� t j | � } n t | t j
� st j | � } n | | | <q: W| } n | S( u�
Can either be a list of label names, or a list of name=value pairs. The API
can accept either a list of label names or a dictionary mapping names to
values, so the value we translate will be different depending on the input.
i u Invalid label(s)u =u ( R R( RB R R R t nextt iterR R R; R< ( R* RM R t key( ( sG /usr/lib/python2.7/site-packages/salt/utils/docker/translate/helpers.pyt translate_labels s,
(# t __doc__t
__future__R R R RE t salt.utils.dataR3 t salt.utils.networkt salt.exceptionsR t salt.extR t salt.ext.six.movesR R t objectR% R R R# R2 R8 R: R= R> R@ RA RC RD R& t TrueRK RP RT ( ( ( sG /usr/lib/python2.7/site-packages/salt/utils/docker/translate/helpers.pyt <module> s0 $ " "
#
Mini Shell