__pycache__/__init__.cpython-36.opt-1.pyc000064400000001074147205111620014101 0ustar003 ft` @sPddlmZdZdZdZdZdZeedeedeed eed eed iZd S) )_z#Enabling different stream for '{}'.zNothing to show.z;Installing newer version of '{}' than specified. Reason: {}zEnabled modules: {}.z6No profile specified for '{}', please specify profile.N)Zdnf.i18nrZDIFFERENT_STREAM_INFOZNOTHING_TO_SHOWZINSTALLING_NEWER_VERSIONZENABLED_MODULESZNO_PROFILE_SPECIFIEDZmodule_messagesrr/usr/lib/python3.6/__init__.pys __pycache__/__init__.cpython-36.pyc000064400000001074147205111620013142 0ustar003 ft` @sPddlmZdZdZdZdZdZeedeedeed eed eed iZd S) )_z#Enabling different stream for '{}'.zNothing to show.z;Installing newer version of '{}' than specified. Reason: {}zEnabled modules: {}.z6No profile specified for '{}', please specify profile.N)Zdnf.i18nrZDIFFERENT_STREAM_INFOZNOTHING_TO_SHOWZINSTALLING_NEWER_VERSIONZENABLED_MODULESZNO_PROFILE_SPECIFIEDZmodule_messagesrr/usr/lib/python3.6/__init__.pys __pycache__/exceptions.cpython-36.opt-1.pyc000064400000011022147205111620014515 0ustar003 ft`F@sddlZddlmZmZddlmZGdddejjZGdddejjZ Gdd d ejjZ Gd d d ejjZ Gd d d ejjZ GdddejjZ GdddejjZGdddejjZGdddejjZGdddejjZGdddejjZdS)N)module_messagesNO_PROFILE_SPECIFIED)_cseZdZfddZZS)NoModuleExceptioncs"tdj|}tt|j|dS)NzNo such module: {})rformatsuperr__init__)self module_specvalue) __class__ /usr/lib/python3.6/exceptions.pyrszNoModuleException.__init__)__name__ __module__ __qualname__r __classcell__r r )r rrsrcseZdZfddZZS)NoStreamExceptioncs"tdj|}tt|j|dS)NzNo such stream: {})rrrrr)r streamr )r r rr szNoStreamException.__init__)rrrrrr r )r rrsrcseZdZfddZZS)EnabledStreamExceptioncs"tdj|}tt|j|dS)Nz No enabled stream for module: {})rrrrr)r r r )r r rr&szEnabledStreamException.__init__)rrrrrr r )r rr%srcseZdZdfdd ZZS)EnableMultipleStreamsExceptionNcs*|dkrtdj|}tt|j|dS)NzsrcseZdZfddZZS)NoStreamSpecifiedExceptioncs"tdj|}tt|j|dS)Nz3No stream specified for '{}', please specify stream)rrrrr)r r r )r r rrEsz#NoStreamSpecifiedException.__init__)rrrrrr r )r rrDsrcseZdZfddZZS)NoProfileSpecifiedExceptioncs"ttj|}tt|j|dS)N)rrrrrr)r r r )r r rrKsz$NoProfileSpecifiedException.__init__)rrrrrr r )r rrJsrcseZdZfddZZS)NoProfilesExceptioncs"tdj|}tt|j|dS)Nz*No such profile: {}. No profiles available)rrrrr)r r r )r r rrQszNoProfilesException.__init__)rrrrrr r )r rrPsrcseZdZfddZZS)NoProfileToRemoveExceptioncs"tdj|}tt|j|dS)NzNo profile to remove for '{}')rrrrr)r r r )r r rrWsz#NoProfileToRemoveException.__init__)rrrrrr r )r rrVsr)ZdnfZ dnf.modulerrZdnf.i18nr exceptionsErrorrrrrrrrrrrrr r r rs __pycache__/exceptions.cpython-36.pyc000064400000011022147205111620013556 0ustar003 ft`F@sddlZddlmZmZddlmZGdddejjZGdddejjZ Gdd d ejjZ Gd d d ejjZ Gd d d ejjZ GdddejjZ GdddejjZGdddejjZGdddejjZGdddejjZGdddejjZdS)N)module_messagesNO_PROFILE_SPECIFIED)_cseZdZfddZZS)NoModuleExceptioncs"tdj|}tt|j|dS)NzNo such module: {})rformatsuperr__init__)self module_specvalue) __class__ /usr/lib/python3.6/exceptions.pyrszNoModuleException.__init__)__name__ __module__ __qualname__r __classcell__r r )r rrsrcseZdZfddZZS)NoStreamExceptioncs"tdj|}tt|j|dS)NzNo such stream: {})rrrrr)r streamr )r r rr szNoStreamException.__init__)rrrrrr r )r rrsrcseZdZfddZZS)EnabledStreamExceptioncs"tdj|}tt|j|dS)Nz No enabled stream for module: {})rrrrr)r r r )r r rr&szEnabledStreamException.__init__)rrrrrr r )r rr%srcseZdZdfdd ZZS)EnableMultipleStreamsExceptionNcs*|dkrtdj|}tt|j|dS)NzsrcseZdZfddZZS)NoStreamSpecifiedExceptioncs"tdj|}tt|j|dS)Nz3No stream specified for '{}', please specify stream)rrrrr)r r r )r r rrEsz#NoStreamSpecifiedException.__init__)rrrrrr r )r rrDsrcseZdZfddZZS)NoProfileSpecifiedExceptioncs"ttj|}tt|j|dS)N)rrrrrr)r r r )r r rrKsz$NoProfileSpecifiedException.__init__)rrrrrr r )r rrJsrcseZdZfddZZS)NoProfilesExceptioncs"tdj|}tt|j|dS)Nz*No such profile: {}. No profiles available)rrrrr)r r r )r r rrQszNoProfilesException.__init__)rrrrrr r )r rrPsrcseZdZfddZZS)NoProfileToRemoveExceptioncs"tdj|}tt|j|dS)NzNo profile to remove for '{}')rrrrr)r r r )r r rrWsz#NoProfileToRemoveException.__init__)rrrrrr r )r rrVsr)ZdnfZ dnf.modulerrZdnf.i18nr exceptionsErrorrrrrrrrrrrrr r r rs __pycache__/module_base.cpython-36.opt-1.pyc000064400000057260147205111620014631 0ustar003 ft`@sddlmZddlZddlZddlZddlZddlZddl m Z ddl m Z ddl mZmZmZddlZejjjZejjjZejjjZejjjZedZedZdd ZGd d d eZ d d Z!dS)) OrderedDictN)EnableMultipleStreamsException)logger)_P_ucdz6 Hint: [d]efault, [e]nabled, [x]disabled, [i]nstalledz@ Hint: [d]efault, [e]nabled, [x]disabled, [i]nstalled, [a]ctivecCs|jS)N)getName)profiler !/usr/lib/python3.6/module_base.py_profile_comparison_key'sr c@seZdZddZddZddZdBdd ZdCd d Zd d ZddZ ddZ ddZ ddZ ddZ dDddZddZddZddZd d!Zd"d#ZdEd%d&Zd'd(Zd)d*Zd+d,ZdFd-d.Zd/d0Zed1d2Zd3d4Zd5d6Zd7d8Zd9d:Zd;d<Z d=d>Z!d?d@Z"dAS)G ModuleBasecCs ||_dS)N)base)selfrr r r __init__.szModuleBase.__init__c Csn|j|\}}}}x8|jD],\}\}}|jrtjtdj|j|jqW|sX|sX|rjtj j |||ddS)Nz%Ignoring unnecessary profile: '{}/{}')no_match_group_specserror_group_specsmodule_depsolv_errors) !_resolve_specs_enable_update_sackitemsr rinforformatnamednf exceptions MarkingErrors) r module_specsno_match_specs error_specs solver_errors module_dictsspecnsvcap module_dictr r r enable2s  zModuleBase.enablecCs,|j|t\}}|s|r(tjj||ddS)N)rr)_modules_reset_or_disableSTATE_DISABLEDrrr)rrrrr r r disable?szModuleBase.disableTc sj|\}}}}tj}i}t} d} xt|jD]f\} \} } xV| jD]H\}}x<|jD].\}}fdd|D}|stjtdj| |||j | qbg}j |}|j |krtd}tj |j|j |d} | jrd|j|j| j|s(|j}|r>djtdd|D}td j| |||}ntd j| }tj||j | qbnĈjjj||}|s|j}|rdjtd d|D}td j|||}ntd j||}tj||j | xNt|D]B}|j|}|stjtdj||||j | |j|qWxJ|D]B}jjj||jx&|jD]}|j|tj| qPWq.Wx|D]}| j|jqzWqbWqLWq2W| rtjjtdj | ||\}}|r|j||s|s|rtjj!|||ddS)NFcs"g|]}jjj|jr|qSr )r_moduleContainerisModuleActivegetId).0x)rr r Ssz&ModuleBase.install..zAAll matches for argument '{0}' in module '{1}:{2}' are not activezDInstalling module '{0}' from Fail-Safe repository {1} is not allowedTz, cSsg|] }|jqSr )r)r+r r r r r-gszKUnable to match profile for argument {}. Available profiles for '{}:{}': {}z'Unable to match profile for argument {}cSsg|] }|jqSr )r)r+r r r r r-wsz| jD]0\} }x"|jD]\}}fd d |D}|stjtd j| | ||j| q@g}j|}|j|krtd }tj|j|j|d}| jrJ|j |j| j|s|j}|r"djtdd |D} tdj| | || }ntdj| }tj||j| q@nT| |krxH|| D]<}!|j|!}"|"stjtdj|!| |q^|j |"q^WxJ|D]B}!jjj||!j x&|!j!D]}|j"|tj | qWqWxh|D]`} | j}#|j#|#xF|#D]>}|j ddd}||kr.q |j ddd}|j |q WqWq@Wq*WqW|r|t$j%j&tdj'|||\}$}%|%r|j |%t}&|&j#||&j#|jj(jj)dd}'jj(jj)ddgdj*}(x|&D]}|(j+|d})|)j,}*|*sq|)j-}+|+sJtjtdj|||kr|'j.|)}'q|)j/|$},|,r^|,})t$j0j1jj(}-|-j|)djj2j3|-dqWjj4|'|s|s|rt$j%j5|||ddS)Nnosrcsrc.-rFcs"g|]}jjj|jr|qSr )rr(r)r*)r+r,)rr r r-sz(ModuleBase.switch_to..z8No active matches for argument '{0}' in module '{1}:{2}'zDInstalling module '{0}' from Fail-Safe repository {1} is not allowedTz, cSsg|] }|jqSr )r)r+r r r r r-szKUnable to match profile for argument {}. Available profiles for '{}:{}': {}z'Unable to match profile for argument {}zEInstalled profile '{0}' is not available in module '{1}' stream '{2}'z:Installing module from Fail-Safe repository is not allowed)empty) arch__neq)rz9No packages available to distrosync for package name '{}')pkg)select)rrr)6_resolve_specs_enabler0rkeysrr(queryr)rArsplitr? _update_sack_enable_dependenciesr7r.r/ZgetRemovedProfilesrr1rrr2r3r4r5r6r r8r9r:Zwarningr<rr=r>r@rrrBrCsackfiltermapplyfilter installed availableunion intersectionselectorSelector_goalZ distupgrade_remove_if_unneededr).rrrDrrr Znew_artifacts_namesZactive_artifacts_namesZ src_archesr!r"rIrrUartifactarchrTrdependency_error_specrErFrGrHZremoved_profilesrJrKrLrMrNrOrPrQrRr rS artifactsinstall_base_queryrWZ all_namesZ remove_querybase_no_source_queryrermrnZonly_new_modulesltrr )rr switch_tos                  (           zModuleBase.switch_tocCs(|j|t\}}|r$tjj||ddS)N)rr)r% STATE_UNKNOWNrrr)rrrrr r r resetszModuleBase.resetcs,g}tj}d}jjjjddgdj}x|D]}j|\}}|sV|j|q2fdd|D} | st j t dj |q2j | |d} t} x| jD]\} } x| jD]\}}| jj||j|}|j|kr t d}t j|j |j|d }|jrH|j|j}|s(qx|D]}| j|jq.Wqx |jD]}| j|jqRWxD|jD]8}tj|}x&|jtjgd D]}| j|jqWqtWqWqW| st j t d j ||j| d }|r2t j!j"jj}|j|d jj#j$|dq2W|r(t j%j&t d|S)NFrYrX)r`cs"g|]}jjj|jr|qSr )rr(r)r*)r+r,)rr r r-3sz&ModuleBase.upgrade..zUnable to resolve argument {}zCUpgrading module '{0}' from Fail-Safe repository {1} is not allowedT)Zformsz&Unable to match profile in argument {})r)ra)rbz9Upgrading module from Fail-Safe repository is not allowed)'r.r/rrirerjrk _get_modulesr2rr1rr_create_module_dict_and_enabler0rr@)_get_package_name_set_and_remove_profilesr3r4r5r6r r8r=rASubjectZget_nevra_possibilitiesZ FORM_NEVRAr?rrlrrqrrrsupgraderrB)rrrrErHrzr!rLr"Zupdate_module_listr#Zupgrade_package_setrrJrKmodule_list_from_dictrOrP profiles_setr rusubjZ nevra_objrer{r )rr r%sb         zModuleBase.upgradecCsg}t}x|D]}|j|\}}|s2|j|q|j||d}g}x>|jD]2\} } x(| jD]\} } |j|j| |dq`WqNW|stjt dj ||j |qW|r|j j j} |j| }|r|j jjjj|d}|r|j j||S)NFTz&Unable to match profile in argument {})r)r0rr2rrr7rrr1rrr@rr(ZgetInstalledPkgNames differencerirermrjrt)rrrZremove_package_setr!rLr"r#Zremove_packages_namesrrJrKrZkeep_pkg_namesrer r r remove_s0     zModuleBase.removecCs |j|S)N)r)r module_specr r r get_modules|szModuleBase.get_modulesc Cstj|}x|jD]}|jr$|jnd}|jr4|jnd}d}|jrH|jnd}|jrX|jnd}|jrv|jdkrvt|j}|j j j |||||} | r| |fSqWfdfS)NrZr\) r.rZnsvcap_possibilitiesrrKcontextrvversionstrrr(re) rrrr"rrKrrrvmodulesr r r rs   zModuleBase._get_modulescCs>d}|r:|d}x(|ddD]}|j|jkr|}qW|S)Nrr\)Z getVersionNum)rrLlatestrUr r r r3szModuleBase._get_latestc Csvi}x.|D]&}|j|jij|jgj|q Wx:|jD],\}}|jjj|}t|dkrF|t kr|t kr|t krdj t |jtj|jjjd} tdj|t|| |d} t|| |t kr|jjj|} n|jjj|} | s| |krt|xjt |jD]0} | | kr8|r|jjj|| q|| =qWq@|r@x"|jD]} |jjj|| qTWq@W|S)Nr\z', ')keyzArgument '{argument}' matches {stream_count} streams ('{streams}') of module '{module}', but none of the streams are enabled or default)ZargumentZ stream_countZstreamsrU)r>r getStreamr2rrr(ZgetModuleStatelen STATE_DEFAULT STATE_ENABLEDr&r9r:rd functools cmp_to_keyriZevr_cmprrrZgetEnabledStreamgetDefaultStreamr$) rrLr!r$ moduleDictrUZ moduleName streamDictZ moduleStateZ streams_strrPrKrr r r rs> "   z)ModuleBase._create_module_dict_and_enablec Csg}g}i}x|D]}|j|\}}|s4|j|qy|j||d}||f||<Wqttfk r} z2|j|tjt| tjtdj |WYdd} ~ XqXqW|||fS)NTzUnable to resolve argument {}) rr2r RuntimeErrorrrr1rrr) rrr error_specr r!rLr"r#er r r rcs    *z ModuleBase._resolve_specs_enablecCsdd|jjjD}y4|jjj|jj||jjj|jjjd|jjj d}Wn4t j k r~}zt j jt|WYdd}~XnX|S)NcSsg|]}|jr|jqSr )module_hotfixesid)r+ir r r r-sz+ModuleBase._update_sack..T)Z update_onlyZ debugsolver)rrepos iter_enabledriZfilter_modulesr(confZ installrootZmodule_platform_idZ debug_solverr. ExceptionrrrBr)r hot_fix_reposrrr r r rgs "zModuleBase._update_sackc Csg}x|jD]\}\}}x|jD]}xz|jD]n}y|jjjtjj|Wq2tk r}z2|j |t j t |t j t dj|WYdd}~Xq2Xq2Wq$WqW|S)NzUnable to resolve argument {})rvaluesrr(ZenableDependencyTreelibdnfrUZVectorModulePackagePtrrr2rr1rrr) rr rr!r"rrrrr r r rhs 2zModuleBase._enable_dependenciescCs<|j|\}}}|j}|j|}|r0|j|||||fS)N)rcrgrhr7)rrrrr rrwr r r rs   z,ModuleBase._resolve_specs_enable_update_sackc Csg}x|D]}|j|\}}|s@tjtdj||j|q |js^|js^|js^|j s^|j rrtj tdj|t }x|D]}|j |jq~Wx8|D]0} |tkr|jjj| |tkr|jjj| qWq W|j} || fS)NzUnable to resolve argument {}zMOnly module name is required. Ignoring unneeded information in argument: '{}')rrr1rrr2rKrrrvr rr0r?rr}rr(r~r&r'rg) rrZto_staterr!rLr"Z module_namesrUrrr r r r%s(     z$ModuleBase._modules_reset_or_disableFc Cst}|j|}t|jjj|j}|s0tS|jr|j|j}|sLtSx|D]6}|j|krR|rz|jjj||j|j |j qRWnDxB|D]:} |r|jjj|| x |j| D]}|j |j qWqW|S)N) r0r3rr(getInstalledProfilesrr r8Z uninstallr@r=) rrLr"rZpackage_name_setrOZinstalled_profiles_stringsrr Zprofile_stringr r r r s*       z4ModuleBase._get_package_name_set_and_remove_profilesc Cst}x|D]}|j|\}}|s8tjtdj|q |jrXtjtdj|j|jxl|D]d}t}|j |d<x8t |j t dD]$}dj dd|jD||j<qW|j|j|jq^Wq Wdj t |S) NzUnable to resolve argument {}z%Ignoring unnecessary profile: '{}/{}'Name)r cSsg|]}|qSr r )r+ZpkgNamer r r r-5sz1ModuleBase._get_info_profiles..z )r0rrrrrr rrgetFullIdentifierr:r8r r9r=rr?_create_simple_tabletoString) rroutputrrLr"rUlinesr r r r _get_info_profiles#s"     zModuleBase._get_info_profilescCs|jjj|j}|j}d}xTt|tdD]D}|dj|j|j|krLdnd7}||j|krj|rjdnd7}q,W|ddS) NrZ)rz{}{}z [d]z [i], z, r^)rr(rrr8r:r r)r modulePackagedefault_profiles enabled_strZinstalled_profilesrQ profiles_strr r r r _profile_report_formatter:s  z$ModuleBase._profile_report_formattercCs|jjddS)Nr )stripreplace)rZsummaryr r r _summary_report_formatterFsz$ModuleBase._summary_report_formattercCsd}d}d}|j|jjj|jkr*d}|jjj|rJ|s@d}|d7}n|jjj|rh|s`d}|d7}|r|jjj|r|sd}|d7}|||fS)NrZz [d]rz[e]z[x]z[a])rrr(rrZ isEnabledZ isDisabledr))rr markActive default_strr disabled_strr r r _module_strs_formatterIs&  z!ModuleBase._module_strs_formatterc Cst}x|D]}|j|\}}|s.F)r)rrrZ setTermforceZTermForce_AUTOZ enableMaxoutrrrrverboseZhiddenrrrr(r;rrrrrrr)rrrrZ column_streamZcolumn_profilesZ column_infoZlatest_per_repoZnameStreamArchrZactiverrrrrrZ summary_strr )rr _create_and_fill_tablesD              z!ModuleBase._create_and_fill_tablecCsg}|r0x2|D]}|j|\}}|j|qWn |jjj}|jjj||}|sTdS|j|}d} d} y"|jj|dddjj } Wn(t k r|dddj} YnXt |d} |j |} |j | }|| 7}xtd|jD]}| | |kr| | 7} | d7} y"|jj|| ddjj } Wn*t k rX|| ddj} YnXt || } |d7}||j | 7}|| 7}|j|}||j||7}qW|tS)NrZrr\r)rr7rr(rZgetLatestModulesPerReporrr4rKeyErrorr_format_header_format_repoidrangeZgetNumberOfLinesgetLinerMODULE_TABLE_HINT)rrZ module_staterr!rLr"rrZcurrent_repo_id_indexZalready_printed_lines repo_nameZversionsheaderrrrr r r _get_brief_descriptionsH   "     z!ModuleBase._get_brief_descriptioncCs&|jd}|j||jddddS)Nrrr\)rrsplit)rrrr r r r.s zModuleBase._format_headercCsdj|jjjj|S)Nz{} )rrrrr)rrr r r r2szModuleBase._format_repoidcCs|jjjjddgdj}|j|d}g}dd|jjjD}|j||jd}|j |}x|j D]\} } |j| d} | s|j| d} | sx | D]} t j t d j| qWt j t d j| |j| qh|jjjj| tjj|jj} | j| d |jjj| | d qhW||fS) NrYrX)r`)rcSsg|]}|jr|jqSr )rr)r+rr r r r-<sz9ModuleBase._install_profiles_internal..)Zreponamer)rzUnable to resolve argument {}zNo match for package {})ra)rbZoptional)rrirerjrkrlrrrdrorrr1rrr7rsZ group_membersr?rrqrrr0r<)rrGrFrDrzryrrZhotfix_packagesrTZ set_specsrer!r{r r r rC5s,       z%ModuleBase._install_profiles_internalN)T)T)T)F)F)#__name__ __module__ __qualname__rr$r'r<r|r~rrrrr3rrcrgrhrr%rrrrrr staticmethodrrrrrrrrCr r r r r +s@  U : %     - (**r cCs&tjj|}djtddt||gS)NrzModular dependency problem:zModular dependency problems:)rutilZ_format_resolve_problemsr9rr)errorsrPr r r format_modular_solver_errorsSs r)" collectionsrr.Zlibdnf.smartcolsrZ libdnf.moduleZ dnf.selectorrZdnf.exceptionsZdnf.module.exceptionsrZdnf.utilrZdnf.i18nrrrrrUZModulePackageContainerZModuleState_DEFAULTrZModuleState_ENABLEDrZModuleState_DISABLEDr&ZModuleState_UNKNOWNr}rrr objectr rr r r r s0       .__pycache__/module_base.cpython-36.pyc000064400000057322147205111620013671 0ustar003 ft`@sddlmZddlZddlZddlZddlZddlZddl m Z ddl m Z ddl mZmZmZddlZejjjZejjjZejjjZejjjZedZedZdd ZGd d d eZ d d Z!dS)) OrderedDictN)EnableMultipleStreamsException)logger)_P_ucdz6 Hint: [d]efault, [e]nabled, [x]disabled, [i]nstalledz@ Hint: [d]efault, [e]nabled, [x]disabled, [i]nstalled, [a]ctivecCs|jS)N)getName)profiler !/usr/lib/python3.6/module_base.py_profile_comparison_key'sr c@seZdZddZddZddZdBdd ZdCd d Zd d ZddZ ddZ ddZ ddZ ddZ dDddZddZddZddZd d!Zd"d#ZdEd%d&Zd'd(Zd)d*Zd+d,ZdFd-d.Zd/d0Zed1d2Zd3d4Zd5d6Zd7d8Zd9d:Zd;d<Z d=d>Z!d?d@Z"dAS)G ModuleBasecCs ||_dS)N)base)selfrr r r __init__.szModuleBase.__init__c Csn|j|\}}}}x8|jD],\}\}}|jrtjtdj|j|jqW|sX|sX|rjtj j |||ddS)Nz%Ignoring unnecessary profile: '{}/{}')no_match_group_specserror_group_specsmodule_depsolv_errors) !_resolve_specs_enable_update_sackitemsr rinforformatnamednf exceptions MarkingErrors) r module_specsno_match_specs error_specs solver_errors module_dictsspecnsvcap module_dictr r r enable2s  zModuleBase.enablecCs,|j|t\}}|s|r(tjj||ddS)N)rr)_modules_reset_or_disableSTATE_DISABLEDrrr)rrrrr r r disable?szModuleBase.disableTc sj|\}}}}tj}i}t} d} xt|jD]f\} \} } xV| jD]H\}}x<|jD].\}}fdd|D}|stjtdj| |||j | qbg}j |}|j |krtd}tj |j|j |d} | jrd|j|j| j|s(|j}|r>djtdd|D}td j| |||}ntd j| }tj||j | qbnĈjjj||}|s|j}|rdjtd d|D}td j|||}ntd j||}tj||j | xNt|D]B}|j|}|stjtdj||||j | |j|qWxJ|D]B}jjj||jx&|jD]}|j|tj| qPWq.Wx|D]}| j|jqzWqbWqLWq2W| rtjjtdj | ||\}}|r|j||s|s|rtjj!|||ddS)NFcs"g|]}jjj|jr|qSr )r_moduleContainerisModuleActivegetId).0x)rr r Ssz&ModuleBase.install..zAAll matches for argument '{0}' in module '{1}:{2}' are not activezDInstalling module '{0}' from Fail-Safe repository {1} is not allowedTz, cSsg|] }|jqSr )r)r+r r r r r-gszKUnable to match profile for argument {}. Available profiles for '{}:{}': {}z'Unable to match profile for argument {}cSsg|] }|jqSr )r)r+r r r r r-wsz| jD]0\} }x"|jD]\}}fd d |D}|stjtd j| | ||j| q@g}j|}|j|krtd }tj|j|j|d}| jrJ|j |j| j|s|j}|r"djtdd |D} tdj| | || }ntdj| }tj||j| q@nT| |krxH|| D]<}!|j|!}"|"stjtdj|!| |q^|j |"q^WxJ|D]B}!jjj||!j x&|!j!D]}|j"|tj | qWqWxh|D]`} | j}#|j#|#xF|#D]>}|j ddd}||kr.q |j ddd}|j |q WqWq@Wq*WqW|r|t$j%j&tdj'|||\}$}%|%r|j |%t}&|&j#||&j#|jj(jj)dd}'jj(jj)ddgdj*}(x|&D]}|(j+|d})|)j,}*|*sq|)j-}+|+sJtjtdj|||kr|'j.|)}'q|)j/|$},|,r^|,})t$j0j1jj(}-|-j|)djj2j3|-dqWjj4|'|s|s|rt$j%j5|||ddS)Nnosrcsrc.-rFcs"g|]}jjj|jr|qSr )rr(r)r*)r+r,)rr r r-sz(ModuleBase.switch_to..z8No active matches for argument '{0}' in module '{1}:{2}'zDInstalling module '{0}' from Fail-Safe repository {1} is not allowedTz, cSsg|] }|jqSr )r)r+r r r r r-szKUnable to match profile for argument {}. Available profiles for '{}:{}': {}z'Unable to match profile for argument {}zEInstalled profile '{0}' is not available in module '{1}' stream '{2}'z:Installing module from Fail-Safe repository is not allowed)empty) arch__neq)rz9No packages available to distrosync for package name '{}')pkg)select)rrr)6_resolve_specs_enabler0rkeysrr(queryr)rArsplitr? _update_sack_enable_dependenciesr7r.r/ZgetRemovedProfilesrr1rrr2r3r4r5r6r r8r9r:Zwarningr<rr=r>r@rrrBrCsackfiltermapplyfilter installed availableunion intersectionselectorSelector_goalZ distupgrade_remove_if_unneededr).rrrDrrr Znew_artifacts_namesZactive_artifacts_namesZ src_archesr!r"rIrrUartifactarchrTrdependency_error_specrErFrGrHZremoved_profilesrJrKrLrMrNrOrPrQrRr rS artifactsinstall_base_queryrWZ all_namesZ remove_querybase_no_source_queryrermrnZonly_new_modulesltrr )rr switch_tos                  (           zModuleBase.switch_tocCs(|j|t\}}|r$tjj||ddS)N)rr)r% STATE_UNKNOWNrrr)rrrrr r r resetszModuleBase.resetcs,g}tj}d}jjjjddgdj}x|D]}j|\}}|sV|j|q2fdd|D} | st j t dj |q2j | |d} t} x| jD]\} } x| jD]\}}| jj||j|}|j|kr t d}t j|j |j|d }|jrH|j|j}|s(qx|D]}| j|jq.Wqx |jD]}| j|jqRWxD|jD]8}tj|}x&|jtjgd D]}| j|jqWqtWqWqW| st j t d j ||j| d }|r2t j!j"jj}|j|d jj#j$|dq2W|r(t j%j&t d|S)NFrYrX)r`cs"g|]}jjj|jr|qSr )rr(r)r*)r+r,)rr r r-3sz&ModuleBase.upgrade..zUnable to resolve argument {}zCUpgrading module '{0}' from Fail-Safe repository {1} is not allowedT)Zformsz&Unable to match profile in argument {})r)ra)rbz9Upgrading module from Fail-Safe repository is not allowed)'r.r/rrirerjrk _get_modulesr2rr1rr_create_module_dict_and_enabler0rr@)_get_package_name_set_and_remove_profilesr3r4r5r6r r8r=rASubjectZget_nevra_possibilitiesZ FORM_NEVRAr?rrlrrqrrrsupgraderrB)rrrrErHrzr!rLr"Zupdate_module_listr#Zupgrade_package_setrrJrKmodule_list_from_dictrOrP profiles_setr rusubjZ nevra_objrer{r )rr r%sb         zModuleBase.upgradecCsg}t}x|D]}|j|\}}|s2|j|q|j||d}g}x>|jD]2\} } x(| jD]\} } |j|j| |dq`WqNW|stjt dj ||j |qW|r|j j j} |j| }|r|j jjjj|d}|r|j j||S)NFTz&Unable to match profile in argument {})r)r0rr2rrr7rrr1rrr@rr(ZgetInstalledPkgNames differencerirermrjrt)rrrZremove_package_setr!rLr"r#Zremove_packages_namesrrJrKrZkeep_pkg_namesrer r r remove_s0     zModuleBase.removecCs |j|S)N)r)r module_specr r r get_modules|szModuleBase.get_modulesc Cstj|}x|jD]}|jr$|jnd}|jr4|jnd}d}|jrH|jnd}|jrX|jnd}|jrv|jdkrvt|j}|j j j |||||} | r| |fSqWfdfS)NrZr\) r.rZnsvcap_possibilitiesrrKcontextrvversionstrrr(re) rrrr"rrKrrrvmodulesr r r rs   zModuleBase._get_modulescCs>d}|r:|d}x(|ddD]}|j|jkr|}qW|S)Nrr\)Z getVersionNum)rrLlatestrUr r r r3szModuleBase._get_latestc Csi}x.|D]&}|j|jij|jgj|q WxL|jD]>\}}|jjj|}t|dkrF|t kr|t kr|t krdj t |jtj|jjjd} tdj|t|| |d} t|| |t kr|jjj|} n|jjj|} | s| |krt|xlt |jD]0} | | kr8|r|jjj|| q|| =qWn*|rpx"|jD]} |jjj|| qVWt|dks@tq@W|S)Nr\z', ')keyzArgument '{argument}' matches {stream_count} streams ('{streams}') of module '{module}', but none of the streams are enabled or default)ZargumentZ stream_countZstreamsrU)r>r getStreamr2rrr(ZgetModuleStatelen STATE_DEFAULT STATE_ENABLEDr&r9r:rd functools cmp_to_keyriZevr_cmprrrZgetEnabledStreamgetDefaultStreamr$AssertionError) rrLr!r$ moduleDictrUZ moduleName streamDictZ moduleStateZ streams_strrPrKrr r r rs> "   z)ModuleBase._create_module_dict_and_enablec Csg}g}i}x|D]}|j|\}}|s4|j|qy|j||d}||f||<Wqttfk r} z2|j|tjt| tjtdj |WYdd} ~ XqXqW|||fS)NTzUnable to resolve argument {}) rr2r RuntimeErrorrrr1rrr) rrr error_specr r!rLr"r#er r r rcs    *z ModuleBase._resolve_specs_enablecCsdd|jjjD}y4|jjj|jj||jjj|jjjd|jjj d}Wn4t j k r~}zt j jt|WYdd}~XnX|S)NcSsg|]}|jr|jqSr )module_hotfixesid)r+ir r r r-sz+ModuleBase._update_sack..T)Z update_onlyZ debugsolver)rrepos iter_enabledriZfilter_modulesr(confZ installrootZmodule_platform_idZ debug_solverr. ExceptionrrrBr)r hot_fix_reposrrr r r rgs "zModuleBase._update_sackc Csg}x|jD]\}\}}x|jD]}xz|jD]n}y|jjjtjj|Wq2tk r}z2|j |t j t |t j t dj|WYdd}~Xq2Xq2Wq$WqW|S)NzUnable to resolve argument {})rvaluesrr(ZenableDependencyTreelibdnfrUZVectorModulePackagePtrrr2rr1rrr) rr rr!r"rrrrr r r rhs 2zModuleBase._enable_dependenciescCs<|j|\}}}|j}|j|}|r0|j|||||fS)N)rcrgrhr7)rrrrr rrwr r r rs   z,ModuleBase._resolve_specs_enable_update_sackc Csg}x|D]}|j|\}}|s@tjtdj||j|q |js^|js^|js^|j s^|j rrtj tdj|t }x|D]}|j |jq~Wx8|D]0} |tkr|jjj| |tkr|jjj| qWq W|j} || fS)NzUnable to resolve argument {}zMOnly module name is required. Ignoring unneeded information in argument: '{}')rrr1rrr2rKrrrvr rr0r?rr}rr(r~r&r'rg) rrZto_staterr!rLr"Z module_namesrUrrr r r r%s(     z$ModuleBase._modules_reset_or_disableFc Cst}|j|}t|jjj|j}|s0tS|jr|j|j}|sLtSx|D]6}|j|krR|rz|jjj||j|j |j qRWnDxB|D]:} |r|jjj|| x |j| D]}|j |j qWqW|S)N) r0r3rr(getInstalledProfilesrr r8Z uninstallr@r=) rrLr"rZpackage_name_setrOZinstalled_profiles_stringsrr Zprofile_stringr r r r s*       z4ModuleBase._get_package_name_set_and_remove_profilesc Cst}x|D]}|j|\}}|s8tjtdj|q |jrXtjtdj|j|jxl|D]d}t}|j |d<x8t |j t dD]$}dj dd|jD||j<qW|j|j|jq^Wq Wdj t |S) NzUnable to resolve argument {}z%Ignoring unnecessary profile: '{}/{}'Name)r cSsg|]}|qSr r )r+ZpkgNamer r r r-5sz1ModuleBase._get_info_profiles..z )r0rrrrrr rrgetFullIdentifierr:r8r r9r=rr?_create_simple_tabletoString) rroutputrrLr"rUlinesr r r r _get_info_profiles#s"     zModuleBase._get_info_profilescCs|jjj|j}|j}d}xTt|tdD]D}|dj|j|j|krLdnd7}||j|krj|rjdnd7}q,W|ddS) NrZ)rz{}{}z [d]z [i], z, r^)rr(rrr8r:r r)r modulePackagedefault_profiles enabled_strZinstalled_profilesrQ profiles_strr r r r _profile_report_formatter:s  z$ModuleBase._profile_report_formattercCs|jjddS)Nr )stripreplace)rZsummaryr r r _summary_report_formatterFsz$ModuleBase._summary_report_formattercCsd}d}d}|j|jjj|jkr*d}|jjj|rJ|s@d}|d7}n|jjj|rh|s`d}|d7}|r|jjj|r|sd}|d7}|||fS)NrZz [d]rz[e]z[x]z[a])rrr(rrZ isEnabledZ isDisabledr))rr markActive default_strr disabled_strr r r _module_strs_formatterIs&  z!ModuleBase._module_strs_formatterc Cst}x|D]}|j|\}}|s.F)r)rrrZ setTermforceZTermForce_AUTOZ enableMaxoutrrrrverboseZhiddenrrrr(r;rrrrrrr)rrrrZ column_streamZcolumn_profilesZ column_infoZlatest_per_repoZnameStreamArchrZactiverrrrrrZ summary_strr )rr _create_and_fill_tablesD              z!ModuleBase._create_and_fill_tablecCsg}|r0x2|D]}|j|\}}|j|qWn |jjj}|jjj||}|sTdS|j|}d} d} y"|jj|dddjj } Wn(t k r|dddj} YnXt |d} |j |} |j | }|| 7}xtd|jD]}| | |kr| | 7} | d7} y"|jj|| ddjj } Wn*t k rX|| ddj} YnXt || } |d7}||j | 7}|| 7}|j|}||j||7}qW|tS)NrZrr\r)rr7rr(rZgetLatestModulesPerReporrr4rKeyErrorr_format_header_format_repoidrangeZgetNumberOfLinesgetLinerMODULE_TABLE_HINT)rrZ module_staterr!rLr"rrZcurrent_repo_id_indexZalready_printed_lines repo_nameZversionsheaderrrrr r r _get_brief_descriptionsH   "     z!ModuleBase._get_brief_descriptioncCs&|jd}|j||jddddS)Nrrr\)rrsplit)rrrr r r r.s zModuleBase._format_headercCsdj|jjjj|S)Nz{} )rrrrr)rrr r r r2szModuleBase._format_repoidcCs|jjjjddgdj}|j|d}g}dd|jjjD}|j||jd}|j |}x|j D]\} } |j| d} | s|j| d} | sx | D]} t j t d j| qWt j t d j| |j| qh|jjjj| tjj|jj} | j| d |jjj| | d qhW||fS) NrYrX)r`)rcSsg|]}|jr|jqSr )rr)r+rr r r r-<sz9ModuleBase._install_profiles_internal..)Zreponamer)rzUnable to resolve argument {}zNo match for package {})ra)rbZoptional)rrirerjrkrlrrrdrorrr1rrr7rsZ group_membersr?rrqrrr0r<)rrGrFrDrzryrrZhotfix_packagesrTZ set_specsrer!r{r r r rC5s,       z%ModuleBase._install_profiles_internalN)T)T)T)F)F)#__name__ __module__ __qualname__rr$r'r<r|r~rrrrr3rrcrgrhrr%rrrrrr staticmethodrrrrrrrrCr r r r r +s@  U : %     - (**r cCs&tjj|}djtddt||gS)NrzModular dependency problem:zModular dependency problems:)rutilZ_format_resolve_problemsr9rr)errorsrPr r r format_modular_solver_errorsSs r)" collectionsrr.Zlibdnf.smartcolsrZ libdnf.moduleZ dnf.selectorrZdnf.exceptionsZdnf.module.exceptionsrZdnf.utilrZdnf.i18nrrrrrUZModulePackageContainerZModuleState_DEFAULTrZModuleState_ENABLEDrZModuleState_DISABLEDr&ZModuleState_UNKNOWNr}rrr objectr rr r r r s0       .__init__.py000064400000002356147205111620006662 0ustar00# Copyright (C) 2017 Red Hat, Inc. # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Library General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. from dnf.i18n import _ DIFFERENT_STREAM_INFO = 1 NOTHING_TO_SHOW = 2 INSTALLING_NEWER_VERSION = 4 ENABLED_MODULES = 5 NO_PROFILE_SPECIFIED = 6 module_messages = { DIFFERENT_STREAM_INFO: _("Enabling different stream for '{}'."), NOTHING_TO_SHOW: _("Nothing to show."), INSTALLING_NEWER_VERSION: _("Installing newer version of '{}' than specified. Reason: {}"), ENABLED_MODULES: _("Enabled modules: {}."), NO_PROFILE_SPECIFIED: _("No profile specified for '{}', please specify profile."), } exceptions.py000064400000007106147205111620007302 0ustar00# supplies the 'module' command. # # Copyright (C) 2014-2017 Red Hat, Inc. # # This copyrighted material is made available to anyone wishing to use, # modify, copy, or redistribute it subject to the terms and conditions of # the GNU General Public License v.2, or (at your option) any later version. # This program is distributed in the hope that it will be useful, but WITHOUT # ANY WARRANTY expressed or implied, including the implied warranties of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General # Public License for more details. You should have received a copy of the # GNU General Public License along with this program; if not, write to the # Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA # 02110-1301, USA. Any Red Hat trademarks that are incorporated in the # source code or documentation are not subject to the GNU General Public # License and may only be used or replicated with the express permission of # Red Hat, Inc. # import dnf from dnf.module import module_messages, NO_PROFILE_SPECIFIED from dnf.i18n import _ class NoModuleException(dnf.exceptions.Error): def __init__(self, module_spec): value = _("No such module: {}").format(module_spec) super(NoModuleException, self).__init__(value) class NoStreamException(dnf.exceptions.Error): def __init__(self, stream): value = _("No such stream: {}").format(stream) super(NoStreamException, self).__init__(value) class EnabledStreamException(dnf.exceptions.Error): def __init__(self, module_spec): value = _("No enabled stream for module: {}").format(module_spec) super(EnabledStreamException, self).__init__(value) class EnableMultipleStreamsException(dnf.exceptions.Error): def __init__(self, module_spec, value=None): if value is None: value = _("Cannot enable more streams from module '{}' at the same time").format(module_spec) super(EnableMultipleStreamsException, self).__init__(value) class DifferentStreamEnabledException(dnf.exceptions.Error): def __init__(self, module_spec): value = _("Different stream enabled for module: {}").format(module_spec) super(DifferentStreamEnabledException, self).__init__(value) class NoProfileException(dnf.exceptions.Error): def __init__(self, profile): value = _("No such profile: {}").format(profile) super(NoProfileException, self).__init__(value) class ProfileNotInstalledException(dnf.exceptions.Error): def __init__(self, module_spec): value = _("Specified profile not installed for {}").format(module_spec) super(ProfileNotInstalledException, self).__init__(value) class NoStreamSpecifiedException(dnf.exceptions.Error): def __init__(self, module_spec): value = _("No stream specified for '{}', please specify stream").format(module_spec) super(NoStreamSpecifiedException, self).__init__(value) class NoProfileSpecifiedException(dnf.exceptions.Error): def __init__(self, module_spec): value = module_messages[NO_PROFILE_SPECIFIED].format(module_spec) super(NoProfileSpecifiedException, self).__init__(value) class NoProfilesException(dnf.exceptions.Error): def __init__(self, module_spec): value = _("No such profile: {}. No profiles available").format(module_spec) super(NoProfilesException, self).__init__(value) class NoProfileToRemoveException(dnf.exceptions.Error): def __init__(self, module_spec): value = _("No profile to remove for '{}'").format(module_spec) super(NoProfileToRemoveException, self).__init__(value) module_base.py000064400000120617147205111620007403 0ustar00# Copyright (C) 2017-2018 Red Hat, Inc. # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Library General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. from collections import OrderedDict import hawkey import libdnf.smartcols import libdnf.module import dnf.selector import dnf.exceptions from dnf.module.exceptions import EnableMultipleStreamsException from dnf.util import logger from dnf.i18n import _, P_, ucd import functools STATE_DEFAULT = libdnf.module.ModulePackageContainer.ModuleState_DEFAULT STATE_ENABLED = libdnf.module.ModulePackageContainer.ModuleState_ENABLED STATE_DISABLED = libdnf.module.ModulePackageContainer.ModuleState_DISABLED STATE_UNKNOWN = libdnf.module.ModulePackageContainer.ModuleState_UNKNOWN MODULE_TABLE_HINT = _("\n\nHint: [d]efault, [e]nabled, [x]disabled, [i]nstalled") MODULE_INFO_TABLE_HINT = _("\n\nHint: [d]efault, [e]nabled, [x]disabled, [i]nstalled, [a]ctive") def _profile_comparison_key(profile): return profile.getName() class ModuleBase(object): # :api def __init__(self, base): # :api self.base = base def enable(self, module_specs): # :api no_match_specs, error_specs, solver_errors, module_dicts = \ self._resolve_specs_enable_update_sack(module_specs) for spec, (nsvcap, module_dict) in module_dicts.items(): if nsvcap.profile: logger.info(_("Ignoring unnecessary profile: '{}/{}'").format( nsvcap.name, nsvcap.profile)) if no_match_specs or error_specs or solver_errors: raise dnf.exceptions.MarkingErrors(no_match_group_specs=no_match_specs, error_group_specs=error_specs, module_depsolv_errors=solver_errors) def disable(self, module_specs): # :api no_match_specs, solver_errors = self._modules_reset_or_disable(module_specs, STATE_DISABLED) if no_match_specs or solver_errors: raise dnf.exceptions.MarkingErrors(no_match_group_specs=no_match_specs, module_depsolv_errors=solver_errors) def install(self, module_specs, strict=True): # :api no_match_specs, error_specs, solver_errors, module_dicts = \ self._resolve_specs_enable_update_sack(module_specs) # fail_safe_repo = hawkey.MODULE_FAIL_SAFE_REPO_NAME install_dict = {} install_set_artifacts = set() fail_safe_repo_used = False for spec, (nsvcap, moduledict) in module_dicts.items(): for name, streamdict in moduledict.items(): for stream, module_list in streamdict.items(): install_module_list = [x for x in module_list if self.base._moduleContainer.isModuleActive(x.getId())] if not install_module_list: logger.error(_("All matches for argument '{0}' in module '{1}:{2}' are not " "active").format(spec, name, stream)) error_specs.append(spec) continue profiles = [] latest_module = self._get_latest(install_module_list) if latest_module.getRepoID() == fail_safe_repo: msg = _( "Installing module '{0}' from Fail-Safe repository {1} is not allowed") logger.critical(msg.format(latest_module.getNameStream(), fail_safe_repo)) fail_safe_repo_used = True if nsvcap.profile: profiles.extend(latest_module.getProfiles(nsvcap.profile)) if not profiles: available_profiles = latest_module.getProfiles() if available_profiles: profile_names = ", ".join(sorted( [profile.getName() for profile in available_profiles])) msg = _("Unable to match profile for argument {}. Available " "profiles for '{}:{}': {}").format( spec, name, stream, profile_names) else: msg = _("Unable to match profile for argument {}").format(spec) logger.error(msg) no_match_specs.append(spec) continue else: profiles_strings = self.base._moduleContainer.getDefaultProfiles( name, stream) if not profiles_strings: available_profiles = latest_module.getProfiles() if available_profiles: profile_names = ", ".join(sorted( [profile.getName() for profile in available_profiles])) msg = _("No default profiles for module {}:{}. Available profiles" ": {}").format( name, stream, profile_names) else: msg = _("No profiles for module {}:{}").format(name, stream) logger.error(msg) error_specs.append(spec) for profile in set(profiles_strings): module_profiles = latest_module.getProfiles(profile) if not module_profiles: logger.error( _("Default profile {} not available in module {}:{}").format( profile, name, stream)) error_specs.append(spec) profiles.extend(module_profiles) for profile in profiles: self.base._moduleContainer.install(latest_module ,profile.getName()) for pkg_name in profile.getContent(): install_dict.setdefault(pkg_name, set()).add(spec) for module in install_module_list: install_set_artifacts.update(module.getArtifacts()) if fail_safe_repo_used: raise dnf.exceptions.Error(_( "Installing module from Fail-Safe repository is not allowed")) __, profiles_errors = self._install_profiles_internal( install_set_artifacts, install_dict, strict) if profiles_errors: error_specs.extend(profiles_errors) if no_match_specs or error_specs or solver_errors: raise dnf.exceptions.MarkingErrors(no_match_group_specs=no_match_specs, error_group_specs=error_specs, module_depsolv_errors=solver_errors) def switch_to(self, module_specs, strict=True): # :api no_match_specs, error_specs, module_dicts = self._resolve_specs_enable(module_specs) # collect name of artifacts from new modules for distrosync new_artifacts_names = set() # collect name of artifacts from active modules for distrosync before sack update active_artifacts_names = set() src_arches = {"nosrc", "src"} for spec, (nsvcap, moduledict) in module_dicts.items(): for name in moduledict.keys(): for module in self.base._moduleContainer.query(name, "", "", "", ""): if self.base._moduleContainer.isModuleActive(module): for artifact in module.getArtifacts(): arch = artifact.rsplit(".", 1)[1] if arch in src_arches: continue pkg_name = artifact.rsplit("-", 2)[0] active_artifacts_names.add(pkg_name) solver_errors = self._update_sack() dependency_error_spec = self._enable_dependencies(module_dicts) if dependency_error_spec: error_specs.extend(dependency_error_spec) # fail_safe_repo = hawkey.MODULE_FAIL_SAFE_REPO_NAME install_dict = {} install_set_artifacts = set() fail_safe_repo_used = False # list of name: [profiles] for module profiles being removed removed_profiles = self.base._moduleContainer.getRemovedProfiles() for spec, (nsvcap, moduledict) in module_dicts.items(): for name, streamdict in moduledict.items(): for stream, module_list in streamdict.items(): install_module_list = [x for x in module_list if self.base._moduleContainer.isModuleActive(x.getId())] if not install_module_list: "No active matches for argument '{0}' in module '{1}:{2}'" logger.error(_("No active matches for argument '{0}' in module " "'{1}:{2}'").format(spec, name, stream)) error_specs.append(spec) continue profiles = [] latest_module = self._get_latest(install_module_list) if latest_module.getRepoID() == fail_safe_repo: msg = _( "Installing module '{0}' from Fail-Safe repository {1} is not allowed") logger.critical(msg.format(latest_module.getNameStream(), fail_safe_repo)) fail_safe_repo_used = True if nsvcap.profile: profiles.extend(latest_module.getProfiles(nsvcap.profile)) if not profiles: available_profiles = latest_module.getProfiles() if available_profiles: profile_names = ", ".join(sorted( [profile.getName() for profile in available_profiles])) msg = _("Unable to match profile for argument {}. Available " "profiles for '{}:{}': {}").format( spec, name, stream, profile_names) else: msg = _("Unable to match profile for argument {}").format(spec) logger.error(msg) no_match_specs.append(spec) continue elif name in removed_profiles: for profile in removed_profiles[name]: module_profiles = latest_module.getProfiles(profile) if not module_profiles: logger.warning( _("Installed profile '{0}' is not available in module " "'{1}' stream '{2}'").format(profile, name, stream)) continue profiles.extend(module_profiles) for profile in profiles: self.base._moduleContainer.install(latest_module, profile.getName()) for pkg_name in profile.getContent(): install_dict.setdefault(pkg_name, set()).add(spec) for module in install_module_list: artifacts = module.getArtifacts() install_set_artifacts.update(artifacts) for artifact in artifacts: arch = artifact.rsplit(".", 1)[1] if arch in src_arches: continue pkg_name = artifact.rsplit("-", 2)[0] new_artifacts_names.add(pkg_name) if fail_safe_repo_used: raise dnf.exceptions.Error(_( "Installing module from Fail-Safe repository is not allowed")) install_base_query, profiles_errors = self._install_profiles_internal( install_set_artifacts, install_dict, strict) if profiles_errors: error_specs.extend(profiles_errors) # distrosync module name all_names = set() all_names.update(new_artifacts_names) all_names.update(active_artifacts_names) remove_query = self.base.sack.query().filterm(empty=True) base_no_source_query = self.base.sack.query().filterm(arch__neq=['src', 'nosrc']).apply() for pkg_name in all_names: query = base_no_source_query.filter(name=pkg_name) installed = query.installed() if not installed: continue available = query.available() if not available: logger.warning(_("No packages available to distrosync for package name " "'{}'").format(pkg_name)) if pkg_name not in new_artifacts_names: remove_query = remove_query.union(query) continue only_new_module = query.intersection(install_base_query) if only_new_module: query = only_new_module sltr = dnf.selector.Selector(self.base.sack) sltr.set(pkg=query) self.base._goal.distupgrade(select=sltr) self.base._remove_if_unneeded(remove_query) if no_match_specs or error_specs or solver_errors: raise dnf.exceptions.MarkingErrors(no_match_group_specs=no_match_specs, error_group_specs=error_specs, module_depsolv_errors=solver_errors) def reset(self, module_specs): # :api no_match_specs, solver_errors = self._modules_reset_or_disable(module_specs, STATE_UNKNOWN) if no_match_specs: raise dnf.exceptions.MarkingErrors(no_match_group_specs=no_match_specs, module_depsolv_errors=solver_errors) def upgrade(self, module_specs): # :api no_match_specs = [] fail_safe_repo = hawkey.MODULE_FAIL_SAFE_REPO_NAME fail_safe_repo_used = False # Remove source packages because they cannot be installed or upgraded base_no_source_query = self.base.sack.query().filterm(arch__neq=['src', 'nosrc']).apply() for spec in module_specs: module_list, nsvcap = self._get_modules(spec) if not module_list: no_match_specs.append(spec) continue update_module_list = [x for x in module_list if self.base._moduleContainer.isModuleActive(x.getId())] if not update_module_list: logger.error(_("Unable to resolve argument {}").format(spec)) continue module_dict = self._create_module_dict_and_enable(update_module_list, spec, False) upgrade_package_set = set() for name, streamdict in module_dict.items(): for stream, module_list_from_dict in streamdict.items(): upgrade_package_set.update(self._get_package_name_set_and_remove_profiles( module_list_from_dict, nsvcap)) latest_module = self._get_latest(module_list_from_dict) if latest_module.getRepoID() == fail_safe_repo: msg = _( "Upgrading module '{0}' from Fail-Safe repository {1} is not allowed") logger.critical(msg.format(latest_module.getNameStream(), fail_safe_repo)) fail_safe_repo_used = True if nsvcap.profile: profiles_set = latest_module.getProfiles(nsvcap.profile) if not profiles_set: continue for profile in profiles_set: upgrade_package_set.update(profile.getContent()) else: for profile in latest_module.getProfiles(): upgrade_package_set.update(profile.getContent()) for artifact in latest_module.getArtifacts(): subj = hawkey.Subject(artifact) for nevra_obj in subj.get_nevra_possibilities( forms=[hawkey.FORM_NEVRA]): upgrade_package_set.add(nevra_obj.name) if not upgrade_package_set: logger.error(_("Unable to match profile in argument {}").format(spec)) query = base_no_source_query.filter(name=upgrade_package_set) if query: sltr = dnf.selector.Selector(self.base.sack) sltr.set(pkg=query) self.base._goal.upgrade(select=sltr) if fail_safe_repo_used: raise dnf.exceptions.Error(_( "Upgrading module from Fail-Safe repository is not allowed")) return no_match_specs def remove(self, module_specs): # :api no_match_specs = [] remove_package_set = set() for spec in module_specs: module_list, nsvcap = self._get_modules(spec) if not module_list: no_match_specs.append(spec) continue module_dict = self._create_module_dict_and_enable(module_list, spec, False) remove_packages_names = [] for name, streamdict in module_dict.items(): for stream, module_list_from_dict in streamdict.items(): remove_packages_names.extend(self._get_package_name_set_and_remove_profiles( module_list_from_dict, nsvcap, True)) if not remove_packages_names: logger.error(_("Unable to match profile in argument {}").format(spec)) remove_package_set.update(remove_packages_names) if remove_package_set: keep_pkg_names = self.base._moduleContainer.getInstalledPkgNames() remove_package_set = remove_package_set.difference(keep_pkg_names) if remove_package_set: query = self.base.sack.query().installed().filterm(name=remove_package_set) if query: self.base._remove_if_unneeded(query) return no_match_specs def get_modules(self, module_spec): # :api return self._get_modules(module_spec) def _get_modules(self, module_spec): # used by ansible (lib/ansible/modules/packaging/os/dnf.py) subj = hawkey.Subject(module_spec) for nsvcap in subj.nsvcap_possibilities(): name = nsvcap.name if nsvcap.name else "" stream = nsvcap.stream if nsvcap.stream else "" version = "" context = nsvcap.context if nsvcap.context else "" arch = nsvcap.arch if nsvcap.arch else "" if nsvcap.version and nsvcap.version != -1: version = str(nsvcap.version) modules = self.base._moduleContainer.query(name, stream, version, context, arch) if modules: return modules, nsvcap return (), None def _get_latest(self, module_list): latest = None if module_list: latest = module_list[0] for module in module_list[1:]: if module.getVersionNum() > latest.getVersionNum(): latest = module return latest def _create_module_dict_and_enable(self, module_list, spec, enable=True): moduleDict = {} for module in module_list: moduleDict.setdefault( module.getName(), {}).setdefault(module.getStream(), []).append(module) for moduleName, streamDict in moduleDict.items(): moduleState = self.base._moduleContainer.getModuleState(moduleName) if len(streamDict) > 1: if moduleState != STATE_DEFAULT and moduleState != STATE_ENABLED \ and moduleState != STATE_DISABLED: streams_str = "', '".join( sorted(streamDict.keys(), key=functools.cmp_to_key(self.base.sack.evr_cmp))) msg = _("Argument '{argument}' matches {stream_count} streams ('{streams}') of " "module '{module}', but none of the streams are enabled or " "default").format( argument=spec, stream_count=len(streamDict), streams=streams_str, module=moduleName) raise EnableMultipleStreamsException(moduleName, msg) if moduleState == STATE_ENABLED: stream = self.base._moduleContainer.getEnabledStream(moduleName) else: stream = self.base._moduleContainer.getDefaultStream(moduleName) if not stream or stream not in streamDict: raise EnableMultipleStreamsException(moduleName) for key in sorted(streamDict.keys()): if key == stream: if enable: self.base._moduleContainer.enable(moduleName, key) continue del streamDict[key] elif enable: for key in streamDict.keys(): self.base._moduleContainer.enable(moduleName, key) assert len(streamDict) == 1 return moduleDict def _resolve_specs_enable(self, module_specs): no_match_specs = [] error_spec = [] module_dicts = {} for spec in module_specs: module_list, nsvcap = self._get_modules(spec) if not module_list: no_match_specs.append(spec) continue try: module_dict = self._create_module_dict_and_enable(module_list, spec, True) module_dicts[spec] = (nsvcap, module_dict) except (RuntimeError, EnableMultipleStreamsException) as e: error_spec.append(spec) logger.error(ucd(e)) logger.error(_("Unable to resolve argument {}").format(spec)) return no_match_specs, error_spec, module_dicts def _update_sack(self): hot_fix_repos = [i.id for i in self.base.repos.iter_enabled() if i.module_hotfixes] try: solver_errors = self.base.sack.filter_modules( self.base._moduleContainer, hot_fix_repos, self.base.conf.installroot, self.base.conf.module_platform_id, update_only=True, debugsolver=self.base.conf.debug_solver) except hawkey.Exception as e: raise dnf.exceptions.Error(ucd(e)) return solver_errors def _enable_dependencies(self, module_dicts): error_spec = [] for spec, (nsvcap, moduleDict) in module_dicts.items(): for streamDict in moduleDict.values(): for modules in streamDict.values(): try: self.base._moduleContainer.enableDependencyTree( libdnf.module.VectorModulePackagePtr(modules)) except RuntimeError as e: error_spec.append(spec) logger.error(ucd(e)) logger.error(_("Unable to resolve argument {}").format(spec)) return error_spec def _resolve_specs_enable_update_sack(self, module_specs): no_match_specs, error_spec, module_dicts = self._resolve_specs_enable(module_specs) solver_errors = self._update_sack() dependency_error_spec = self._enable_dependencies(module_dicts) if dependency_error_spec: error_spec.extend(dependency_error_spec) return no_match_specs, error_spec, solver_errors, module_dicts def _modules_reset_or_disable(self, module_specs, to_state): no_match_specs = [] for spec in module_specs: module_list, nsvcap = self._get_modules(spec) if not module_list: logger.error(_("Unable to resolve argument {}").format(spec)) no_match_specs.append(spec) continue if nsvcap.stream or nsvcap.version or nsvcap.context or nsvcap.arch or nsvcap.profile: logger.info(_("Only module name is required. " "Ignoring unneeded information in argument: '{}'").format(spec)) module_names = set() for module in module_list: module_names.add(module.getName()) for name in module_names: if to_state == STATE_UNKNOWN: self.base._moduleContainer.reset(name) if to_state == STATE_DISABLED: self.base._moduleContainer.disable(name) solver_errors = self._update_sack() return no_match_specs, solver_errors def _get_package_name_set_and_remove_profiles(self, module_list, nsvcap, remove=False): package_name_set = set() latest_module = self._get_latest(module_list) installed_profiles_strings = set(self.base._moduleContainer.getInstalledProfiles( latest_module.getName())) if not installed_profiles_strings: return set() if nsvcap.profile: profiles_set = latest_module.getProfiles(nsvcap.profile) if not profiles_set: return set() for profile in profiles_set: if profile.getName() in installed_profiles_strings: if remove: self.base._moduleContainer.uninstall(latest_module, profile.getName()) package_name_set.update(profile.getContent()) else: for profile_string in installed_profiles_strings: if remove: self.base._moduleContainer.uninstall(latest_module, profile_string) for profile in latest_module.getProfiles(profile_string): package_name_set.update(profile.getContent()) return package_name_set def _get_info_profiles(self, module_specs): output = set() for module_spec in module_specs: module_list, nsvcap = self._get_modules(module_spec) if not module_list: logger.info(_("Unable to resolve argument {}").format(module_spec)) continue if nsvcap.profile: logger.info(_("Ignoring unnecessary profile: '{}/{}'").format( nsvcap.name, nsvcap.profile)) for module in module_list: lines = OrderedDict() lines["Name"] = module.getFullIdentifier() for profile in sorted(module.getProfiles(), key=_profile_comparison_key): lines[profile.getName()] = "\n".join( [pkgName for pkgName in profile.getContent()]) output.add(self._create_simple_table(lines).toString()) return "\n\n".join(sorted(output)) def _profile_report_formatter(self, modulePackage, default_profiles, enabled_str): installed_profiles = self.base._moduleContainer.getInstalledProfiles( modulePackage.getName()) available_profiles = modulePackage.getProfiles() profiles_str = "" for profile in sorted(available_profiles, key=_profile_comparison_key): profiles_str += "{}{}".format( profile.getName(), " [d]" if profile.getName() in default_profiles else "") profiles_str += " [i], " if profile.getName() in installed_profiles and enabled_str \ else ", " return profiles_str[:-2] def _summary_report_formatter(self, summary): return summary.strip().replace("\n", " ") def _module_strs_formatter(self, modulePackage, markActive=False): default_str = "" enabled_str = "" disabled_str = "" if modulePackage.getStream() == self.base._moduleContainer.getDefaultStream( modulePackage.getName()): default_str = " [d]" if self.base._moduleContainer.isEnabled(modulePackage): if not default_str: enabled_str = " " enabled_str += "[e]" elif self.base._moduleContainer.isDisabled(modulePackage): if not default_str: disabled_str = " " disabled_str += "[x]" if markActive and self.base._moduleContainer.isModuleActive(modulePackage): if not default_str: disabled_str = " " disabled_str += "[a]" return default_str, enabled_str, disabled_str def _get_info(self, module_specs): output = set() for module_spec in module_specs: module_list, nsvcap = self._get_modules(module_spec) if not module_list: logger.info(_("Unable to resolve argument {}").format(module_spec)) continue if nsvcap.profile: logger.info(_("Ignoring unnecessary profile: '{}/{}'").format( nsvcap.name, nsvcap.profile)) for modulePackage in module_list: default_str, enabled_str, disabled_str = self._module_strs_formatter( modulePackage, markActive=True) default_profiles = self.base._moduleContainer.getDefaultProfiles( modulePackage.getName(), modulePackage.getStream()) profiles_str = self._profile_report_formatter( modulePackage, default_profiles, enabled_str) lines = OrderedDict() lines["Name"] = modulePackage.getName() lines["Stream"] = modulePackage.getStream() + default_str + enabled_str + \ disabled_str lines["Version"] = modulePackage.getVersion() lines["Context"] = modulePackage.getContext() lines["Architecture"] = modulePackage.getArch() lines["Profiles"] = profiles_str lines["Default profiles"] = " ".join(default_profiles) lines["Repo"] = modulePackage.getRepoID() lines["Summary"] = modulePackage.getSummary() lines["Description"] = modulePackage.getDescription() req_set = set() for req in modulePackage.getModuleDependencies(): for require_dict in req.getRequires(): for mod_require, stream in require_dict.items(): req_set.add("{}:[{}]".format(mod_require, ",".join(stream))) lines["Requires"] = "\n".join(sorted(req_set)) lines["Artifacts"] = "\n".join(sorted(modulePackage.getArtifacts())) output.add(self._create_simple_table(lines).toString()) str_table = "\n\n".join(sorted(output)) if str_table: str_table += MODULE_INFO_TABLE_HINT return str_table @staticmethod def _create_simple_table(lines): table = libdnf.smartcols.Table() table.enableNoheadings(True) table.setColumnSeparator(" : ") column_name = table.newColumn("Name") column_value = table.newColumn("Value") column_value.setWrap(True) column_value.setSafechars("\n") column_value.setNewlineWrapFunction() for line_name, value in lines.items(): if value is None: value = "" line = table.newLine() line.getColumnCell(column_name).setData(line_name) line.getColumnCell(column_value).setData(str(value)) return table def _get_full_info(self, module_specs): output = set() for module_spec in module_specs: module_list, nsvcap = self._get_modules(module_spec) if not module_list: logger.info(_("Unable to resolve argument {}").format(module_spec)) continue if nsvcap.profile: logger.info(_("Ignoring unnecessary profile: '{}/{}'").format( nsvcap.name, nsvcap.profile)) for modulePackage in module_list: info = modulePackage.getYaml() if info: output.add(info) output_string = "\n\n".join(sorted(output)) return output_string def _what_provides(self, rpm_specs): output = set() modulePackages = self.base._moduleContainer.getModulePackages() baseQuery = self.base.sack.query().filterm(empty=True).apply() getBestInitQuery = self.base.sack.query(flags=hawkey.IGNORE_MODULAR_EXCLUDES) for spec in rpm_specs: subj = dnf.subject.Subject(spec) baseQuery = baseQuery.union(subj.get_best_query( self.base.sack, with_nevra=True, with_provides=False, with_filenames=False, query=getBestInitQuery)) baseQuery.apply() for modulePackage in modulePackages: artifacts = modulePackage.getArtifacts() if not artifacts: continue query = baseQuery.filter(nevra_strict=artifacts) if query: for pkg in query: string_output = "" profiles = [] for profile in sorted(modulePackage.getProfiles(), key=_profile_comparison_key): if pkg.name in profile.getContent(): profiles.append(profile.getName()) lines = OrderedDict() lines["Module"] = modulePackage.getFullIdentifier() lines["Profiles"] = " ".join(sorted(profiles)) lines["Repo"] = modulePackage.getRepoID() lines["Summary"] = modulePackage.getSummary() table = self._create_simple_table(lines) string_output += "{}\n".format(self.base.output.term.bold(str(pkg))) string_output += "{}".format(table.toString()) output.add(string_output) return "\n\n".join(sorted(output)) def _create_and_fill_table(self, latest): table = libdnf.smartcols.Table() table.setTermforce(libdnf.smartcols.Table.TermForce_AUTO) table.enableMaxout(True) column_name = table.newColumn("Name") column_stream = table.newColumn("Stream") column_profiles = table.newColumn("Profiles") column_profiles.setWrap(True) column_info = table.newColumn("Summary") column_info.setWrap(True) if not self.base.conf.verbose: column_info.hidden = True for latest_per_repo in latest: for nameStreamArch in latest_per_repo: if len(nameStreamArch) == 1: modulePackage = nameStreamArch[0] else: active = [module for module in nameStreamArch if self.base._moduleContainer.isModuleActive(module)] if active: modulePackage = active[0] else: modulePackage = nameStreamArch[0] line = table.newLine() default_str, enabled_str, disabled_str = self._module_strs_formatter( modulePackage, markActive=False) default_profiles = self.base._moduleContainer.getDefaultProfiles( modulePackage.getName(), modulePackage.getStream()) profiles_str = self._profile_report_formatter(modulePackage, default_profiles, enabled_str) line.getColumnCell(column_name).setData(modulePackage.getName()) line.getColumnCell( column_stream).setData( modulePackage.getStream() + default_str + enabled_str + disabled_str) line.getColumnCell(column_profiles).setData(profiles_str) summary_str = self._summary_report_formatter(modulePackage.getSummary()) line.getColumnCell(column_info).setData(summary_str) return table def _get_brief_description(self, module_specs, module_state): modules = [] if module_specs: for spec in module_specs: module_list, nsvcap = self._get_modules(spec) modules.extend(module_list) else: modules = self.base._moduleContainer.getModulePackages() latest = self.base._moduleContainer.getLatestModulesPerRepo(module_state, modules) if not latest: return "" table = self._create_and_fill_table(latest) current_repo_id_index = 0 already_printed_lines = 0 try: repo_name = self.base.repos[latest[0][0][0].getRepoID()].name except KeyError: repo_name = latest[0][0][0].getRepoID() versions = len(latest[0]) header = self._format_header(table) str_table = self._format_repoid(repo_name) str_table += header for i in range(0, table.getNumberOfLines()): if versions + already_printed_lines <= i: already_printed_lines += versions current_repo_id_index += 1 # Fail-Safe repository is not in self.base.repos try: repo_name = self.base.repos[ latest[current_repo_id_index][0][0].getRepoID()].name except KeyError: repo_name = latest[current_repo_id_index][0][0].getRepoID() versions = len(latest[current_repo_id_index]) str_table += "\n" str_table += self._format_repoid(repo_name) str_table += header line = table.getLine(i) str_table += table.toString(line, line) return str_table + MODULE_TABLE_HINT def _format_header(self, table): line = table.getLine(0) return table.toString(line, line).split('\n', 1)[0] + '\n' def _format_repoid(self, repo_name): return "{}\n".format(self.base.output.term.bold(repo_name)) def _install_profiles_internal(self, install_set_artifacts, install_dict, strict): # Remove source packages because they cannot be installed or upgraded base_no_source_query = self.base.sack.query().filterm(arch__neq=['src', 'nosrc']).apply() install_base_query = base_no_source_query.filter(nevra_strict=install_set_artifacts) error_specs = [] # add hot-fix packages hot_fix_repos = [i.id for i in self.base.repos.iter_enabled() if i.module_hotfixes] hotfix_packages = base_no_source_query.filter( reponame=hot_fix_repos, name=install_dict.keys()) install_base_query = install_base_query.union(hotfix_packages) for pkg_name, set_specs in install_dict.items(): query = install_base_query.filter(name=pkg_name) if not query: # package can also be non-modular or part of another stream query = base_no_source_query.filter(name=pkg_name) if not query: for spec in set_specs: logger.error(_("Unable to resolve argument {}").format(spec)) logger.error(_("No match for package {}").format(pkg_name)) error_specs.extend(set_specs) continue self.base._goal.group_members.add(pkg_name) sltr = dnf.selector.Selector(self.base.sack) sltr.set(pkg=query) self.base._goal.install(select=sltr, optional=(not strict)) return install_base_query, error_specs def format_modular_solver_errors(errors): msg = dnf.util._format_resolve_problems(errors) return "\n".join( [P_('Modular dependency problem:', 'Modular dependency problems:', len(errors)), msg])