folkslinux
/
tdnf
mirror of https://github.com/vmware/tdnf.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

support multiple packages

This commit is contained in:
Priyesh Padmavilasom 2015-11-06 05:42:02 +00:00
parent 3c74e3d080
commit 89d71e8e41
10 changed files with 789 additions and 331 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

40
client/api.c
View File

@ -646,8 +646,7 @@ TDNFResolve(
{
uint32_t dwError = 0;
HyQuery hQuery = NULL;
HyPackageList hPkgListGoal = NULL;
PTDNF_SOLVED_PKG_INFO pSolvedPkgInfo = NULL;
@ -659,13 +658,6 @@ TDNFResolve(
dwError = TDNFValidateCmdArgs(pTdnf);
BAIL_ON_TDNF_ERROR(dwError);
hQuery = hy_query_create(pTdnf->hSack);
if(!hQuery)
{
dwError = HY_E_FAILED;
BAIL_ON_TDNF_HAWKEY_ERROR(dwError);
}
dwError = TDNFAllocateMemory(
sizeof(TDNF_SOLVED_PKG_INFO),
(void**)&pSolvedPkgInfo);
@ -673,15 +665,22 @@ TDNFResolve(
pSolvedPkgInfo->nAlterType = nAlterType;
if(nAlterType == ALTER_UPGRADEALL || nAlterType == ALTER_DISTRO_SYNC)
{
dwError = TDNFResolveAll(pTdnf, pSolvedPkgInfo);
}
else
{
dwError = TDNFResolvePackages(pTdnf, pSolvedPkgInfo);
BAIL_ON_TDNF_ERROR(dwError);
}
dwError = TDNFAllocateMemory(
sizeof(char*) * pTdnf->pArgs->nCmdCount,
(void**)&pSolvedPkgInfo->ppszPkgsNotResolved);
BAIL_ON_TDNF_ERROR(dwError);
dwError = TDNFPrepareAllPackages(
pTdnf,
pSolvedPkgInfo,
&hPkgListGoal);
BAIL_ON_TDNF_ERROR(dwError);
dwError = TDNFGoal(
pTdnf,
hPkgListGoal,
pSolvedPkgInfo);
BAIL_ON_TDNF_ERROR(dwError);
pSolvedPkgInfo->nNeedAction =
pSolvedPkgInfo->pPkgsToInstall ||
@ -699,10 +698,11 @@ TDNFResolve(
pSolvedPkgInfo->pPkgsToReinstall;
*ppSolvedPkgInfo = pSolvedPkgInfo;
cleanup:
if(hQuery)
if(hPkgListGoal)
{
hy_query_free(hQuery);
hy_packagelist_free(hPkgListGoal);
}
return dwError;

286
client/goal.c
View File

@ -24,101 +24,47 @@ uint32_t
TDNFGoal(
PTDNF pTdnf,
HyPackageList hPkgList,
HySelector hSelector,
TDNF_ALTERTYPE nResolveFor,
PTDNF_SOLVED_PKG_INFO pInfo
)
{
uint32_t dwError = 0;
HyGoal hGoal = NULL;
HyPackage hPkg = NULL;
PTDNF_PKG_INFO pPkgsToInstall = NULL;
PTDNF_PKG_INFO pPkgsToUpgrade = NULL;
PTDNF_PKG_INFO pPkgsToDowngrade = NULL;
PTDNF_PKG_INFO pPkgsToRemove = NULL;
PTDNF_PKG_INFO pPkgsUnNeeded = NULL;
PTDNF_PKG_INFO pPkgsToReinstall = NULL;
PTDNF_PKG_INFO pPkgsObsoleted = NULL;
PTDNF_SOLVED_PKG_INFO pInfoTemp = NULL;
int nFlags = 0;
int nRequirePkgList =
(nResolveFor != ALTER_UPGRADEALL &&
nResolveFor != ALTER_DISTRO_SYNC);
int i = 0;
if(!pTdnf || !pInfo )
if(!pTdnf || !hPkgList || !pInfo )
{
dwError = ERROR_TDNF_INVALID_PARAMETER;
BAIL_ON_TDNF_ERROR(dwError);
}
if(nResolveFor == ALTER_UPGRADE && !hSelector)
{
dwError = ERROR_TDNF_INVALID_PARAMETER;
BAIL_ON_TDNF_ERROR(dwError);
}
if(nRequirePkgList)
{
if(!hPkgList)
{
dwError = ERROR_TDNF_INVALID_PARAMETER;
BAIL_ON_TDNF_ERROR(dwError);
}
hPkg = hy_packagelist_get(hPkgList, 0);
if(!hPkg)
{
dwError = ERROR_TDNF_PACKAGELIST_EMPTY;
BAIL_ON_TDNF_ERROR(dwError);
}
}
hGoal = hy_goal_create(pTdnf->hSack);
if(!hGoal)
{
dwError = ERROR_TDNF_GOAL_CREATE;
BAIL_ON_TDNF_ERROR(dwError);
}
switch(nResolveFor)
{
case ALTER_DOWNGRADE:
dwError = hy_goal_downgrade_to(hGoal, hPkg);
BAIL_ON_TDNF_HAWKEY_ERROR(dwError);
break;
case ALTER_ERASE:
dwError = hy_goal_erase(hGoal, hPkg);
BAIL_ON_TDNF_HAWKEY_ERROR(dwError);
break;
case ALTER_REINSTALL:
dwError = hy_goal_install(hGoal, hPkg);
BAIL_ON_TDNF_HAWKEY_ERROR(dwError);
break;
case ALTER_INSTALL:
dwError = TDNFPackageGetLatest(hPkgList, &hPkg);
BAIL_ON_TDNF_ERROR(dwError);
dwError = hy_goal_install(hGoal, hPkg);
BAIL_ON_TDNF_HAWKEY_ERROR(dwError);
break;
case ALTER_UPGRADE:
dwError = hy_goal_upgrade_to_selector(hGoal, hSelector);
BAIL_ON_TDNF_HAWKEY_ERROR(dwError);
break;
case ALTER_UPGRADEALL:
dwError = hy_goal_upgrade_all(hGoal);
BAIL_ON_TDNF_HAWKEY_ERROR(dwError);
break;
case ALTER_DISTRO_SYNC:
dwError = hy_goal_distupgrade_all(hGoal);
BAIL_ON_TDNF_HAWKEY_ERROR(dwError);
break;
case ALTER_AUTOERASE:
dwError = TDNFGoalSetUserInstalled(hGoal, hPkgList);
BAIL_ON_TDNF_HAWKEY_ERROR(dwError);
break;
default:
dwError = ERROR_TDNF_INVALID_RESOLVE_ARG;
BAIL_ON_TDNF_ERROR(dwError);
if(pInfo->nAlterType == ALTER_UPGRADEALL)
{
dwError = hy_goal_upgrade_all(hGoal);
BAIL_ON_TDNF_HAWKEY_ERROR(dwError);
}
else if(pInfo->nAlterType == ALTER_DISTRO_SYNC)
{
dwError = hy_goal_distupgrade_all(hGoal);
BAIL_ON_TDNF_HAWKEY_ERROR(dwError);
}
else
{
FOR_PACKAGELIST(hPkg, hPkgList, i)
{
TDNFAddGoal(pTdnf, pInfo->nAlterType, hGoal, hPkg);
}
}
if(pTdnf->pArgs->nBest)
@ -126,8 +72,8 @@ TDNFGoal(
nFlags = nFlags | HY_FORCE_BEST;
}
if(pTdnf->pArgs->nAllowErasing ||
nResolveFor == ALTER_ERASE ||
nResolveFor == ALTER_AUTOERASE)
pInfo->nAlterType == ALTER_ERASE ||
pInfo->nAlterType == ALTER_AUTOERASE)
{
nFlags = nFlags | HY_ALLOW_UNINSTALL;
}
@ -139,53 +85,24 @@ TDNFGoal(
}
BAIL_ON_TDNF_HAWKEY_ERROR(dwError);
dwError = TDNFGoalGetResultsIgnoreNoData(
hy_goal_list_installs(hGoal),
&pPkgsToInstall);
dwError = TDNFGoalGetAllResultsIgnoreNoData(
pInfo->nAlterType,
hGoal,
&pInfoTemp);
BAIL_ON_TDNF_ERROR(dwError);
dwError = TDNFGoalGetResultsIgnoreNoData(
hy_goal_list_upgrades(hGoal),
&pPkgsToUpgrade);
BAIL_ON_TDNF_ERROR(dwError);
pInfo->pPkgsToInstall = pInfoTemp->pPkgsToInstall;
pInfo->pPkgsToUpgrade = pInfoTemp->pPkgsToUpgrade;
pInfo->pPkgsToDowngrade = pInfoTemp->pPkgsToDowngrade;
pInfo->pPkgsToRemove = pInfoTemp->pPkgsToRemove;
pInfo->pPkgsUnNeeded = pInfoTemp->pPkgsUnNeeded;
pInfo->pPkgsToReinstall = pInfoTemp->pPkgsToReinstall;
pInfo->pPkgsObsoleted = pInfoTemp->pPkgsObsoleted;
dwError = TDNFGoalGetResultsIgnoreNoData(
hy_goal_list_downgrades(hGoal),
&pPkgsToDowngrade);
BAIL_ON_TDNF_ERROR(dwError);
dwError = TDNFGoalGetResultsIgnoreNoData(
hy_goal_list_erasures(hGoal),
&pPkgsToRemove);
BAIL_ON_TDNF_ERROR(dwError);
dwError = TDNFGoalGetResultsIgnoreNoData(
hy_goal_list_obsoleted(hGoal),
&pPkgsObsoleted);
BAIL_ON_TDNF_ERROR(dwError);
if(nResolveFor == ALTER_AUTOERASE)
{
dwError = TDNFGoalGetResultsIgnoreNoData(
hy_goal_list_unneeded(hGoal),
&pPkgsUnNeeded);
BAIL_ON_TDNF_ERROR(dwError);
}
dwError = TDNFGoalGetResultsIgnoreNoData(
hy_goal_list_reinstalls(hGoal),
&pPkgsToReinstall);
BAIL_ON_TDNF_ERROR(dwError);
pInfo->pPkgsToInstall = pPkgsToInstall;
pInfo->pPkgsToUpgrade = pPkgsToUpgrade;
pInfo->pPkgsToDowngrade = pPkgsToDowngrade;
pInfo->pPkgsToRemove = pPkgsToRemove;
pInfo->pPkgsUnNeeded = pPkgsUnNeeded;
pInfo->pPkgsToReinstall = pPkgsToReinstall;
pInfo->pPkgsObsoleted = pPkgsObsoleted;
pTdnf->hGoal = hGoal;
cleanup:
TDNF_SAFE_FREE_MEMORY(pInfoTemp);
return dwError;
error:
@ -194,33 +111,136 @@ error:
TDNFGoalReportProblems(hGoal);
hy_goal_free(hGoal);
}
if(pPkgsToInstall)
goto cleanup;
}
uint32_t
TDNFAddGoal(
PTDNF pTdnf,
int nAlterType,
HyGoal hGoal,
HyPackage hPkg
)
{
uint32_t dwError = 0;
HySelector hSelector = NULL;
const char* pszPkg = NULL;
if(!hGoal || !hPkg)
{
TDNFFreePackageInfo(pPkgsToInstall);
dwError = ERROR_TDNF_INVALID_PARAMETER;
BAIL_ON_TDNF_ERROR(dwError);
}
if(pPkgsToUpgrade)
switch(nAlterType)
{
TDNFFreePackageInfo(pPkgsToUpgrade);
case ALTER_DOWNGRADEALL:
case ALTER_DOWNGRADE:
dwError = hy_goal_downgrade_to(hGoal, hPkg);
BAIL_ON_TDNF_HAWKEY_ERROR(dwError);
break;
case ALTER_ERASE:
dwError = hy_goal_erase(hGoal, hPkg);
BAIL_ON_TDNF_HAWKEY_ERROR(dwError);
break;
case ALTER_REINSTALL:
case ALTER_INSTALL:
dwError = hy_goal_install(hGoal, hPkg);
BAIL_ON_TDNF_HAWKEY_ERROR(dwError);
break;
case ALTER_UPGRADE:
pszPkg = hy_package_get_name(hPkg);
TDNFGetSelector(pTdnf, pszPkg, &hSelector);
BAIL_ON_TDNF_ERROR(dwError);
dwError = hy_goal_upgrade_to_selector(hGoal, hSelector);
BAIL_ON_TDNF_HAWKEY_ERROR(dwError);
break;
case ALTER_AUTOERASE:
//dwError = TDNFGoalSetUserInstalled(hGoal, hPkgList);
BAIL_ON_TDNF_HAWKEY_ERROR(dwError);
break;
default:
dwError = ERROR_TDNF_INVALID_RESOLVE_ARG;
BAIL_ON_TDNF_ERROR(dwError);
}
if(pPkgsToDowngrade)
cleanup:
return dwError;
error:
goto cleanup;
}
uint32_t
TDNFGoalGetAllResultsIgnoreNoData(
int nResolveFor,
HyGoal hGoal,
PTDNF_SOLVED_PKG_INFO* ppInfo
)
{
uint32_t dwError = 0;
PTDNF_SOLVED_PKG_INFO pInfo = NULL;
if(!hGoal || !ppInfo)
{
TDNFFreePackageInfo(pPkgsToDowngrade);
dwError = ERROR_TDNF_INVALID_PARAMETER;
BAIL_ON_TDNF_ERROR(dwError);
}
if(pPkgsToRemove)
dwError = TDNFAllocateMemory(
sizeof(TDNF_SOLVED_PKG_INFO),
(void**)&pInfo);
BAIL_ON_TDNF_ERROR(dwError);
dwError = TDNFGoalGetResultsIgnoreNoData(
hy_goal_list_installs(hGoal),
&pInfo->pPkgsToInstall);
BAIL_ON_TDNF_ERROR(dwError);
dwError = TDNFGoalGetResultsIgnoreNoData(
hy_goal_list_upgrades(hGoal),
&pInfo->pPkgsToUpgrade);
BAIL_ON_TDNF_ERROR(dwError);
dwError = TDNFGoalGetResultsIgnoreNoData(
hy_goal_list_downgrades(hGoal),
&pInfo->pPkgsToDowngrade);
BAIL_ON_TDNF_ERROR(dwError);
dwError = TDNFGoalGetResultsIgnoreNoData(
hy_goal_list_erasures(hGoal),
&pInfo->pPkgsToRemove);
BAIL_ON_TDNF_ERROR(dwError);
if(nResolveFor == ALTER_AUTOERASE)
{
TDNFFreePackageInfo(pPkgsToRemove);
dwError = TDNFGoalGetResultsIgnoreNoData(
hy_goal_list_unneeded(hGoal),
&pInfo->pPkgsUnNeeded);
BAIL_ON_TDNF_ERROR(dwError);
}
if(pPkgsUnNeeded)
dwError = TDNFGoalGetResultsIgnoreNoData(
hy_goal_list_reinstalls(hGoal),
&pInfo->pPkgsToReinstall);
BAIL_ON_TDNF_ERROR(dwError);
dwError = TDNFGoalGetResultsIgnoreNoData(
hy_goal_list_obsoleted(hGoal),
&pInfo->pPkgsObsoleted);
BAIL_ON_TDNF_ERROR(dwError);
*ppInfo = pInfo;
cleanup:
return dwError;
error:
if(ppInfo)
{
TDNFFreePackageInfo(pPkgsUnNeeded);
*ppInfo = NULL;
}
if(pPkgsToReinstall)
if(pInfo)
{
TDNFFreePackageInfo(pPkgsToReinstall);
}
if(pPkgsObsoleted)
{
TDNFFreePackageInfo(pPkgsObsoleted);
TDNFFreeSolvedPackageInfo(pInfo);
}
goto cleanup;
}

10
client/memory.c
View File

@ -124,6 +124,7 @@ TDNFFreeSolvedPackageInfo(
PTDNF_SOLVED_PKG_INFO pSolvedPkgInfo
)
{
int i = 0;
if(pSolvedPkgInfo)
{
TDNF_SAFE_FREE_PKGINFO(pSolvedPkgInfo->pPkgsNotAvailable);
@ -135,6 +136,15 @@ TDNFFreeSolvedPackageInfo(
TDNF_SAFE_FREE_PKGINFO(pSolvedPkgInfo->pPkgsUnNeeded);
TDNF_SAFE_FREE_PKGINFO(pSolvedPkgInfo->pPkgsToReinstall);
TDNF_SAFE_FREE_PKGINFO(pSolvedPkgInfo->pPkgsObsoleted);
if(pSolvedPkgInfo->ppszPkgsNotResolved)
{
while(pSolvedPkgInfo->ppszPkgsNotResolved[i])
{
TDNF_SAFE_FREE_MEMORY(pSolvedPkgInfo->ppszPkgsNotResolved[i++]);
}
}
TDNF_SAFE_FREE_MEMORY(pSolvedPkgInfo->ppszPkgsNotResolved);
}
TDNF_SAFE_FREE_MEMORY(pSolvedPkgInfo);
}

197
client/packageutils.c
View File

@ -686,3 +686,200 @@ error:
}
goto cleanup;
}
uint32_t
TDNFAppendPackages(
PTDNF_PKG_INFO* ppDest,
PTDNF_PKG_INFO pSource
)
{
uint32_t dwError = 0;
PTDNF_PKG_INFO pDest = NULL;
if(!ppDest || !pSource)
{
dwError = ERROR_TDNF_INVALID_PARAMETER;
BAIL_ON_TDNF_ERROR(dwError);
}
pDest = *ppDest;
if(!pDest)
{
*ppDest = pSource;
}
else
{
while(pDest->pNext)
{
pDest = pDest->pNext;
}
pDest->pNext = pSource;
}
cleanup:
return dwError;
error:
if(ppDest)
{
*ppDest = NULL;
}
goto cleanup;
}
uint32_t
TDNFPackageGetDowngrade(
HyPackageList hPkgList,
HyPackage hPkgCurrent,
HyPackage* phPkgDowngrade
)
{
uint32_t dwError = 0;
HyPackage hPkgDowngrade = NULL;
HyPackage hPkg = NULL;
int i = 0;
if(!hPkgList || !hPkgCurrent || !phPkgDowngrade)
{
dwError = ERROR_TDNF_INVALID_PARAMETER;
BAIL_ON_TDNF_ERROR(dwError);
}
FOR_PACKAGELIST(hPkg, hPkgList, i)
{
if(hy_package_evr_cmp(hPkg, hPkgCurrent) < 0)
{
if(!hPkgDowngrade)
{
hPkgDowngrade = hPkg;
}
else if(hy_package_evr_cmp(hPkg, hPkgDowngrade) > 0)
{
hPkgDowngrade = hPkg;
}
}
}
if(!hPkgDowngrade)
{
dwError = ERROR_TDNF_NO_DOWNGRADES;
BAIL_ON_TDNF_ERROR(dwError);
}
*phPkgDowngrade = hPkgDowngrade;
cleanup:
return dwError;
error:
if(phPkgDowngrade)
{
*phPkgDowngrade = NULL;
}
goto cleanup;
}
uint32_t
TDNFGetGlobPackages(
PTDNF pTdnf,
char* pszPkgGlob,
HyPackageList* phPkgList
)
{
uint32_t dwError = 0;
HyQuery hQuery = NULL;
HyPackageList hPkgList = NULL;
char* ppszPkgGlob[2] = {pszPkgGlob, 0};
if(!pTdnf || IsNullOrEmptyString(pszPkgGlob) || !phPkgList)
{
dwError = ERROR_TDNF_INVALID_PARAMETER;
BAIL_ON_TDNF_ERROR(dwError);
}
hQuery = hy_query_create(pTdnf->hSack);
if(!hQuery)
{
dwError = HY_E_IO;
BAIL_ON_TDNF_HAWKEY_ERROR(dwError);
}
dwError = TDNFApplyPackageFilter(hQuery, ppszPkgGlob);
BAIL_ON_TDNF_ERROR(dwError);
hPkgList = hy_query_run(hQuery);
if(!hPkgList)
{
dwError = HY_E_IO;
BAIL_ON_TDNF_HAWKEY_ERROR(dwError);
}
*phPkgList = hPkgList;
cleanup:
if(hQuery)
{
hy_query_free(hQuery);
}
return dwError;
error:
if(phPkgList)
{
*phPkgList = NULL;
}
goto cleanup;
}
uint32_t
TDNFGetDowngradeablePkgs(
PTDNF pTdnf,
HyPackageList* phPkgList
)
{
uint32_t dwError = 0;
HyQuery hQuery = NULL;
HyPackageList hPkgList = NULL;
if(!pTdnf || !phPkgList)
{
dwError = ERROR_TDNF_INVALID_PARAMETER;
BAIL_ON_TDNF_ERROR(dwError);
}
hQuery = hy_query_create(pTdnf->hSack);
if(!hQuery)
{
dwError = HY_E_IO;
BAIL_ON_TDNF_HAWKEY_ERROR(dwError);
}
dwError = TDNFApplyScopeFilter(hQuery, SCOPE_DOWNGRADES);
BAIL_ON_TDNF_ERROR(dwError);
hPkgList = hy_query_run(hQuery);
if(!hPkgList)
{
dwError = HY_E_IO;
BAIL_ON_TDNF_HAWKEY_ERROR(dwError);
}
*phPkgList = hPkgList;
cleanup:
if(hQuery)
{
hy_query_free(hQuery);
}
return dwError;
error:
if(phPkgList)
{
*phPkgList = NULL;
}
if(hPkgList)
{
hy_packagelist_free(hPkgList);
}
goto cleanup;
}

70
client/prototypes.h
View File

@ -224,6 +224,32 @@ TDNFPackageGetLatest(
HyPackage* phPkgLatest
);
uint32_t
TDNFAppendPackages(
PTDNF_PKG_INFO* ppDest,
PTDNF_PKG_INFO pSource
);
uint32_t
TDNFPackageGetDowngrade(
HyPackageList hPkgList,
HyPackage hPkgCurrent,
HyPackage* phPkgDowngrade
);
uint32_t
TDNFGetGlobPackages(
PTDNF pTdnf,
char* pszPkgGlob,
HyPackageList* phPkgList
);
uint32_t
TDNFGetDowngradeablePkgs(
PTDNF pTdnf,
HyPackageList* phPkgList
);
//goal.c
uint32_t
TDNFGoalGetResultsIgnoreNoData(
@ -247,8 +273,6 @@ uint32_t
TDNFGoal(
PTDNF pTdnf,
HyPackageList hPkgList,
HySelector hSelector,
TDNF_ALTERTYPE nResolveFor,
PTDNF_SOLVED_PKG_INFO pInfo
);
@ -256,6 +280,22 @@ uint32_t
TDNFGoalReportProblems(
HyGoal hGoal
);
uint32_t
TDNFAddGoal(
PTDNF pTdnf,
int nAlterType,
HyGoal hGoal,
HyPackage hPkg
);
uint32_t
TDNFGoalGetAllResultsIgnoreNoData(
int nResolveFor,
HyGoal hGoal,
PTDNF_SOLVED_PKG_INFO* ppInfo
);
//config.c
int
TDNFConfGetRpmVerbosity(
@ -420,15 +460,33 @@ TDNFGetSelector(
);
uint32_t
TDNFResolveAll(
TDNFPrepareAllPackages(
PTDNF pTdnf,
PTDNF_SOLVED_PKG_INFO pSolvedPkgInfo
PTDNF_SOLVED_PKG_INFO pSolvedPkgInfo,
HyPackageList* phPkgListGoal
);
uint32_t
TDNFResolvePackages(
TDNFPrepareAndAddPkg(
PTDNF pTdnf,
PTDNF_SOLVED_PKG_INFO pSolvedPkgInfo
const char* pszPkgName,
PTDNF_SOLVED_PKG_INFO pSolvedPkgInfo,
HyPackageList hPkgListGoal
);
uint32_t
TDNFPrepareSinglePkg(
PTDNF pTdnf,
const char* pszPkgName,
PTDNF_SOLVED_PKG_INFO pSolvedPkgInfo,
HyPackageList* phPkgListGoal
);
uint32_t
TDNFAddDowngradeable(
PTDNF pTdnf,
PTDNF_SOLVED_PKG_INFO pSolvedPkgInfo,
HyPackageList hPkgListGoal
);
//rpmtrans.c

466
client/resolve.c
View File

@ -21,76 +21,33 @@
#include "includes.h"
uint32_t
TDNFGetMatchingInstalledAndAvailable(
PTDNF pTdnf,
int nAlterType,
const char* pszName,
TDNFAddNotResolved(
PTDNF_SOLVED_PKG_INFO pSolvedInfo,
HyPackageList* phPkgListGoal
const char* pszPkgName
)
{
uint32_t dwError = 0;
HyPackageList hPkgListGoal = NULL;
HyPackageList hPkgsInstalled = NULL;
HyPackageList hPkgsAvailable = NULL;
uint32_t dwError = 0 ;
int nIndex = 0;
if(!pTdnf || !pSolvedInfo || IsNullOrEmptyString(pszName) || !phPkgListGoal)
if(!pSolvedInfo ||
!pSolvedInfo->ppszPkgsNotResolved ||
IsNullOrEmptyString(pszPkgName))
{
dwError = ERROR_TDNF_INVALID_PARAMETER;
BAIL_ON_TDNF_ERROR(dwError);
}
dwError = TDNFGetMatching(
pTdnf,
1,//Installed
pszName,
&hPkgsInstalled);
while(pSolvedInfo->ppszPkgsNotResolved[nIndex++]);
dwError = TDNFAllocateString(
pszPkgName,
&pSolvedInfo->ppszPkgsNotResolved[--nIndex]);
BAIL_ON_TDNF_ERROR(dwError);
dwError = TDNFGetMatching(
pTdnf,
0,//Available
pszName,
&hPkgsAvailable);
BAIL_ON_TDNF_ERROR(dwError);
dwError = TDNFGetGoalPackageList(
nAlterType,
hPkgsInstalled,
hPkgsAvailable,
&hPkgListGoal);
BAIL_ON_TDNF_ERROR(dwError);
if(hy_packagelist_count(hPkgsInstalled) > 0 && nAlterType == ALTER_INSTALL)
{
dwError = TDNFPopulatePkgInfos(
hPkgsInstalled,
&pSolvedInfo->pPkgsExisting);
BAIL_ON_TDNF_ERROR(dwError);
}
*phPkgListGoal = hPkgListGoal;
cleanup:
if(hPkgsInstalled)
{
hy_packagelist_free(hPkgsInstalled);
}
if(hPkgsAvailable)
{
hy_packagelist_free(hPkgsAvailable);
}
return dwError;
error:
if(phPkgListGoal)
{
*phPkgListGoal = NULL;
}
if(hPkgListGoal)
{
hy_packagelist_free(hPkgListGoal);
}
goto cleanup;
}
@ -158,61 +115,6 @@ error:
goto cleanup;
}
uint32_t
TDNFGetGoalPackageList(
TDNF_ALTERTYPE nAlterType,
HyPackageList hPkgsInstalled,
HyPackageList hPkgsAvailable,
HyPackageList* phPkgList
)
{
uint32_t dwError = 0;
HyPackage hPkg = NULL;
HyPackageList hPkgList = NULL;
int i = 0;
hPkgList = hy_packagelist_create();
if(!hPkgList)
{
dwError = ERROR_TDNF_OUT_OF_MEMORY;
BAIL_ON_TDNF_ERROR(dwError);
}
if(nAlterType == ALTER_INSTALL)
{
FOR_PACKAGELIST(hPkg, hPkgsAvailable, i)
{
if(!hy_packagelist_has(hPkgsInstalled, hPkg))
{
hy_packagelist_push(hPkgList, hPkg);
}
}
}
else if(nAlterType == ALTER_ERASE || nAlterType == ALTER_AUTOERASE)
{
FOR_PACKAGELIST(hPkg, hPkgsInstalled, i)
{
hy_packagelist_push(hPkgList, hPkg);
}
}
else if(nAlterType == ALTER_UPGRADE || nAlterType == ALTER_DOWNGRADE)
{
}
*phPkgList = hPkgList;
cleanup:
return dwError;
error:
if(phPkgList)
{
*phPkgList = NULL;
}
TDNF_SAFE_FREE_PKGLIST(hPkgList);
goto cleanup;
}
uint32_t
TDNFGetSelector(
PTDNF pTdnf,
@ -361,49 +263,200 @@ error:
}
uint32_t
TDNFResolveAll(
TDNFPrepareAllPackages(
PTDNF pTdnf,
PTDNF_SOLVED_PKG_INFO pSolvedPkgInfo
PTDNF_SOLVED_PKG_INFO pSolvedPkgInfo,
HyPackageList* phPkgListGoal
)
{
uint32_t dwError = 0;
HyPackageList hPkgListGoal = NULL;
HyPackageList hPkgListGlob = NULL;
HyPackage hPkgGlob = NULL;
if(!pTdnf || !pSolvedPkgInfo)
PTDNF_CMD_ARGS pCmdArgs = NULL;
int nCmdIndex = 0;
int nPkgIndex = 0;
char* pszPkgName = NULL;
if(!pTdnf || !pTdnf->pArgs || !pSolvedPkgInfo || !phPkgListGoal)
{
dwError = ERROR_TDNF_INVALID_PARAMETER;
BAIL_ON_TDNF_ERROR(dwError);
}
dwError = TDNFGoal(
pTdnf,
NULL,
NULL,
pSolvedPkgInfo->nAlterType,
pSolvedPkgInfo);
BAIL_ON_TDNF_ERROR(dwError);
pCmdArgs = pTdnf->pArgs;
hPkgListGoal = hy_packagelist_create();
if(pSolvedPkgInfo->nAlterType == ALTER_DOWNGRADEALL)
{
dwError = TDNFAddDowngradeable(pTdnf, pSolvedPkgInfo, hPkgListGoal);
BAIL_ON_TDNF_ERROR(dwError);
}
for(nCmdIndex = 1; nCmdIndex < pCmdArgs->nCmdCount; ++nCmdIndex)
{
pszPkgName = pCmdArgs->ppszCmds[nCmdIndex];
if(TDNFIsGlob(pszPkgName))
{
dwError = TDNFGetGlobPackages(pTdnf, pszPkgName, &hPkgListGlob);
BAIL_ON_TDNF_ERROR(dwError);
nPkgIndex = 0;
FOR_PACKAGELIST(hPkgGlob, hPkgListGlob, nPkgIndex)
{
dwError = TDNFPrepareAndAddPkg(
pTdnf,
hy_package_get_name(hPkgGlob),
pSolvedPkgInfo,
hPkgListGoal);
BAIL_ON_TDNF_ERROR(dwError);
}
if(nPkgIndex == 0)
{
dwError = TDNFAddNotResolved(pSolvedPkgInfo, pszPkgName);
BAIL_ON_TDNF_ERROR(dwError);
}
}
else
{
dwError = TDNFPrepareAndAddPkg(
pTdnf,
pszPkgName,
pSolvedPkgInfo,
hPkgListGoal);
BAIL_ON_TDNF_ERROR(dwError);
}
}
*phPkgListGoal = hPkgListGoal;
cleanup:
if(hPkgListGlob)
{
hy_packagelist_free(hPkgListGlob);
}
return dwError;
error:
if(phPkgListGoal)
{
*phPkgListGoal = NULL;
}
if(hPkgListGoal)
{
hy_packagelist_free(hPkgListGoal);
}
goto cleanup;
}
uint32_t
TDNFAddDowngradeable(
PTDNF pTdnf,
PTDNF_SOLVED_PKG_INFO pSolvedPkgInfo,
HyPackageList hPkgListGoal
)
{
uint32_t dwError = 0;
HyPackageList hPkgList = NULL;
HyPackage hPkg = NULL;
int nPkgIndex = 0;
if(!pTdnf || !pSolvedPkgInfo || !hPkgListGoal)
{
dwError = ERROR_TDNF_INVALID_PARAMETER;
BAIL_ON_TDNF_ERROR(dwError);
}
dwError = TDNFGetDowngradeablePkgs(pTdnf, &hPkgList);
BAIL_ON_TDNF_ERROR(dwError);
nPkgIndex = 0;
FOR_PACKAGELIST(hPkg, hPkgList, nPkgIndex)
{
dwError = TDNFPrepareAndAddPkg(
pTdnf,
hy_package_get_name(hPkg),
pSolvedPkgInfo,
hPkgListGoal);
BAIL_ON_TDNF_ERROR(dwError);
}
cleanup:
if(hPkgList)
{
hy_packagelist_free(hPkgList);
}
return dwError;
error:
goto cleanup;
}
uint32_t
TDNFResolvePackages(
TDNFPrepareAndAddPkg(
PTDNF pTdnf,
PTDNF_SOLVED_PKG_INFO pSolvedPkgInfo
const char* pszPkgName,
PTDNF_SOLVED_PKG_INFO pSolvedPkgInfo,
HyPackageList hPkgListGoal
)
{
uint32_t dwError = 0;
HyPackageList hPkgList = NULL;
HyPackageList hPkgListGoal = NULL;
HySelector hSelector = NULL;
HyPackage hPkgTemp = NULL;
const char* pszPkgName = NULL;
int nAlterType = -1;
HyPackage hPkg = NULL;
int nPkgIndex = 0;
if(!pTdnf || !pSolvedPkgInfo)
if( !pTdnf ||
IsNullOrEmptyString(pszPkgName) ||
!pSolvedPkgInfo ||
!hPkgListGoal)
{
dwError = ERROR_TDNF_INVALID_PARAMETER;
BAIL_ON_TDNF_ERROR(dwError);
}
dwError = TDNFPrepareSinglePkg(
pTdnf,
pszPkgName,
pSolvedPkgInfo,
&hPkgList);
BAIL_ON_TDNF_ERROR(dwError);
if(hPkgList)
{
FOR_PACKAGELIST(hPkg, hPkgList, nPkgIndex)
{
hy_packagelist_push(hPkgListGoal, hPkg);
}
}
cleanup:
//do not free hPkgList as it is shallow copied to hPkgListGoal
return dwError;
error:
goto cleanup;
}
uint32_t
TDNFPrepareSinglePkg(
PTDNF pTdnf,
const char* pszPkgName,
PTDNF_SOLVED_PKG_INFO pSolvedPkgInfo,
HyPackageList* phPkgListGoal
)
{
uint32_t dwError = 0;
HyPackageList hPkgListGoal = NULL;
HyPackageList hPkgListGoalTemp = NULL;
HyPackage hPkgTemp = NULL;
HyPackage hPkg = NULL;
HySelector hSelector = NULL;
int i = 0;
int nAlterType = 0;
if(!pTdnf
|| IsNullOrEmptyString(pszPkgName)
|| !pSolvedPkgInfo
|| !phPkgListGoal)
{
dwError = ERROR_TDNF_INVALID_PARAMETER;
BAIL_ON_TDNF_ERROR(dwError);
@ -411,8 +464,12 @@ TDNFResolvePackages(
nAlterType = pSolvedPkgInfo->nAlterType;
//TODO: support multiple packages
pszPkgName = pTdnf->pArgs->ppszCmds[1];
//Check if this is a known package. If not add to unresolved
dwError = TDNFGetSelector(
pTdnf,
pszPkgName,
&hSelector);
BAIL_ON_TDNF_ERROR(dwError);
//Check if package is installed before proceeding
if(nAlterType == ALTER_ERASE)
@ -437,68 +494,135 @@ TDNFResolvePackages(
&hPkgListGoal);
BAIL_ON_TDNF_ERROR(dwError);
}
else
else if(hSelector != NULL)
{
dwError = TDNFGetSelector(
pTdnf,
pszPkgName,
&hSelector);
BAIL_ON_TDNF_ERROR(dwError);
if(hSelector != NULL)
hPkgListGoalTemp = hy_selector_matches(hSelector);
hPkgListGoal = hy_packagelist_create();
if(nAlterType == ALTER_ERASE)
{
hPkgListGoal = hy_selector_matches(hSelector);
FOR_PACKAGELIST(hPkg, hPkgListGoalTemp, i)
{
if(hy_package_installed(hPkg))
{
hy_packagelist_push(hPkgListGoal, hPkg);
break;
}
}
}
else
else if (nAlterType == ALTER_INSTALL)
{
dwError = TDNFGetMatchingInstalledAndAvailable(
pTdnf,
nAlterType,
pszPkgName,
pSolvedPkgInfo,
&hPkgListGoal);
//Find if the package is installed from matching list
//TODO: Move to packageutils with appropriate name
FOR_PACKAGELIST(hPkg, hPkgListGoalTemp, i)
{
if(hy_package_installed(hPkg))
{
break;
}
}
dwError = TDNFPackageGetLatest(hPkgListGoalTemp, &hPkgTemp);
BAIL_ON_TDNF_ERROR(dwError);
}
}
if(hy_packagelist_count(hPkgListGoal) > 0)
{
dwError = TDNFGoal(
pTdnf,
hPkgListGoal,
hSelector,
nAlterType,
pSolvedPkgInfo);
BAIL_ON_TDNF_ERROR(dwError);
if(hPkg)
{
if(hy_package_evr_cmp(hPkgTemp, hPkg))
{
hy_packagelist_push(hPkgListGoal, hPkgTemp);
}
}
else
{
hy_packagelist_push(hPkgListGoal, hPkgTemp);
}
}
else if (nAlterType == ALTER_UPGRADE)
{
//Find installed package.
//TODO: Move to packageutils with appropriate name
FOR_PACKAGELIST(hPkg, hPkgListGoalTemp, i)
{
if(hy_package_installed(hPkg))
{
break;
}
}
if(hPkg == NULL)
{
dwError = ERROR_TDNF_NO_SEARCH_RESULTS;
BAIL_ON_TDNF_ERROR(dwError);
}
dwError = TDNFPackageGetLatest(hPkgListGoalTemp, &hPkgTemp);
BAIL_ON_TDNF_ERROR(dwError);
hy_packagelist_push(hPkgListGoal, hPkgTemp);
}
else if (nAlterType == ALTER_DOWNGRADE || nAlterType == ALTER_DOWNGRADEALL)
{
//Find installed package.
//TODO: Move to packageutils with appropriate name
FOR_PACKAGELIST(hPkg, hPkgListGoalTemp, i)
{
if(hy_package_installed(hPkg))
{
break;
}
}
if(hPkg == NULL)
{
dwError = ERROR_TDNF_NO_SEARCH_RESULTS;
BAIL_ON_TDNF_ERROR(dwError);
}
dwError = TDNFPackageGetDowngrade(hPkgListGoalTemp, hPkg, &hPkgTemp);
if(dwError == ERROR_TDNF_NO_DOWNGRADES)
{
dwError = ERROR_TDNF_NO_SEARCH_RESULTS;
}
BAIL_ON_TDNF_ERROR(dwError);
hy_packagelist_push(hPkgListGoal, hPkgTemp);
}
}
else
{
dwError = TDNFAllocateMemory(
sizeof(TDNF_PKG_INFO),
(void**)&pSolvedPkgInfo->pPkgsNotAvailable);
BAIL_ON_TDNF_ERROR(dwError);
dwError = TDNFAllocateString(
pszPkgName,
&pSolvedPkgInfo->pPkgsNotAvailable->pszName);
//TODO: Shouldnt be here. Better error needed
dwError = ERROR_TDNF_INVALID_PARAMETER;
BAIL_ON_TDNF_ERROR(dwError);
}
*phPkgListGoal = hPkgListGoal;
cleanup:
if(hPkgTemp)
{
hy_package_free(hPkgTemp);
// hy_package_free(hPkgTemp);
}
if(hSelector)
if(hPkgListGoalTemp)
{
hy_selector_free(hSelector);
// hy_packagelist_free(hPkgListGoalTemp);
}
return dwError;
error:
if(dwError == ERROR_TDNF_NO_SEARCH_RESULTS)
{
dwError = 0;
if(TDNFAddNotResolved(pSolvedPkgInfo, pszPkgName))
{
fprintf(stderr, "Error while adding not resolved packages\n");
}
}
if(phPkgListGoal)
{
*phPkgListGoal = NULL;
}
if(hPkgListGoal)
{
hy_packagelist_free(hPkgListGoal);
}
TDNF_SAFE_FREE_PKGLIST(hPkgList);
return dwError;
error:
goto cleanup;
}

1
include/tdnferror.h
View File

@ -51,6 +51,7 @@ extern "C" {
#define ERROR_TDNF_GOAL_CREATE 1014
#define ERROR_TDNF_INVALID_RESOLVE_ARG 1015
#define ERROR_TDNF_CLEAN_UNSUPPORTED 1016
#define ERROR_TDNF_NO_DOWNGRADES 1017
//Config settings error
#define ERROR_TDNF_SET_PROXY 1020
#define ERROR_TDNF_SET_PROXY_USERPASS 1021

2
include/tdnftypes.h
View File

@ -51,6 +51,7 @@ typedef enum
{
ALTER_AUTOERASE,
ALTER_DOWNGRADE,
ALTER_DOWNGRADEALL,
ALTER_ERASE,
ALTER_INSTALL,
ALTER_REINSTALL,
@ -166,6 +167,7 @@ typedef struct _TDNF_SOLVED_PKG_INFO
PTDNF_PKG_INFO pPkgsUnNeeded;
PTDNF_PKG_INFO pPkgsToReinstall;
PTDNF_PKG_INFO pPkgsObsoleted;
char** ppszPkgsNotResolved;
}TDNF_SOLVED_PKG_INFO, *PTDNF_SOLVED_PKG_INFO;
typedef struct _TDNF_CMD_ARGS

43
tools/cli/installcmd.c
View File

@ -106,8 +106,14 @@ TDNFCliDowngradeCommand(
)
{
uint32_t dwError = 0;
int nAlterType = ALTER_DOWNGRADE;
if(pCmdArgs->nCmdCount == 1)
{
nAlterType = ALTER_DOWNGRADEALL;
}
dwError = TDNFCliAlterCommand(pTdnf, pCmdArgs, ALTER_DOWNGRADE);
dwError = TDNFCliAlterCommand(pTdnf, pCmdArgs, nAlterType);
BAIL_ON_CLI_ERROR(dwError);
cleanup:
@ -181,6 +187,12 @@ TDNFCliAlterCommand(
dwError = TDNFResolve(pTdnf, nAlterType, &pSolvedPkgInfo);
BAIL_ON_CLI_ERROR(dwError);
if(pSolvedPkgInfo->ppszPkgsNotResolved)
{
dwError = PrintNotAvailable(pSolvedPkgInfo->ppszPkgsNotResolved);
BAIL_ON_CLI_ERROR(dwError);
}
if(!pSolvedPkgInfo->nNeedAction)
{
dwError = ERROR_TDNF_CLI_NOTHING_TO_DO;
@ -270,6 +282,35 @@ error:
goto cleanup;
}
uint32_t
PrintNotAvailable(
char** ppszPkgsNotAvailable
)
{
uint32_t dwError = 0;
int i = 0;
#define BOLD "\033[1m\033[30m"
#define RESET "\033[0m"
if(!ppszPkgsNotAvailable)
{
dwError = ERROR_TDNF_INVALID_PARAMETER;
BAIL_ON_CLI_ERROR(dwError);
}
while(ppszPkgsNotAvailable[i])
{
printf(
"No package " BOLD "%s " RESET "available\n",
ppszPkgsNotAvailable[i]);
++i;
}
cleanup:
return dwError;
error:
goto cleanup;
}
uint32_t
PrintExistingPackagesSkipped(
PTDNF_PKG_INFO pPkgInfos

5
tools/cli/prototypes.h
View File

@ -165,6 +165,11 @@ TDNFCliHelpCommand(
);
//installcmd.c
uint32_t
PrintNotAvailable(
char** ppszPkgsNotAvailable
);
uint32_t
PrintExistingPackagesSkipped(
PTDNF_PKG_INFO pPkgInfos