#include "zypp/base/IOStream.h"
#include "zypp/base/Functional.h"
#include "zypp/base/UserRequestException.h"
+#include "zypp/base/Json.h"
#include "zypp/ZConfig.h"
#include "zypp/ZYppFactory.h"
+#include "zypp/PathInfo.h"
#include "zypp/PoolItem.h"
#include "zypp/ResObjects.h"
#include "zypp/RepoStatus.h"
#include "zypp/ExternalProgram.h"
#include "zypp/Repository.h"
+#include "zypp/ShutdownLock_p.h"
#include "zypp/ResFilters.h"
#include "zypp/HistoryLog.h"
#include "zypp/target/TargetCallbackReceiver.h"
#include "zypp/target/rpm/librpmDb.h"
#include "zypp/target/CommitPackageCache.h"
+#include "zypp/target/RpmPostTransCollector.h"
#include "zypp/parser/ProductFileReader.h"
-
-#include "zypp/pool/GetResolvablesToInsDel.h"
-#include "zypp/solver/detail/Testcase.h"
-
-#include "zypp/repo/DeltaCandidates.h"
-#include "zypp/repo/PackageProvider.h"
#include "zypp/repo/SrcPackageProvider.h"
#include "zypp/sat/Pool.h"
+#include "zypp/sat/detail/PoolImpl.h"
+#include "zypp/sat/SolvableSpec.h"
#include "zypp/sat/Transaction.h"
-#include "zypp/PluginScript.h"
+#include "zypp/PluginExecutor.h"
using namespace std;
///////////////////////////////////////////////////////////////////
namespace zypp
-{ /////////////////////////////////////////////////////////////////
+{
+ /////////////////////////////////////////////////////////////////
+ namespace
+ {
+ // HACK for bnc#906096: let pool re-evaluate multiversion spec
+ // if target root changes. ZConfig returns data sensitive to
+ // current target root.
+ inline void sigMultiversionSpecChanged()
+ {
+ sat::detail::PoolMember::myPool().multiversionSpecChanged();
+ }
+ } //namespace
+ /////////////////////////////////////////////////////////////////
+
///////////////////////////////////////////////////////////////////
- namespace target
- { /////////////////////////////////////////////////////////////////
+ namespace json
+ {
+ // Lazy via template specialisation / should switch to overloading
- /** Helper for commit plugin execution.
- * \ingroup g_RAII
- */
- class CommitPlugins : private base::NonCopyable
+ template<>
+ inline std::string toJSON( const ZYppCommitResult::TransactionStepList & steps_r )
+ {
+ using sat::Transaction;
+ json::Array ret;
+
+ for ( const Transaction::Step & step : steps_r )
+ // ignore implicit deletes due to obsoletes and non-package actions
+ if ( step.stepType() != Transaction::TRANSACTION_IGNORE )
+ ret.add( step );
+
+ return ret.asJSON();
+ }
+
+ /** See \ref commitbegin on page \ref plugin-commit for the specs. */
+ template<>
+ inline std::string toJSON( const sat::Transaction::Step & step_r )
{
- public:
+ static const std::string strType( "type" );
+ static const std::string strStage( "stage" );
+ static const std::string strSolvable( "solvable" );
+
+ static const std::string strTypeDel( "-" );
+ static const std::string strTypeIns( "+" );
+ static const std::string strTypeMul( "M" );
- public:
- /** Default ctor: Empty plugin list */
- CommitPlugins()
- {}
+ static const std::string strStageDone( "ok" );
+ static const std::string strStageFailed( "err" );
+
+ static const std::string strSolvableN( "n" );
+ static const std::string strSolvableE( "e" );
+ static const std::string strSolvableV( "v" );
+ static const std::string strSolvableR( "r" );
+ static const std::string strSolvableA( "a" );
+
+ using sat::Transaction;
+ json::Object ret;
+
+ switch ( step_r.stepType() )
+ {
+ case Transaction::TRANSACTION_IGNORE: /*empty*/ break;
+ case Transaction::TRANSACTION_ERASE: ret.add( strType, strTypeDel ); break;
+ case Transaction::TRANSACTION_INSTALL: ret.add( strType, strTypeIns ); break;
+ case Transaction::TRANSACTION_MULTIINSTALL: ret.add( strType, strTypeMul ); break;
+ }
- /** Dtor: Send PLUGINEND message and close plugins. */
- ~CommitPlugins()
+ switch ( step_r.stepStage() )
+ {
+ case Transaction::STEP_TODO: /*empty*/ break;
+ case Transaction::STEP_DONE: ret.add( strStage, strStageDone ); break;
+ case Transaction::STEP_ERROR: ret.add( strStage, strStageFailed ); break;
+ }
+
+ {
+ IdString ident;
+ Edition ed;
+ Arch arch;
+ if ( sat::Solvable solv = step_r.satSolvable() )
{
- for_( it, _scripts.begin(), _scripts.end() )
- {
- MIL << "Unload plugin: " << *it << endl;
- try {
- it->send( PluginFrame( "PLUGINEND" ) );
- PluginFrame ret( it->receive() );
- if ( ! ret.isAckCommand() )
- {
- WAR << "Failed to unload plugin: Bad plugin response." << endl;
- }
- it->close();
- }
- catch( const zypp::Exception & )
- {
- WAR << "Failed to unload plugin." << endl;
- }
- }
- // _scripts dtor will disconnect all remaining plugins!
+ ident = solv.ident();
+ ed = solv.edition();
+ arch = solv.arch();
}
+ else
+ {
+ // deleted package; post mortem data stored in Transaction::Step
+ ident = step_r.ident();
+ ed = step_r.edition();
+ arch = step_r.arch();
+ }
+
+ json::Object s {
+ { strSolvableN, ident.asString() },
+ { strSolvableV, ed.version() },
+ { strSolvableR, ed.release() },
+ { strSolvableA, arch.asString() }
+ };
+ if ( Edition::epoch_t epoch = ed.epoch() )
+ s.add( strSolvableE, epoch );
- /** Find and launch plugins sending PLUGINSTART message.
- *
- * If \a path_r is a directory all executable files whithin are
- * expected to be plugins. Otherwise \a path_r must point to an
- * executable plugin.
- */
- void load( const Pathname & path_r )
+ ret.add( strSolvable, s );
+ }
+
+ return ret.asJSON();
+ }
+ } // namespace json
+ ///////////////////////////////////////////////////////////////////
+
+ ///////////////////////////////////////////////////////////////////
+ namespace target
+ {
+ ///////////////////////////////////////////////////////////////////
+ namespace
+ {
+ SolvIdentFile::Data getUserInstalledFromHistory( const Pathname & historyFile_r )
+ {
+ SolvIdentFile::Data onSystemByUserList;
+ // go and parse it: 'who' must constain an '@', then it was installed by user request.
+ // 2009-09-29 07:25:19|install|lirc-remotes|0.8.5-3.2|x86_64|root@opensuse|InstallationImage|a204211eb0...
+ std::ifstream infile( historyFile_r.c_str() );
+ for( iostr::EachLine in( infile ); in; in.next() )
{
- PathInfo pi( path_r );
- if ( pi.isDir() )
+ const char * ch( (*in).c_str() );
+ // start with year
+ if ( *ch < '1' || '9' < *ch )
+ continue;
+ const char * sep1 = ::strchr( ch, '|' ); // | after date
+ if ( !sep1 )
+ continue;
+ ++sep1;
+ // if logs an install or delete
+ bool installs = true;
+ if ( ::strncmp( sep1, "install|", 8 ) )
{
- std::list<Pathname> entries;
- if ( filesystem::readdir( entries, pi.path(), false ) != 0 )
- {
- WAR << "Plugin dir is not readable: " << pi << endl;
- return;
- }
- for_( it, entries.begin(), entries.end() )
- {
- PathInfo pii( *it );
- if ( pii.isFile() && pii.userMayRX() )
- doLoad( pii );
- }
+ if ( ::strncmp( sep1, "remove |", 8 ) )
+ continue; // no install and no remove
+ else
+ installs = false; // remove
}
- else if ( pi.isFile() )
+ sep1 += 8; // | after what
+ // get the package name
+ const char * sep2 = ::strchr( sep1, '|' ); // | after name
+ if ( !sep2 || sep1 == sep2 )
+ continue;
+ (*in)[sep2-ch] = '\0';
+ IdString pkg( sep1 );
+ // we're done, if a delete
+ if ( !installs )
{
- if ( pi.userMayRX() )
- doLoad( pi );
- else
- WAR << "Plugin file is not executable: " << pi << endl;
+ onSystemByUserList.erase( pkg );
+ continue;
}
- else
+ // now guess whether user installed or not (3rd next field contains 'user@host')
+ if ( (sep1 = ::strchr( sep2+1, '|' )) // | after version
+ && (sep1 = ::strchr( sep1+1, '|' )) // | after arch
+ && (sep2 = ::strchr( sep1+1, '|' )) ) // | after who
{
- WAR << "Plugin path is neither dir nor file: " << pi << endl;
- }
- }
-
- private:
- void doLoad( const PathInfo & pi_r )
- {
- MIL << "Load plugin: " << pi_r << endl;
- try {
- PluginScript plugin( pi_r.path() );
- plugin.open();
- plugin.send( PluginFrame( "PLUGINBEGIN" ) );
- PluginFrame ret( plugin.receive() );
- if ( ret.isAckCommand() )
- {
- _scripts.push_back( plugin );
- }
- else
+ (*in)[sep2-ch] = '\0';
+ if ( ::strchr( sep1+1, '@' ) )
{
- WAR << "Failed to load plugin: Bad plugin response." << endl;
+ // by user
+ onSystemByUserList.insert( pkg );
+ continue;
}
}
- catch( const zypp::Exception & )
- {
- WAR << "Failed to load plugin." << endl;
- }
}
+ MIL << "onSystemByUserList found: " << onSystemByUserList.size() << endl;
+ return onSystemByUserList;
+ }
+ } // namespace
+ ///////////////////////////////////////////////////////////////////
- private:
- std::list<PluginScript> _scripts;
- };
-
- void testCommitPlugins( const Pathname & path_r ) // for testing only
+ ///////////////////////////////////////////////////////////////////
+ namespace
{
- USR << "+++++" << endl;
+ inline PluginFrame transactionPluginFrame( const std::string & command_r, ZYppCommitResult::TransactionStepList & steps_r )
{
- CommitPlugins pl;
- pl.load( path_r );
- USR << "=====" << endl;
+ return PluginFrame( command_r, json::Object {
+ { "TransactionStepList", steps_r }
+ }.asJSON() );
}
- USR << "-----" << endl;
- }
-
+ } // namespace
///////////////////////////////////////////////////////////////////
/** \internal Manage writing a new testcase when doing an upgrade. */
// - "name-version-release"
// - "name-version-release-*"
bool abort = false;
+ std::map<std::string, Pathname> unify; // scripts <md5,path>
for_( it, checkPackages_r.begin(), checkPackages_r.end() )
{
std::string prefix( str::form( "%s-%s", it->name().c_str(), it->edition().c_str() ) );
continue; // if not exact match it had to continue with '-'
PathInfo script( scriptsDir / *sit );
- if ( ! script.isFile() )
- continue;
+ Pathname localPath( scriptsPath_r/(*sit) ); // without root prefix
+ std::string unifytag; // must not stay empty
+
+ if ( script.isFile() )
+ {
+ // Assert it's set executable, unify by md5sum.
+ filesystem::addmod( script.path(), 0500 );
+ unifytag = filesystem::md5sum( script.path() );
+ }
+ else if ( ! script.isExist() )
+ {
+ // Might be a dangling symlink, might be ok if we are in
+ // instsys (absolute symlink within the system below /mnt).
+ // readlink will tell....
+ unifytag = filesystem::readlink( script.path() ).asString();
+ }
- // Assert it's set executable
- filesystem::addmod( script.path(), 0500 );
+ if ( unifytag.empty() )
+ continue;
+
+ // Unify scripts
+ if ( unify[unifytag].empty() )
+ {
+ unify[unifytag] = localPath;
+ }
+ else
+ {
+ // translators: We may find the same script content in files with different names.
+ // Only the first occurence is executed, subsequent ones are skipped. It's a one-line
+ // message for a log file. Preferably start translation with "%s"
+ std::string msg( str::form(_("%s already executed as %s)"), localPath.asString().c_str(), unify[unifytag].c_str() ) );
+ MIL << "Skip update script: " << msg << endl;
+ HistoryLog().comment( msg, /*timestamp*/true );
+ continue;
+ }
- Pathname localPath( scriptsPath_r/(*sit) ); // without root prefix
if ( abort || aborting_r )
{
WAR << "Aborting: Skip update script " << *sit << endl;
ZYppCommitResult & result_r )
{ RunUpdateMessages( root_r, messagesPath_r, checkPackages_r, result_r ); }
- /** Helper for PackageProvider queries during commit. */
- struct QueryInstalledEditionHelper
- {
- bool operator()( const std::string & name_r,
- const Edition & ed_r,
- const Arch & arch_r ) const
- {
- rpm::librpmDb::db_const_iterator it;
- for ( it.findByName( name_r ); *it; ++it )
- {
- if ( arch_r == it->tag_arch()
- && ( ed_r == Edition::noedition || ed_r == it->tag_edition() ) )
- {
- return true;
- }
- }
- return false;
- }
- };
-
- /**
- * \short Let the Source provide the package.
- * \p pool_r \ref ResPool used to get candidates
- * \p pi item to be commited
- */
- struct RepoProvidePackage
- {
- ResPool _pool;
- repo::RepoMediaAccess &_access;
-
- RepoProvidePackage( repo::RepoMediaAccess &access, ResPool pool_r )
- : _pool(pool_r), _access(access)
- {}
-
- ManagedFile operator()( const PoolItem & pi )
- {
- // Redirect PackageProvider queries for installed editions
- // (in case of patch/delta rpm processing) to rpmDb.
- repo::PackageProviderPolicy packageProviderPolicy;
- packageProviderPolicy.queryInstalledCB( QueryInstalledEditionHelper() );
-
- Package::constPtr p = asKind<Package>(pi.resolvable());
-
- // Build a repository list for repos
- // contributing to the pool
- std::list<Repository> repos( _pool.knownRepositoriesBegin(), _pool.knownRepositoriesEnd() );
- repo::DeltaCandidates deltas(repos, p->name());
- repo::PackageProvider pkgProvider( _access, p, deltas, packageProviderPolicy );
-
- ManagedFile ret( pkgProvider.providePackage() );
- return ret;
- }
- };
///////////////////////////////////////////////////////////////////
IMPL_PTR_TYPE(TargetImpl);
- TargetImpl_Ptr TargetImpl::_nullimpl;
-
- /** Null implementation */
- TargetImpl_Ptr TargetImpl::nullimpl()
- {
- if (_nullimpl == 0)
- _nullimpl = new TargetImpl;
- return _nullimpl;
- }
-
///////////////////////////////////////////////////////////////////
//
// METHOD NAME : TargetImpl::TargetImpl
TargetImpl::TargetImpl( const Pathname & root_r, bool doRebuild_r )
: _root( root_r )
, _requestedLocalesFile( home() / "RequestedLocales" )
- , _softLocksFile( home() / "SoftLocks" )
+ , _autoInstalledFile( home() / "AutoInstalled" )
, _hardLocksFile( Pathname::assertprefix( _root, ZConfig::instance().locksFile() ) )
{
_rpm.initDatabase( root_r, Pathname(), doRebuild_r );
HistoryLog::setRoot(_root);
createAnonymousId();
-
+ sigMultiversionSpecChanged(); // HACK: see sigMultiversionSpecChanged
MIL << "Initialized target on " << _root << endl;
}
/**
* generates a random id using uuidgen
*/
- static string generateRandomId()
+ static std::string generateRandomId()
{
- string id;
- const char* argv[] =
- {
- "/usr/bin/uuidgen",
- NULL
- };
-
- ExternalProgram prog( argv,
- ExternalProgram::Normal_Stderr,
- false, -1, true);
- std::string line;
- for(line = prog.receiveLine();
- ! line.empty();
- line = prog.receiveLine() )
- {
- MIL << line << endl;
- id = line;
- break;
- }
- prog.close();
- return id;
+ std::ifstream uuidprovider( "/proc/sys/kernel/random/uuid" );
+ return iostr::getline( uuidprovider );
}
/**
void TargetImpl::createAnonymousId() const
{
+ // bsc#1024741: Omit creating a new uid for chrooted systems (if it already has one, fine)
+ if ( root() != "/" )
+ return;
- // create the anonymous unique id
- // this value is used for statistics
+ // Create the anonymous unique id, used for download statistics
Pathname idpath( home() / "AnonymousUniqueId");
try
TargetImpl::~TargetImpl()
{
_rpm.closeDatabase();
+ sigMultiversionSpecChanged(); // HACK: see sigMultiversionSpecChanged
MIL << "Targets closed" << endl;
}
filesystem::recursive_rmdir( base );
}
- void TargetImpl::buildCache()
+ bool TargetImpl::buildCache()
{
Pathname base = solvfilesPath();
Pathname rpmsolv = base/"solv";
bool build_rpm_solv = true;
// lets see if the rpm solv cache exists
- RepoStatus rpmstatus( RepoStatus( _root/"/var/lib/rpm/Name" )
- && (_root/"/etc/products.d") );
+ RepoStatus rpmstatus( RepoStatus(_root/"var/lib/rpm/Name") && RepoStatus(_root/"etc/products.d") );
bool solvexisted = PathInfo(rpmsolv).isExist();
if ( solvexisted )
{
RepoStatus status = RepoStatus::fromCookieFile(rpmsolvcookie);
// now compare it with the rpm database
- if ( status.checksum() == rpmstatus.checksum() )
- build_rpm_solv = false;
- MIL << "Read cookie: " << rpmsolvcookie << " says: "
- << (build_rpm_solv ? "outdated" : "uptodate") << endl;
+ if ( status == rpmstatus )
+ build_rpm_solv = false;
+ MIL << "Read cookie: " << rpmsolvcookie << " says: "
+ << (build_rpm_solv ? "outdated" : "uptodate") << endl;
}
}
// Take care we unlink the solvfile on exception
ManagedFile guard( base, filesystem::recursive_rmdir );
- std::ostringstream cmd;
- cmd << "rpmdb2solv";
- if ( ! _root.empty() )
- cmd << " -r '" << _root << "'";
-
- cmd << " -p '" << Pathname::assertprefix( _root, "/etc/products.d" ) << "'";
+ ExternalProgram::Arguments cmd;
+ cmd.push_back( "rpmdb2solv" );
+ if ( ! _root.empty() ) {
+ cmd.push_back( "-r" );
+ cmd.push_back( _root.asString() );
+ }
+ cmd.push_back( "-X" ); // autogenerate pattern/product/... from -package
+ // bsc#1104415: no more application support // cmd.push_back( "-A" ); // autogenerate application pseudo packages
+ cmd.push_back( "-p" );
+ cmd.push_back( Pathname::assertprefix( _root, "/etc/products.d" ).asString() );
if ( ! oldSolvFile.empty() )
- cmd << " '" << oldSolvFile << "'";
+ cmd.push_back( oldSolvFile.asString() );
- cmd << " > '" << tmpsolv.path() << "'";
+ cmd.push_back( "-o" );
+ cmd.push_back( tmpsolv.path().asString() );
- MIL << "Executing: " << cmd << endl;
- ExternalProgram prog( cmd.str(), ExternalProgram::Stderr_To_Stdout );
+ ExternalProgram prog( cmd, ExternalProgram::Stderr_To_Stdout );
+ std::string errdetail;
- cmd << endl;
for ( std::string output( prog.receiveLine() ); output.length(); output = prog.receiveLine() ) {
WAR << " " << output;
- cmd << " " << output;
+ if ( errdetail.empty() ) {
+ errdetail = prog.command();
+ errdetail += '\n';
+ }
+ errdetail += output;
}
int ret = prog.close();
if ( ret != 0 )
{
Exception ex(str::form("Failed to cache rpm database (%d).", ret));
- ex.remember( cmd.str() );
+ ex.remember( errdetail );
ZYPP_THROW(ex);
}
// We keep it.
guard.resetDispose();
+ sat::updateSolvFileIndex( rpmsolv ); // content digest for zypper bash completion
- // Finally send notification to plugins
- // NOTE: quick hack looking for spacewalk plugin only
+ // system-hook: Finally send notification to plugins
+ if ( root() == "/" )
{
- Pathname script( Pathname::assertprefix( _root, ZConfig::instance().pluginsPath()/"system/spacewalk" ) );
- if ( PathInfo( script ).isX() )
- try {
- PluginScript spacewalk( script );
- spacewalk.open();
-
- PluginFrame notify( "PACKAGESETCHANGED" );
- spacewalk.send( notify );
-
- PluginFrame ret( spacewalk.receive() );
- MIL << ret << endl;
- if ( ret.command() == "ERROR" )
- ret.writeTo( WAR ) << endl;
- }
- catch ( const Exception & excpt )
- {
- WAR << excpt.asUserHistory() << endl;
- }
+ PluginExecutor plugins;
+ plugins.load( ZConfig::instance().pluginsPath()/"system" );
+ if ( plugins )
+ plugins.send( PluginFrame( "PACKAGESETCHANGED" ) );
}
}
+ else
+ {
+ // On the fly add missing solv.idx files for bash completion.
+ if ( ! PathInfo(base/"solv.idx").isExist() )
+ sat::updateSolvFileIndex( rpmsolv );
+ }
+ return build_rpm_solv;
+ }
+
+ void TargetImpl::reload()
+ {
+ load( false );
}
void TargetImpl::unload()
system.eraseFromPool();
}
-
- void TargetImpl::load()
+ void TargetImpl::load( bool force )
{
- buildCache();
+ bool newCache = buildCache();
+ MIL << "New cache built: " << (newCache?"true":"false") <<
+ ", force loading: " << (force?"true":"false") << endl;
// now add the repos to the pool
sat::Pool satpool( sat::Pool::instance() );
// Providing an empty system repo, unload any old content
Repository system( sat::Pool::instance().findSystemRepo() );
+
if ( system && ! system.solvablesEmpty() )
{
- system.eraseFromPool(); // invalidates system
+ if ( newCache || force )
+ {
+ system.eraseFromPool(); // invalidates system
+ }
+ else
+ {
+ return; // nothing to do
+ }
}
+
if ( ! system )
{
system = satpool.systemRepo();
try
{
+ MIL << "adding " << rpmsolv << " to system" << endl;
system.addSolv( rpmsolv );
}
catch ( const Exception & exp )
system.addSolv( rpmsolv );
}
+ satpool.rootDir( _root );
// (Re)Load the requested locales et al.
// If the requested locales are empty, we leave the pool untouched
const LocaleSet & requestedLocales( _requestedLocalesFile.locales() );
if ( ! requestedLocales.empty() )
{
- satpool.setRequestedLocales( requestedLocales );
+ satpool.initRequestedLocales( requestedLocales );
}
}
{
- SoftLocksFile::Data softLocks( _softLocksFile.data() );
- if ( ! softLocks.empty() )
- {
- // Don't soft lock any installed item.
- for_( it, system.solvablesBegin(), system.solvablesEnd() )
- {
- softLocks.erase( it->ident() );
- }
- ResPool::instance().setAutoSoftLocks( softLocks );
- }
+ if ( ! PathInfo( _autoInstalledFile.file() ).isExist() )
+ {
+ // Initialize from history, if it does not exist
+ Pathname historyFile( Pathname::assertprefix( _root, ZConfig::instance().historyLogFile() ) );
+ if ( PathInfo( historyFile ).isExist() )
+ {
+ SolvIdentFile::Data onSystemByUser( getUserInstalledFromHistory( historyFile ) );
+ SolvIdentFile::Data onSystemByAuto;
+ for_( it, system.solvablesBegin(), system.solvablesEnd() )
+ {
+ IdString ident( (*it).ident() );
+ if ( onSystemByUser.find( ident ) == onSystemByUser.end() )
+ onSystemByAuto.insert( ident );
+ }
+ _autoInstalledFile.setData( onSystemByAuto );
+ }
+ // on the fly removed any obsolete SoftLocks file
+ filesystem::unlink( home() / "SoftLocks" );
+ }
+ // read from AutoInstalled file
+ sat::StringQueue q;
+ for ( const auto & idstr : _autoInstalledFile.data() )
+ q.push( idstr.id() );
+ satpool.setAutoInstalled( q );
}
+
+ // Load the needreboot package specs
+ {
+ sat::SolvableSpec needrebootSpec;
+
+ Pathname needrebootFile { Pathname::assertprefix( root(), ZConfig::instance().needrebootFile() ) };
+ if ( PathInfo( needrebootFile ).isFile() )
+ needrebootSpec.parseFrom( needrebootFile );
+
+ Pathname needrebootDir { Pathname::assertprefix( root(), ZConfig::instance().needrebootPath() ) };
+ if ( PathInfo( needrebootDir ).isDir() )
+ {
+ static const StrMatcher isRpmConfigBackup( "\\.rpm(new|save|orig)$", Match::REGEX );
+
+ filesystem::dirForEach( needrebootDir, filesystem::matchNoDots(),
+ [&]( const Pathname & dir_r, const char *const str_r )->bool
+ {
+ if ( ! isRpmConfigBackup( str_r ) )
+ {
+ Pathname needrebootFile { needrebootDir / str_r };
+ if ( PathInfo( needrebootFile ).isFile() )
+ needrebootSpec.parseFrom( needrebootFile );
+ }
+ return true;
+ });
+ }
+ satpool.setNeedrebootSpec( std::move(needrebootSpec) );
+ }
+
if ( ZConfig::instance().apply_locks_file() )
{
const HardLocksFile::Data & hardLocks( _hardLocksFile.data() );
{
// ----------------------------------------------------------------- //
ZYppCommitPolicy policy_r( policy_rX );
+ bool explicitDryRun = policy_r.dryRun(); // explicit dry run will trigger a fileconflict check, implicit (download-only) not.
+
+ ShutdownLock lck("Zypp commit running.");
// Fake outstanding YCP fix: Honour restriction to media 1
// at installation, but install all remaining packages if post-boot.
MIL << "TargetImpl::commit(<pool>, " << policy_r << ")" << endl;
///////////////////////////////////////////////////////////////////
+ // Compute transaction:
+ ///////////////////////////////////////////////////////////////////
+ ZYppCommitResult result( root() );
+ result.rTransaction() = pool_r.resolver().getTransaction();
+ result.rTransaction().order();
+ // steps: this is our todo-list
+ ZYppCommitResult::TransactionStepList & steps( result.rTransactionStepList() );
+ if ( policy_r.restrictToMedia() )
+ {
+ // Collect until the 1st package from an unwanted media occurs.
+ // Further collection could violate install order.
+ MIL << "Restrict to media number " << policy_r.restrictToMedia() << endl;
+ for_( it, result.transaction().begin(), result.transaction().end() )
+ {
+ if ( makeResObject( *it )->mediaNr() > 1 )
+ break;
+ steps.push_back( *it );
+ }
+ }
+ else
+ {
+ result.rTransactionStepList().insert( steps.end(), result.transaction().begin(), result.transaction().end() );
+ }
+ MIL << "Todo: " << result << endl;
+
+ ///////////////////////////////////////////////////////////////////
// Prepare execution of commit plugins:
///////////////////////////////////////////////////////////////////
- CommitPlugins commitPlugins;
+ PluginExecutor commitPlugins;
if ( root() == "/" && ! policy_r.dryRun() )
{
- Pathname plugindir( Pathname::assertprefix( _root, ZConfig::instance().pluginsPath()/"commit" ) );
- commitPlugins.load( plugindir );
+ commitPlugins.load( ZConfig::instance().pluginsPath()/"commit" );
}
+ if ( commitPlugins )
+ commitPlugins.send( transactionPluginFrame( "COMMITBEGIN", steps ) );
///////////////////////////////////////////////////////////////////
// Write out a testcase if we're in dist upgrade mode.
///////////////////////////////////////////////////////////////////
- if ( getZYpp()->resolver()->upgradeMode() )
+ if ( pool_r.resolver().upgradeMode() || pool_r.resolver().upgradingRepos() )
{
if ( ! policy_r.dryRun() )
{
}
}
- ///////////////////////////////////////////////////////////////////
+ ///////////////////////////////////////////////////////////////////
// Store non-package data:
///////////////////////////////////////////////////////////////////
if ( ! policy_r.dryRun() )
filesystem::assert_dir( home() );
// requested locales
_requestedLocalesFile.setLocales( pool_r.getRequestedLocales() );
- // weak locks
+ // autoinstalled
{
- SoftLocksFile::Data newdata;
- pool_r.getActiveSoftLocks( newdata );
- _softLocksFile.setData( newdata );
+ SolvIdentFile::Data newdata;
+ for ( sat::Queue::value_type id : result.rTransaction().autoInstalled() )
+ newdata.insert( IdString(id) );
+ _autoInstalledFile.setData( newdata );
}
// hard locks
if ( ZConfig::instance().apply_locks_file() )
}
///////////////////////////////////////////////////////////////////
- // Compute transaction:
- ///////////////////////////////////////////////////////////////////
- ZYppCommitResult result( root() );
- result.rTransaction() = pool_r.resolver().getTransaction();
- result.rTransaction().order();
- // steps: this is our todo-list
- ZYppCommitResult::TransactionStepList & steps( result.rTransactionStepList() );
- if ( policy_r.restrictToMedia() )
- {
- // Collect until the 1st package from an unwanted media occurs.
- // Further collection could violate install order.
- MIL << "Restrict to media number " << policy_r.restrictToMedia() << endl;
- for_( it, result.transaction().begin(), result.transaction().end() )
- {
- if ( makeResObject( *it )->mediaNr() > 1 )
- break;
- steps.push_back( *it );
- }
- }
- else
- {
- result.rTransactionStepList().insert( steps.end(), result.transaction().begin(), result.transaction().end() );
- }
- MIL << "Todo: " << result << endl;
-
- ///////////////////////////////////////////////////////////////////
// First collect and display all messages
// associated with patches to be installed.
///////////////////////////////////////////////////////////////////
if ( ! report->show( patch ) )
{
WAR << "commit aborted by the user" << endl;
- ZYPP_THROW( TargetAbortedException( N_("Installation has been aborted as directed.") ) );
+ ZYPP_THROW( TargetAbortedException( ) );
}
}
}
if ( ! policy_r.dryRun() || policy_r.downloadMode() == DownloadOnly )
{
// Prepare the package cache. Pass all items requiring download.
- repo::RepoMediaAccess access;
- RepoProvidePackage repoProvidePackage( access, pool_r );
- CommitPackageCache packageCache( root() / "tmp", repoProvidePackage );
+ CommitPackageCache packageCache;
packageCache.setCommitList( steps.begin(), steps.end() );
bool miss = false;
ManagedFile localfile;
try
{
- // TODO: unify packageCache.get for Package and SrcPackage
- if ( pi->isKind<Package>() )
- {
- localfile = packageCache.get( pi );
- }
- else if ( pi->isKind<SrcPackage>() )
- {
- repo::RepoMediaAccess access;
- repo::SrcPackageProvider prov( access );
- localfile = prov.provideSrcPackage( pi->asKind<SrcPackage>() );
- }
- else
- {
- INT << "Don't know howto cache: Neither Package nor SrcPackage: " << pi << endl;
- continue;
- }
+ localfile = packageCache.get( pi );
localfile.resetDispose(); // keep the package file in the cache
}
catch ( const AbortRequestException & exp )
{
+ it->stepStage( sat::Transaction::STEP_ERROR );
miss = true;
WAR << "commit cache preload aborted by the user" << endl;
- ZYPP_THROW( TargetAbortedException( N_("Installation has been aborted as directed.") ) );
+ ZYPP_THROW( TargetAbortedException( ) );
break;
}
catch ( const SkipRequestException & exp )
{
ZYPP_CAUGHT( exp );
+ it->stepStage( sat::Transaction::STEP_ERROR );
miss = true;
WAR << "Skipping cache preload package " << pi->asKind<Package>() << " in commit" << endl;
continue;
// bnc #395704: missing catch causes abort.
// TODO see if packageCache fails to handle errors correctly.
ZYPP_CAUGHT( exp );
+ it->stepStage( sat::Transaction::STEP_ERROR );
miss = true;
INT << "Unexpected Error: Skipping cache preload package " << pi->asKind<Package>() << " in commit" << endl;
continue;
}
}
}
+ packageCache.preloaded( true ); // try to avoid duplicate infoInCache CBs in commit
}
if ( miss )
{
ERR << "Some packages could not be provided. Aborting commit."<< endl;
}
- else if ( ! policy_r.dryRun() )
- {
- commit( policy_r, packageCache, result );
- }
else
- {
- DBG << "dryRun: Not installing/deleting anything." << endl;
- }
+ {
+ if ( ! policy_r.dryRun() )
+ {
+ // if cache is preloaded, check for file conflicts
+ commitFindFileConflicts( policy_r, result );
+ commit( policy_r, packageCache, result );
+ }
+ else
+ {
+ DBG << "dryRun/downloadOnly: Not installing/deleting anything." << endl;
+ if ( explicitDryRun ) {
+ // if cache is preloaded, check for file conflicts
+ commitFindFileConflicts( policy_r, result );
+ }
+ }
+ }
}
else
{
DBG << "dryRun: Not downloading/installing/deleting anything." << endl;
+ if ( explicitDryRun ) {
+ // if cache is preloaded, check for file conflicts
+ commitFindFileConflicts( policy_r, result );
+ }
}
///////////////////////////////////////////////////////////////////
- // Try to rebuild solv file while rpm database is still in cache
+ // Send result to commit plugins:
///////////////////////////////////////////////////////////////////
- if ( ! policy_r.dryRun() )
- {
- buildCache();
- }
+ if ( commitPlugins )
+ commitPlugins.send( transactionPluginFrame( "COMMITEND", steps ) );
- // for DEPRECATED old ZyppCommitResult results:
///////////////////////////////////////////////////////////////////
- // build return statistics
+ // Try to rebuild solv file while rpm database is still in cache
///////////////////////////////////////////////////////////////////
- result._errors.clear();
- result._remaining.clear();
- result._srcremaining.clear();
- unsigned toInstall = 0;
- for_( step, steps.begin(), steps.end() )
+ if ( ! policy_r.dryRun() )
{
- if ( step->stepType() == sat::Transaction::TRANSACTION_IGNORE )
- {
- // For non-packages only products might have beed installed.
- // All the rest is ignored.
- if ( step->satSolvable().isSystem() || ! step->satSolvable().isKind<Product>() )
- continue;
- }
- else if ( step->stepType() == sat::Transaction::TRANSACTION_ERASE )
- {
- continue;
- }
- // to be installed:
- ++toInstall;
- switch ( step->stepStage() )
- {
- case sat::Transaction::STEP_TODO:
- if ( step->satSolvable().isKind<Package>() )
- result._remaining.push_back( PoolItem( *step ) );
- else if ( step->satSolvable().isKind<SrcPackage>() )
- result._srcremaining.push_back( PoolItem( *step ) );
- break;
- case sat::Transaction::STEP_DONE:
- // NOOP
- break;
- case sat::Transaction::STEP_ERROR:
- result._errors.push_back( PoolItem( *step ) );
- break;
- }
+ buildCache();
}
- result._result = (toInstall - result._remaining.size());
- ///////////////////////////////////////////////////////////////////
MIL << "TargetImpl::commit(<pool>, " << policy_r << ") returns: " << result << endl;
return result;
// COMMIT internal
//
///////////////////////////////////////////////////////////////////
+ namespace
+ {
+ struct NotifyAttemptToModify
+ {
+ NotifyAttemptToModify( ZYppCommitResult & result_r ) : _result( result_r ) {}
+
+ void operator()()
+ { if ( _guard ) { _result.attemptToModify( true ); _guard = false; } }
+
+ TrueBool _guard;
+ ZYppCommitResult & _result;
+ };
+ } // namespace
+
void TargetImpl::commit( const ZYppCommitPolicy & policy_r,
CommitPackageCache & packageCache_r,
ZYppCommitResult & result_r )
ZYppCommitResult::TransactionStepList & steps( result_r.rTransactionStepList() );
MIL << "TargetImpl::commit(<list>" << policy_r << ")" << steps.size() << endl;
+ HistoryLog().stampCommand();
+
+ // Send notification once upon 1st call to rpm
+ NotifyAttemptToModify attemptToModify( result_r );
+
bool abort = false;
+
+ RpmPostTransCollector postTransCollector( _root );
std::vector<sat::Solvable> successfullyInstalledPackages;
TargetImpl::PoolItemList remaining;
if (policy_r.rpmExcludeDocs()) flags |= rpm::RPMINST_EXCLUDEDOCS;
if (policy_r.rpmNoSignature()) flags |= rpm::RPMINST_NOSIGNATURE;
+ attemptToModify();
try
{
progress.tryLevel( target::rpm::InstallResolvableReport::RPM_NODEPS_FORCE );
+ if ( postTransCollector.collectScriptFromPackage( localfile ) )
+ flags |= rpm::RPMINST_NOPOSTTRANS;
rpm().installPackage( localfile, flags );
HistoryLog().install(citem);
}
else
{
+ if ( citem.isNeedreboot() ) {
+ auto rebootNeededFile = root() / "/var/run/reboot-needed";
+ if ( filesystem::assert_file( rebootNeededFile ) == EEXIST)
+ filesystem::touch( rebootNeededFile );
+ }
+
success = true;
step->stepStage( sat::Transaction::STEP_DONE );
}
rpm::RpmInstFlags flags( policy_r.rpmInstFlags() & rpm::RPMINST_JUSTDB );
flags |= rpm::RPMINST_NODEPS;
if (policy_r.dryRun()) flags |= rpm::RPMINST_TEST;
+
+ attemptToModify();
try
{
rpm().removePackage( p, flags );
}
else
{
- PathInfo referenceFile( Pathname::assertprefix( _root, Pathname( "/etc/products.d" ) ) / referenceFilename );
- if ( ! referenceFile.isFile() || filesystem::unlink( referenceFile.path() ) != 0 )
- {
- ERR << "Delete orphan product failed: " << referenceFile << endl;
- }
+ Pathname referencePath { Pathname("/etc/products.d") / referenceFilename }; // no root prefix for rpmdb lookup!
+ if ( ! rpm().hasFile( referencePath.asString() ) )
+ {
+ // If it's not owned by a package, we can delete it.
+ referencePath = Pathname::assertprefix( _root, referencePath ); // now add a root prefix
+ if ( filesystem::unlink( referencePath ) != 0 )
+ ERR << "Delete orphan product failed: " << referencePath << endl;
+ }
+ else
+ {
+ WAR << "Won't remove orphan product: '/etc/products.d/" << referenceFilename << "' is owned by a package." << endl;
+ }
}
}
}
} // for
+ // process all remembered posttrans scripts. If aborting,
+ // at least log omitted scripts.
+ if ( abort || (abort = !postTransCollector.executeScripts()) )
+ postTransCollector.discardScripts();
+
// Check presence of update scripts/messages. If aborting,
// at least log omitted scripts.
if ( ! successfullyInstalledPackages.empty() )
if ( abort )
{
- ZYPP_THROW( TargetAbortedException( N_("Installation has been aborted as directed.") ) );
+ ZYPP_THROW( TargetAbortedException( ) );
}
}
}
///////////////////////////////////////////////////////////////////
-
- Product::constPtr TargetImpl::baseProduct() const
- {
- ResPool pool(ResPool::instance());
- for_( it, pool.byKindBegin<Product>(), pool.byKindEnd<Product>() )
- {
- Product::constPtr p = (*it)->asKind<Product>();
- if ( p->isTargetDistribution() )
- return p;
- }
- return 0L;
- }
-
- ///////////////////////////////////////////////////////////////////
-
namespace
{
parser::ProductFileData baseproductdata( const Pathname & root_r )
{
+ parser::ProductFileData ret;
PathInfo baseproduct( Pathname::assertprefix( root_r, "/etc/products.d/baseproduct" ) );
+
if ( baseproduct.isFile() )
{
try
{
- return parser::ProductFileReader::scanFile( baseproduct.path() );
+ ret = parser::ProductFileReader::scanFile( baseproduct.path() );
}
catch ( const Exception & excpt )
{
ZYPP_CAUGHT( excpt );
}
}
- return parser::ProductFileData();
+ else if ( PathInfo( Pathname::assertprefix( root_r, "/etc/products.d" ) ).isDir() )
+ {
+ ERR << "baseproduct symlink is dangling or missing: " << baseproduct << endl;
+ }
+ return ret;
}
inline Pathname staticGuessRoot( const Pathname & root_r )
}
return std::string();
}
+ } // namespace
+ ///////////////////////////////////////////////////////////////////
+
+ Product::constPtr TargetImpl::baseProduct() const
+ {
+ ResPool pool(ResPool::instance());
+ for_( it, pool.byKindBegin<Product>(), pool.byKindEnd<Product>() )
+ {
+ Product::constPtr p = (*it)->asKind<Product>();
+ if ( p->isTargetDistribution() )
+ return p;
+ }
+ return nullptr;
+ }
+
+ LocaleSet TargetImpl::requestedLocales( const Pathname & root_r )
+ {
+ const Pathname needroot( staticGuessRoot(root_r) );
+ const Target_constPtr target( getZYpp()->getTarget() );
+ if ( target && target->root() == needroot )
+ return target->requestedLocales();
+ return RequestedLocalesFile( home(needroot) / "RequestedLocales" ).locales();
+ }
+
+ void TargetImpl::updateAutoInstalled()
+ {
+ MIL << "updateAutoInstalled if changed..." << endl;
+ SolvIdentFile::Data newdata;
+ for ( auto id : sat::Pool::instance().autoInstalled() )
+ newdata.insert( IdString(id) ); // explicit ctor!
+ _autoInstalledFile.setData( std::move(newdata) );
}
std::string TargetImpl::targetDistribution() const
std::string TargetImpl::targetDistributionRelease( const Pathname & root_r )
{ return baseproductdata( staticGuessRoot(root_r) ).registerRelease();}
+ std::string TargetImpl::targetDistributionFlavor() const
+ { return baseproductdata( _root ).registerFlavor(); }
+ // static version:
+ std::string TargetImpl::targetDistributionFlavor( const Pathname & root_r )
+ { return baseproductdata( staticGuessRoot(root_r) ).registerFlavor();}
+
Target::DistributionLabel TargetImpl::distributionLabel() const
{
Target::DistributionLabel ret;
{
// ...But the baseproduct method is not expected to work on RedHat derivatives.
// On RHEL, Fedora and others the "product version" is determined by the first package
- // providing 'redhat-release'. This value is not hardcoded in YUM and can be configured
+ // providing 'system-release'. This value is not hardcoded in YUM and can be configured
// with the $distroverpkg variable.
scoped_ptr<rpm::RpmDb> tmprpmdb;
if ( ZConfig::instance().systemRoot() == Pathname() )
}
///////////////////////////////////////////////////////////////////
+ namespace
+ {
+ std::string guessAnonymousUniqueId( const Pathname & root_r )
+ {
+ // bsc#1024741: Omit creating a new uid for chrooted systems (if it already has one, fine)
+ std::string ret( firstNonEmptyLineIn( root_r / "/var/lib/zypp/AnonymousUniqueId" ) );
+ if ( ret.empty() && root_r != "/" )
+ {
+ // if it has nonoe, use the outer systems one
+ ret = firstNonEmptyLineIn( "/var/lib/zypp/AnonymousUniqueId" );
+ }
+ return ret;
+ }
+ }
std::string TargetImpl::anonymousUniqueId() const
{
- return firstNonEmptyLineIn( home() / "AnonymousUniqueId" );
+ return guessAnonymousUniqueId( root() );
}
// static version:
std::string TargetImpl::anonymousUniqueId( const Pathname & root_r )
{
- return firstNonEmptyLineIn( staticGuessRoot(root_r) / "/var/lib/zypp/AnonymousUniqueId" );
+ return guessAnonymousUniqueId( staticGuessRoot(root_r) );
}
///////////////////////////////////////////////////////////////////
void TargetImpl::installSrcPackage( const SrcPackage_constPtr & srcPackage_r )
{
// provide on local disk
- repo::RepoMediaAccess access_r;
- repo::SrcPackageProvider prov( access_r );
- ManagedFile localfile = prov.provideSrcPackage( srcPackage_r );
+ ManagedFile localfile = provideSrcPackage(srcPackage_r);
+ // create a installation progress report proxy
+ RpmInstallPackageReceiver progress( srcPackage_r );
+ progress.connect(); // disconnected on destruction.
// install it
rpm().installPackage ( localfile );
}
- /////////////////////////////////////////////////////////////////
+ ManagedFile TargetImpl::provideSrcPackage( const SrcPackage_constPtr & srcPackage_r )
+ {
+ // provide on local disk
+ repo::RepoMediaAccess access_r;
+ repo::SrcPackageProvider prov( access_r );
+ return prov.provideSrcPackage( srcPackage_r );
+ }
+ ////////////////////////////////////////////////////////////////
} // namespace target
///////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////
projects / platform / upstream / libzypp.git / blobdiff