Hg>3ddlmZmZmZmZmZddlmZddlZddl Z e j e Z Gdde ZGddeZGdd eZGd d eZGd d eZGddeZdS))TupleOptionalAnyUnionIterator)DeviceNceZdZdS) _MatchInvalidN)__name__ __module__ __qualname__J/usr/lib/python3/dist-packages/ceph/deployment/drive_selection/matchers.pyr r sDrr c$eZdZdZdZdZdZdS)Matcherz} The base class to all Matchers It holds utility methods such as _get_disk_key and handles the initialization. c0||_||_d|_dS)z Initialization of Base class :param str key: Attribute like 'model, size or vendor' :param str value: Value of attribute like 'X123, 5G or samsung' N)keyvalue fallback_keyselfrrs r__init__zMatcher.__init__s  rc|}dtttfdtdt tffd t||j}|s%|jrt||j}|r|dStd |j|j)am Helper method to safely extract values form the disk dict There is a 'key' and a _optional_ 'fallback' key that can be used. The reason for this is that the output of ceph-volume is not always consistent (due to a bug currently, but you never know). There is also a safety measure for a disk_key not existing on virtual environments. ceph-volume apparently sources its information from udev which seems to not populate certain fields on VMs. :raises: A generic Exception when no disk_key could be found. :return: A disk value :rtype: str nodekey_valreturnc3Kt|tr|D]}||D]}|VdSt|tr8||vr ||V|D]}||D]}|VdSdS)z( Find keys in non-flat dict recursively N) isinstancelistdictvalues)rrirjfindkeyss rr&z'Matcher._get_disk_key..findkeys9s$%% """A'x733""! """D$'' "d??w-'''""A'x733""! "  " """rrzNo value found for {} or {}) to_jsonrr!r"strrrrr format)rdevicedisk disk_valuer&s @r _get_disk_keyzMatcher._get_disk_key%s$~~ "5t, "s "x} " " " " " "((42233  Ad/ AhhtT->??@@J  .a=  = D D$+!-!-.. .rct)z Implements a valid comparison method for a SubMatcher This will get overwritten by the individual classes :param dict disk: A disk representation )NotImplementedErrorrr+s rcomparezMatcher.comparePs "!rN)r r r __doc__rr-r1rrrrrsL   ).).).V"""""rrc eZdZdZddZdZdS)SubstringMatcherz Substring matcher subclass NcLt|||||_dSNrrrrrrrs rrzSubstringMatcher.__init___s(sE***(rch|sdS||}t|j|vrdSdS)z Overwritten method to match substrings This matcher does substring matching :param dict disk: A disk representation (see base for examples) :return: True/False if the match succeeded :rtype: bool FT)r-r(r)rr+r,s rr1zSubstringMatcher.comparedsA 5''-- tz??j ( (4urr6r r r r2rr1rrrr4r4[sA)))) rr4c eZdZdZddZdZdS) AllMatcherz All matcher subclass NcLt|||||_dSr6r7r8s rrzAllMatcher.__init__zs* sE***(rc|sdSdS)a Overwritten method to match all A rather dumb matcher that just accepts all disks (regardless of the value) :param dict disk: A disk representation (see base for examples) :return: always True :rtype: bool FTrr0s rr1zAllMatcher.compares 5trr6r:rrrr<r<vsA))))     rr<ceZdZdZdZdZdS)EqualityMatcherz Equality matcher subclass c>t|||dSr6)rrrs rrzEqualityMatcher.__init__s" sE*****rc|sdS||}||jk}|s3td||j|S)z Overwritten method to match equality This matcher does value comparison :param dict disk: A disk representation :return: True/False if the match succeeded :rtype: bool Fz{} != {})r-rloggerdebugr))rr+r,rets rr1zEqualityMatcher.comparesb 5''-- DJ& D LL**:tzBB C C C rNr:rrrr@r@s<+++ rr@cneZdZdZgdgdgdfZededzZdZedZej d Zed Z e j d Z ed Z e j d Z e dZ e dZe dZddZedZedZdZdS) SizeMatcherz Size matcher subclass )KBMBGBTB)KMGT)g@@g.AgeAgmBrct|||d|_d|_d|_d|_d|_d|_d|_d|_ | dS)Nhuman_readable_sizesize) rrrr_high _high_suffix_low _low_suffix_exact _exact_suffix _parse_filterrs rrzSizeMatcher.__init__sp sE***("    ! rc|j|jfS)z# Getter for 'low' matchers rVrWrs rlowzSizeMatcher.lows y$***rc$|\|_|_dS)z# Setter for 'low' matchers Nr\)rr^s rr^zSizeMatcher.lows '*# 4###rc|j|jfS)z$ Getter for 'high' matchers rTrUr]s rhighzSizeMatcher.highs z4,,,rc$|\|_|_dS)z$ Setter for 'high' matchers Nra)rrbs rrbzSizeMatcher.highs )-% D%%%rc|j|jfS)z% Getter for 'exact' matchers rXrYr]s rexactzSizeMatcher.exacts {D...rc$|\|_|_dS)z% Setter for 'exact' matchers Nre)rrfs rrfzSizeMatcher.exacts +0' T'''rc|}||jvr"td|t t |jd|jd||S)a Normalize any supported suffix Since the Drive Groups are user facing, we simply can't make sure that all users type in the requested form. That's why we have to internally agree on one format. It also checks if any of the supported suffixes was used and raises an Exception otherwise. :param str suffix: A suffix ('G') or ('M') :return: A normalized output :rtype: str zUnit '{}' not supportedrPr)uppersupported_suffixesr r)r"zipSUFFIXESget)clssuffixs r_normalize_suffixzSizeMatcher._normalize_suffixs} / / / 9 @ @ H HII IC LO LO     3vv   rc^|tjd|dS)z Wrapper method to find and normalize a prefix :param str obj: A size filtering string ('10G') :return: A normalized unit ('GB') :rtype: str z [a-zA-Z]+r)rprefindall)rnobjs r _parse_suffixzSizeMatcher._parse_suffix s)$$RZ c%B%B1%EFFFrcbtjd|d||fS)ai Helper method to extract data from a string It uses regex to extract all digits and calls _parse_suffix which also uses a regex to extract all letters and normalizes the resulting suffix. :param str data: A size filtering string ('10G') :return: A Tuple with normalized output (10, 'GB') :rtype: tuple z \d+\.?\d*r)rrrsru)rndatas r_get_k_vzSizeMatcher._get_k_vs.z,--a0#2C2CD2I2IIIrrNc*tjd|j}|^|d\}}|||_|||_tjd|j}|r,|||_tjd|j}|r,|||_tjd|j}|r,|||_|js5|js0|js+td |jdSdSdS)a Identifies which type of 'size' filter is applied There are four different filtering modes: 1) 10G:50G (high-low) At least 10G but at max 50G of size 2) :60G At max 60G of size 3) 50G: At least 50G of size 4) 20G Exactly 20G in size This method uses regex to identify and extract this information and raises if none could be found. z\d+[A-Z]{1,2}:\d+[A-Z]{1,2}N:z\d+[A-Z]{1,2}:$z^:\d+[A-Z]{1,2}z^\d+\.?\d*[A-Z]{1,2}$zCouldn't parse {}) rrmatchrgroupsplitrxr^rbrfr r))rlow_highlowparthighpartr^rbrfs rrZzSizeMatcher._parse_filter'sm(8:DJGG   ( 0 0 6 6s ; ; GX}}W--DH h//DIh)4:66  2}}SYY[[11DHx*DJ77  4 djjll33DI14:>>  6u{{}}55DJx H  H$* H 3 : :4: F FGG G H H H H H Hrc|\}}|t|nd}tttjdtjdt |d|zS)z Convert any supported unit to bytes :param tuple tpl: A tuple with ('10', 'GB') :return: The converted byte value :rtype: float Ngr)floatr"rkrGrlrmr()tplval_strrors rto_bytezSizeMatcher.to_bytePss")"5g3C   #   #     3s6{{D ! !E* *rcftt|Sr6)rGrrx)inputs r str_to_bytezSizeMatcher.str_to_bytebs&"";#7#7#>#>???rc|sdS||}|stddStjd|d}||}|||f}t|jrnt|j rZ|||jkr |||j krdSt dn>t|j rOt|js;|||j krdSt dnt|jrOt|j s;|||jkrdSt dnxt|j r;|||j krdSt d n)t d td dS) z Convert MB/GB/TB down to bytes and compare 1) Extracts information from the to-be-inspected disk. 2) Depending on the mode, apply checks and return # This doesn't seem very solid and _may_ be re-factored Fz!Could not retrieve value for diskz\d+\.\d+rTz'Disk didn't match for 'high/low' filterz"Disk didn't match for 'low' filterz#Disk didn't match for 'high' filterz$Disk didn't match for 'exact' filterz&Neither high, low, nor exact was givenzNo filters applied) r-rCwarningrrrsrurallrbr^rDrfr )rr+r, disk_size disk_suffixdisk_size_in_bytes rr1zSizeMatcher.comparehs 5''--   NN> ? ? ?5J{J77: ((44  LL)[)ABB ty>> 6c$(mm 6 DLLI%%#4 TX8N8N#N#Nt LLB C C C C ]] 63ty>> 6 DLL$:$:::t LL= > > > > ^^ 6CMM 6 DLL$;$;;;t LL> ? ? ? ? __ 6 DLL$<$<<<t LL? @ @ @ @ LLA B B B 455 5ur)rN)r r r r2rlrjrpropertyr^setterrbrf classmethodrprurxrZ staticmethodrrr1rrrrGrGs !  !!!H "!x{2$++X+  Z**Z* --X-  [--[- //X/  \00\0 [,GG[G J J[ J'H'H'H'HR**\* @@\@ 44444rrG)typingrrrrrceph.deployment.inventoryrrrlogging getLoggerr rC Exceptionr objectrr4r<r@rGrrrrs98888888888888,,,,,,   8 $ $     I   E"E"E"E"E"fE"E"E"Rw66g8ooooo'ooooor