#include <sstream>
#include <streambuf>
-#define ZYPP_USE_RESOLVER_INTERNALS
-
#include "zypp/solver/detail/Testcase.h"
#include "zypp/base/Logger.h"
#include "zypp/base/LogControl.h"
#include "zypp/target/modalias/Modalias.h"
#include "zypp/sat/detail/PoolImpl.h"
-#include "zypp/solver/detail/Resolver.h"
#include "zypp/solver/detail/SystemCheck.h"
/////////////////////////////////////////////////////////////////////////
return str.str();
}
-inline string helixXML( const PoolItem & obj, Dep deptag_r )
+inline string helixXML( const Resolvable::constPtr &obj, Dep deptag_r )
{
stringstream out;
- Capabilities caps( obj[deptag_r] );
+ Capabilities caps( obj->dep(deptag_r) );
if ( ! caps.empty() )
out << TAB << xml_tag_enclose(helixXML(caps), deptag_r.asString()) << endl;
return out.str();
}
-std::string helixXML( const PoolItem & item )
+std::string helixXML( const PoolItem &item )
{
+ const Resolvable::constPtr resolvable = item.resolvable();
stringstream str;
- str << "<" << item.kind() << ">" << endl;
- str << TAB << xml_tag_enclose( item.name(), "name", true ) << endl;
- str << TAB << xml_tag_enclose( item.vendor().asString(), "vendor", true ) << endl;
- str << TAB << xml_tag_enclose( item.buildtime().asSeconds(), "buildtime", true ) << endl;
- if ( isKind<Package>( item ) ) {
+ str << "<" << toLower (resolvable->kind().asString()) << ">" << endl;
+ str << TAB << xml_tag_enclose (resolvable->name(), "name", true) << endl;
+ str << TAB << xml_tag_enclose (item->vendor(), "vendor", true) << endl;
+ str << TAB << xml_tag_enclose (item->buildtime().asSeconds(), "buildtime", true) << endl;
+ if ( isKind<Package>(resolvable) ) {
str << TAB << "<history>" << endl << TAB << "<update>" << endl;
- str << TAB2 << helixXML( item.arch() ) << endl;
- str << TAB2 << helixXML( item.edition() ) << endl;
+ str << TAB2 << helixXML (resolvable->arch()) << endl;
+ str << TAB2 << helixXML (resolvable->edition()) << endl;
str << TAB << "</update>" << endl << TAB << "</history>" << endl;
} else {
- str << TAB << helixXML( item.arch() ) << endl;
- str << TAB << helixXML( item.edition() ) << endl;
+ str << TAB << helixXML (resolvable->arch()) << endl;
+ str << TAB << helixXML (resolvable->edition()) << endl;
}
- str << helixXML( item, Dep::PROVIDES );
- str << helixXML( item, Dep::PREREQUIRES );
- str << helixXML( item, Dep::CONFLICTS );
- str << helixXML( item, Dep::OBSOLETES );
- str << helixXML( item, Dep::REQUIRES );
- str << helixXML( item, Dep::RECOMMENDS );
- str << helixXML( item, Dep::ENHANCES );
- str << helixXML( item, Dep::SUPPLEMENTS );
- str << helixXML( item, Dep::SUGGESTS );
-
- str << "</" << item.kind() << ">" << endl;
+ str << helixXML( resolvable, Dep::PROVIDES);
+ str << helixXML( resolvable, Dep::PREREQUIRES);
+ str << helixXML( resolvable, Dep::CONFLICTS);
+ str << helixXML( resolvable, Dep::OBSOLETES);
+ str << helixXML( resolvable, Dep::REQUIRES);
+ str << helixXML( resolvable, Dep::RECOMMENDS);
+ str << helixXML( resolvable, Dep::ENHANCES);
+ str << helixXML( resolvable, Dep::SUPPLEMENTS);
+ str << helixXML( resolvable, Dep::SUGGESTS);
+
+ str << "</" << toLower (resolvable->kind().asString()) << ">" << endl;
return str.str();
}
HelixControl (const std::string & controlPath,
const RepositoryTable & sourceTable,
const Arch & systemArchitecture,
+ const LocaleSet &languages,
const target::Modalias::ModaliasList & modaliasList,
const std::set<std::string> & multiversionSpec,
const std::string & systemPath,
HelixControl ();
~HelixControl ();
- void installResolvable( const PoolItem & pi_r );
- void lockResolvable( const PoolItem & pi_r );
- void keepResolvable( const PoolItem & pi_r );
- void deleteResolvable( const PoolItem & pi_r );
+ void installResolvable (const ResObject::constPtr &resObject,
+ const ResStatus &status);
+ void lockResolvable (const ResObject::constPtr &resObject,
+ const ResStatus &status);
+ void keepResolvable (const ResObject::constPtr &resObject,
+ const ResStatus &status);
+ void deleteResolvable (const ResObject::constPtr &resObject,
+ const ResStatus &status);
void addDependencies (const CapabilitySet &capRequire, const CapabilitySet &capConflict);
void addUpgradeRepos( const std::set<Repository> & upgradeRepos_r );
HelixControl::HelixControl(const std::string & controlPath,
const RepositoryTable & repoTable,
const Arch & systemArchitecture,
+ const LocaleSet &languages,
const target::Modalias::ModaliasList & modaliasList,
const std::set<std::string> & multiversionSpec,
const std::string & systemPath,
<< "\" />" << endl << endl;
}
- // HACK: directly access sat::pool
- const sat::Pool & satpool( sat::Pool::instance() );
-
- // RequestedLocales
- const LocaleSet & addedLocales( satpool.getAddedRequestedLocales() );
- const LocaleSet & removedLocales( satpool.getRemovedRequestedLocales() );
- const LocaleSet & requestedLocales( satpool.getRequestedLocales() );
-
- for ( Locale l : requestedLocales )
- {
- const char * fate = ( addedLocales.count(l) ? "\" fate=\"added" : "" );
- *file << TAB << "<locale name=\"" << l << fate << "\" />" << endl;
- }
- for ( Locale l : removedLocales )
- {
- *file << TAB << "<locale name=\"" << l << "\" fate=\"removed\" />" << endl;
- }
-
- // AutoInstalled
- for ( IdString::IdType n : satpool.autoInstalled() )
- {
- *file << TAB << "<autoinst name=\"" << IdString(n) << "\" />" << endl;
+ for (LocaleSet::const_iterator iter = languages.begin(); iter != languages.end(); iter++) {
+ *file << TAB << "<locale name=\"" << iter->code()
+ << "\" />" << endl;
}
-
-
for_( it, modaliasList.begin(), modaliasList.end() ) {
*file << TAB << "<modalias name=\"" << *it
<< "\" />" << endl;
delete(file);
}
-void HelixControl::installResolvable( const PoolItem & pi_r )
+void HelixControl::installResolvable(const ResObject::constPtr &resObject,
+ const ResStatus &status)
{
- *file << "<install channel=\"" << pi_r.repoInfo().alias() << "\""
- << " kind=\"" << pi_r.kind() << "\""
- << " name=\"" << pi_r.name() << "\""
- << " arch=\"" << pi_r.arch() << "\""
- << " version=\"" << pi_r.edition().version() << "\""
- << " release=\"" << pi_r.edition().release() << "\""
- << " status=\"" << pi_r.status() << "\""
+ *file << "<install channel=\"" << resObject->repoInfo().alias() << "\" kind=\"" << toLower (resObject->kind().asString()) << "\""
+ << " name=\"" << resObject->name() << "\"" << " arch=\"" << resObject->arch().asString() << "\""
+ << " version=\"" << resObject->edition().version() << "\"" << " release=\"" << resObject->edition().release() << "\""
+ << " status=\"" << status << "\""
<< "/>" << endl;
}
-void HelixControl::lockResolvable( const PoolItem & pi_r )
+void HelixControl::lockResolvable(const ResObject::constPtr &resObject,
+ const ResStatus &status)
{
- *file << "<lock channel=\"" << pi_r.repoInfo().alias() << "\""
- << " kind=\"" << pi_r.kind() << "\""
- << " name=\"" << pi_r.name() << "\""
- << " arch=\"" << pi_r.arch() << "\""
- << " version=\"" << pi_r.edition().version() << "\""
- << " release=\"" << pi_r.edition().release() << "\""
- << " status=\"" << pi_r.status() << "\""
+ *file << "<lock channel=\"" << resObject->repoInfo().alias() << "\" kind=\"" << toLower (resObject->kind().asString()) << "\""
+ << " name=\"" << resObject->name() << "\"" << " arch=\"" << resObject->arch().asString() << "\""
+ << " version=\"" << resObject->edition().version() << "\"" << " release=\"" << resObject->edition().release() << "\""
+ << " status=\"" << status << "\""
<< "/>" << endl;
}
-void HelixControl::keepResolvable( const PoolItem & pi_r )
+void HelixControl::keepResolvable(const ResObject::constPtr &resObject,
+ const ResStatus &status)
{
- *file << "<keep channel=\"" << pi_r.repoInfo().alias() << "\""
- << " kind=\"" << pi_r.kind() << "\""
- << " name=\"" << pi_r.name() << "\""
- << " arch=\"" << pi_r.arch() << "\""
- << " version=\"" << pi_r.edition().version() << "\""
- << " release=\"" << pi_r.edition().release() << "\""
- << " status=\"" << pi_r.status() << "\""
+ *file << "<keep channel=\"" << resObject->repoInfo().alias() << "\" kind=\"" << toLower (resObject->kind().asString()) << "\""
+ << " name=\"" << resObject->name() << "\"" << " arch=\"" << resObject->arch().asString() << "\""
+ << " version=\"" << resObject->edition().version() << "\"" << " release=\"" << resObject->edition().release() << "\""
+ << " status=\"" << status << "\""
<< "/>" << endl;
}
-void HelixControl::deleteResolvable( const PoolItem & pi_r )
+void HelixControl::deleteResolvable(const ResObject::constPtr &resObject,
+ const ResStatus &status)
{
- *file << "<uninstall kind=\"" << pi_r.kind() << "\""
- << " name=\"" << pi_r.name() << "\""
- << " status=\"" << pi_r.status() << "\""
+ *file << "<uninstall " << " kind=\"" << toLower (resObject->kind().asString()) << "\""
+ << " name=\"" << resObject->name() << "\""
+ << " status=\"" << status << "\""
<< "/>" << endl;
}
if (dumpPool)
system = new HelixResolvable(dumpPath + "/solver-system.xml.gz");
- for ( const PoolItem & pi : pool )
+ for ( ResPool::const_iterator it = pool.begin(); it != pool.end(); ++it )
{
- if ( system && pi.status().isInstalled() ) {
+ Resolvable::constPtr res = it->resolvable();
+
+ if ( system && it->status().isInstalled() ) {
// system channel
- system->addResolvable( pi );
+ system->addResolvable (*it);
} else {
// repo channels
- Repository repo = pi.repository();
+ Repository repo = it->resolvable()->satSolvable().repository();
if (dumpPool) {
if (repoTable.find (repo) == repoTable.end()) {
repoTable[repo] = new HelixResolvable(dumpPath + "/"
+ str::numstring((long)repo.id())
+ "-package.xml.gz");
}
- repoTable[repo]->addResolvable( pi );
+ repoTable[repo]->addResolvable (*it);
}
}
- if ( pi.status().isToBeInstalled()
- && !(pi.status().isBySolver())) {
- items_to_install.push_back( pi );
+ if ( it->status().isToBeInstalled()
+ && !(it->status().isBySolver())) {
+ items_to_install.push_back (*it);
}
- if ( pi.status().isKept()
- && !(pi.status().isBySolver())) {
- items_keep.push_back( pi );
+ if ( it->status().isKept()
+ && !(it->status().isBySolver())) {
+ items_keep.push_back (*it);
}
- if ( pi.status().isToBeUninstalled()
- && !(pi.status().isBySolver())) {
- items_to_remove.push_back( pi );
+ if ( it->status().isToBeUninstalled()
+ && !(it->status().isBySolver())) {
+ items_to_remove.push_back (*it);
}
- if ( pi.status().isLocked()
- && !(pi.status().isBySolver())) {
- items_locked.push_back( pi );
+ if ( it->status().isLocked()
+ && !(it->status().isBySolver())) {
+ items_locked.push_back (*it);
}
}
HelixControl control (dumpPath + "/solver-test.xml",
repoTable,
ZConfig::instance().systemArchitecture(),
+ pool.getRequestedLocales(),
target::Modalias::instance().modaliasList(),
ZConfig::instance().multiversionSpec(),
"solver-system.xml.gz",
resolver.onlyRequires(),
resolver.ignoreAlreadyRecommended() );
- for ( const PoolItem & pi : items_to_install )
- { control.installResolvable( pi ); }
+ for (PoolItemList::const_iterator iter = items_to_install.begin(); iter != items_to_install.end(); iter++) {
+ control.installResolvable (iter->resolvable(), iter->status());
+ }
- for ( const PoolItem & pi : items_locked )
- { control.lockResolvable( pi ); }
+ for (PoolItemList::const_iterator iter = items_locked.begin(); iter != items_locked.end(); iter++) {
+ control.lockResolvable (iter->resolvable(), iter->status());
+ }
- for ( const PoolItem & pi : items_keep )
- { control.keepResolvable( pi ); }
+ for (PoolItemList::const_iterator iter = items_keep.begin(); iter != items_keep.end(); iter++) {
+ control.keepResolvable (iter->resolvable(), iter->status());
+ }
- for ( const PoolItem & pi : items_to_remove )
- { control.deleteResolvable( pi ); }
+ for (PoolItemList::const_iterator iter = items_to_remove.begin(); iter != items_to_remove.end(); iter++) {
+ control.deleteResolvable (iter->resolvable(), iter->status());
+ }
control.addDependencies (resolver.extraRequires(), resolver.extraConflicts());
control.addDependencies (SystemCheck::instance().requiredSystemCap(),