Imported Upstream version 17.11.0

diff --git a/VERSION.cmake b/VERSION.cmake
index c229567..0c908e7 100644 (file)
--- a/VERSION.cmake
+++ b/VERSION.cmake
@@ -60,9 +60,9 @@
 #
 SET(LIBZYPP_MAJOR "17")
 SET(LIBZYPP_COMPATMINOR "9")
-SET(LIBZYPP_MINOR "10")
-SET(LIBZYPP_PATCH "3")
+SET(LIBZYPP_MINOR "11")
+SET(LIBZYPP_PATCH "0")
 #
-# LAST RELEASED: 17.10.3 (9)
+# LAST RELEASED: 17.11.0 (9)
 # (The number in parenthesis is LIBZYPP_COMPATMINOR)
 #=======

diff --git a/package/libzypp.changes b/package/libzypp.changes
index 08af145..d71969c 100644 (file)
--- a/package/libzypp.changes
+++ b/package/libzypp.changes
@@ -1,4 +1,12 @@
 -------------------------------------------------------------------
+Fri Jan 11 10:24:33 CET 2019 - ma@suse.de
+
+- PoolItemBest: Optionally prefer not locked packages (for bsc#1113296)
+- ui::Selectable: add `hasLocks` to indicate a partially locked
+  item (for bsc#1113296)
+- version 17.11.0 (9)
+
+-------------------------------------------------------------------
 Tue Dec 18 14:01:19 CET 2018 - ma@suse.de
 
 - Simplify complex locks so zypper can display them (bsc#1112911)

diff --git a/zypp/PoolItemBest.cc b/zypp/PoolItemBest.cc
index d6e4062..4049f64 100644 (file)
--- a/zypp/PoolItemBest.cc
+++ b/zypp/PoolItemBest.cc
@@ -28,7 +28,12 @@ namespace zypp
   /** PoolItemBest implementation. */
   struct PoolItemBest::Impl
   {
+    Impl( bool preferNotLocked_r )
+    : _preferNotLocked { preferNotLocked_r }
+    {}
+
     Container _container;
+    bool _preferNotLocked;
 
     private:
       friend Impl * rwcowClone<Impl>( const Impl * rhs );
@@ -44,8 +49,11 @@ namespace zypp
   //
   ///////////////////////////////////////////////////////////////////
 
+  void PoolItemBest::_ctor_init( bool preferNotLocked_r )
+  { _dont_use_this_use_pimpl.reset( new RWCOW_pointer<Impl>(new Impl( preferNotLocked_r )) ); }
+
   void PoolItemBest::_ctor_init()
-  { _dont_use_this_use_pimpl.reset( new RWCOW_pointer<Impl>(new Impl) ); }
+  { _ctor_init( /*preferNotLocked*/false ); }
 
   const PoolItemBest::Container & PoolItemBest::container() const
   { return pimpl()->_container; }
@@ -53,8 +61,24 @@ namespace zypp
   void PoolItemBest::add( const PoolItem & pi_r )
   {
     Container & container( pimpl()->_container );
+
     PoolItem & ccand( container[pi_r.satSolvable().ident()] );
-    if ( ! ccand || ui::SelectableTraits::AVOrder()( pi_r, ccand ) )
+    if ( ! ccand )
+      ccand = pi_r;
+    else if ( pimpl()->_preferNotLocked )
+    {
+      if ( ! pi_r.status().isLocked() )
+      {
+       if ( ccand.status().isLocked() || ui::SelectableTraits::AVOrder()( pi_r, ccand ) )
+         ccand = pi_r;
+      }
+      else if ( ccand.status().isLocked() )
+      {
+       if ( ui::SelectableTraits::AVOrder()( pi_r, ccand ) )
+         ccand = pi_r;
+      }
+    }
+    else if ( ui::SelectableTraits::AVOrder()( pi_r, ccand ) )
       ccand = pi_r;
   }
 

diff --git a/zypp/PoolItemBest.h b/zypp/PoolItemBest.h
index cf448da..b4ebc6b 100644 (file)
--- a/zypp/PoolItemBest.h
+++ b/zypp/PoolItemBest.h
@@ -39,6 +39,9 @@ namespace zypp
    * sorts the \ref ui::Selectable list of available objects, thus follows the
    * same rules the \ref resolver will apply.
    *
+   * Ctor argument \ref preferNotLocked causes locked packages to be considered
+   * less than not locked packages.
+   *
    * \code
    *   PoolQuery q;
    *   q.addAttribute(sat::SolvAttr::name, "lib*");
@@ -70,22 +73,26 @@ namespace zypp
       typedef MapKVIteratorTraits<Container>::Key_const_iterator       ident_iterator;
 
     public:
+      /** Indicator argument for ctor: consider locked packages less than not locked packages. */
+      static constexpr bool preferNotLocked = true;
+
+    public:
       /** Default ctor. */
-      PoolItemBest()
-      { _ctor_init(); }
+      PoolItemBest( bool preferNotLocked_r = false )
+      { _ctor_init( preferNotLocked_r ); }
 
       /** Ctor feeding a \ref sat::Solvable. */
-      PoolItemBest( sat::Solvable slv_r )
-      { _ctor_init(); add( slv_r ); }
+      PoolItemBest( sat::Solvable slv_r, bool preferNotLocked_r = false )
+      { _ctor_init( preferNotLocked_r ); add( slv_r ); }
 
       /** Ctor feeding a \ref PoolItem. */
-      PoolItemBest( const PoolItem & pi_r )
-      { _ctor_init(); add( pi_r ); }
+      PoolItemBest( const PoolItem & pi_r, bool preferNotLocked_r = false )
+      { _ctor_init( preferNotLocked_r ); add( pi_r ); }
 
       /** Ctor feeding a range of  \ref sat::Solvable or \ref PoolItem. */
       template<class TIterator>
-      PoolItemBest( TIterator begin_r, TIterator end_r )
-      { _ctor_init(); add( begin_r, end_r ); }
+      PoolItemBest( TIterator begin_r, TIterator end_r, bool preferNotLocked_r = false )
+      { _ctor_init( preferNotLocked_r ); add( begin_r, end_r ); }
 
     public:
       /** Feed one \ref sat::Solvable. */
@@ -132,7 +139,8 @@ namespace zypp
       //@}
 
     private:
-      void _ctor_init();
+      void _ctor_init( bool preferNotLocked_r );
+      void _ctor_init(/*preferNotLocked = false*/);    ///< bin.compat legacy
       const Container & container() const;
     private:
       /** Implementation  */

diff --git a/zypp/sat/detail/PoolImpl.cc b/zypp/sat/detail/PoolImpl.cc
index 38ec751..00224df 100644 (file)
--- a/zypp/sat/detail/PoolImpl.cc
+++ b/zypp/sat/detail/PoolImpl.cc
@@ -108,6 +108,10 @@ namespace zypp
       static void logSat( CPool *, void *data, int type, const char *logString )
       {
        //                            "1234567890123456789012345678901234567890
+       if ( 0 == strncmp( logString, "job: user installed", 19 ) )
+         return;
+       if ( 0 == strncmp( logString, "job: multiversion", 17 ) )
+         return;
        if ( 0 == strncmp( logString, "  - no rule created", 19 ) )
          return;
        if ( 0 == strncmp( logString, "    next rules: 0 0", 19 ) )

diff --git a/zypp/solver/detail/SATResolver.cc b/zypp/solver/detail/SATResolver.cc
index 260dd0c..fd13ceb 100644 (file)
--- a/zypp/solver/detail/SATResolver.cc
+++ b/zypp/solver/detail/SATResolver.cc
@@ -1397,18 +1397,22 @@ void SATResolver::applySolutions( const ProblemSolutionList & solutions )
 
 void SATResolver::setLocks()
 {
+    unsigned icnt = 0;
+    unsigned acnt = 0;
+
     for (PoolItemList::const_iterator iter = _items_to_lock.begin(); iter != _items_to_lock.end(); ++iter) {
         sat::detail::SolvableIdType ident( (*iter)->satSolvable().id() );
        if (iter->status().isInstalled()) {
-           MIL << "Lock installed item " << *iter << endl;
+           ++icnt;
            queue_push( &(_jobQueue), SOLVER_INSTALL | SOLVER_SOLVABLE );
            queue_push( &(_jobQueue), ident );
        } else {
-           MIL << "Lock NOT installed item " << *iter << endl;
+           ++acnt;
            queue_push( &(_jobQueue), SOLVER_ERASE | SOLVER_SOLVABLE | MAYBE_CLEANDEPS );
            queue_push( &(_jobQueue), ident );
        }
     }
+    MIL << "Locked " << icnt << " installed items and " << acnt << " NOT installed items." << endl;
 
     ///////////////////////////////////////////////////////////////////
     // Weak locks: Ignore if an item with this name is already installed.

diff --git a/zypp/ui/Selectable.cc b/zypp/ui/Selectable.cc
index 1d41383..46c0942 100644 (file)
--- a/zypp/ui/Selectable.cc
+++ b/zypp/ui/Selectable.cc
@@ -223,6 +223,8 @@ namespace zypp
     void Selectable::setLicenceConfirmed( bool val_r )
     { _pimpl->setLicenceConfirmed( val_r ); }
 
+    bool Selectable::hasLocks() const
+    { return  _pimpl->hasLocks(); }
 
     Selectable::Fate Selectable::fate() const
     {

diff --git a/zypp/ui/Selectable.h b/zypp/ui/Selectable.h
index abb6a90..e13e564 100644 (file)
--- a/zypp/ui/Selectable.h
+++ b/zypp/ui/Selectable.h
@@ -437,10 +437,22 @@ namespace zypp
       bool unmodified() const
       { return fate() == UNMODIFIED; }
 
-      /** True if locked (subclass of unmodified). */
+      /** True if locked (subclass of unmodified).
+       * The \ref locked status indicates that \b all installed and/or \b all available
+       * items are locked. So you can't remove and/or can't install any item. This
+       * is the common case.
+       * \see \ref hasLocks
+       */
       bool locked() const
       { Status st( status() ); return( st == S_Protected || st == S_Taboo ); }
 
+      /** True if it includes locked items (don't mix this with the \ref locked status).
+       * This is also \c true for partially locked items, where only specific versions
+       * are locked.
+       * \see \ref locked
+       */
+      bool hasLocks() const;
+
       /** True if either to delete or to install */
       bool toModify() const
       { return fate() != UNMODIFIED; }

diff --git a/zypp/ui/SelectableImpl.h b/zypp/ui/SelectableImpl.h
index 902358b..29b3e91 100644 (file)
--- a/zypp/ui/SelectableImpl.h
+++ b/zypp/ui/SelectableImpl.h
@@ -353,6 +353,22 @@ namespace zypp
       void setLicenceConfirmed( bool val_r )
       { if ( candidateObj() ) candidateObj().status().setLicenceConfirmed( val_r ); }
 
+      /** \copydoc Selectable::hasLocks()const */
+      bool hasLocks() const
+      {
+       for ( const PoolItem & pi : available() )
+       {
+         if ( pi.status().isLocked() )
+           return true;
+       }
+        for ( const PoolItem & pi : installed() )
+       {
+         if ( pi.status().isLocked() )
+           return true;
+       }
+       return false;
+      }
+
     private:
       PoolItem transactingInstalled() const
       {