← Back to branch summary

~thopiekar/zypper/libzypp-manual-import

« back to all changes in this revision

Viewing changes to zypp/repo/Applydeltarpm.cc

  • Committer: Thomas-Karl Pietrowski
  • Date: 2014-01-29 22:44:28 UTC
  • Revision ID: thopiekar@googlemail.com-20140129224428-gpcqnsdakby362n8
first import

Show diffs side-by-side

added added

removed removed

Lines of Context:
zypp/repo/Applydeltarpm.cc
 
1
/*---------------------------------------------------------------------\
 
2
|                          ____ _   __ __ ___                          |
 
3
|                         |__  / \ / / . \ . \                         |
 
4
|                           / / \ V /|  _/  _/                         |
 
5
|                          / /__ | | | | | |                           |
 
6
|                         /_____||_| |_| |_|                           |
 
7
|                                                                      |
 
8
\---------------------------------------------------------------------*/
 
9
/** \file       zypp/source/Applydeltarpm.cc
 
10
 *
 
11
*/
 
12
#include <iostream>
 
13
 
 
14
#include "zypp/base/Logger.h"
 
15
#include "zypp/base/String.h"
 
16
#include "zypp/base/Regex.h"
 
17
#include "zypp/repo/Applydeltarpm.h"
 
18
#include "zypp/ExternalProgram.h"
 
19
#include "zypp/AutoDispose.h"
 
20
#include "zypp/PathInfo.h"
 
21
#include "zypp/TriBool.h"
 
22
 
 
23
using std::endl;
 
24
 
 
25
///////////////////////////////////////////////////////////////////
 
26
namespace zypp
 
27
{ /////////////////////////////////////////////////////////////////
 
28
  ///////////////////////////////////////////////////////////////////
 
29
  namespace applydeltarpm
 
30
  { /////////////////////////////////////////////////////////////////
 
31
    ///////////////////////////////////////////////////////////////////
 
32
    namespace
 
33
    { /////////////////////////////////////////////////////////////////
 
34
 
 
35
      const Pathname   applydeltarpm_prog( "/usr/bin/applydeltarpm" );
 
36
      const str::regex applydeltarpm_tick ( "([0-9]+) percent finished" );
 
37
 
 
38
      /******************************************************************
 
39
       **
 
40
       **       FUNCTION NAME : applydeltarpm
 
41
       **       FUNCTION TYPE : bool
 
42
      */
 
43
      bool applydeltarpm( const char *const argv_r[],
 
44
                          const Progress & report_r  = Progress() )
 
45
      {
 
46
        ExternalProgram prog( argv_r, ExternalProgram::Stderr_To_Stdout );
 
47
        str::smatch what;
 
48
        for ( std::string line = prog.receiveLine(); ! line.empty(); line = prog.receiveLine() )
 
49
          {
 
50
            if ( report_r && str::regex_match( line, what, applydeltarpm_tick ) )
 
51
              {
 
52
                report_r( str::strtonum<unsigned>( what[1] ) );
 
53
              }
 
54
            else
 
55
              DBG << "Applydeltarpm : " << line;
 
56
        }
 
57
        return( prog.close() == 0 );
 
58
      }
 
59
 
 
60
      /////////////////////////////////////////////////////////////////
 
61
    } // namespace
 
62
    ///////////////////////////////////////////////////////////////////
 
63
 
 
64
    /******************************************************************
 
65
     **
 
66
     ** FUNCTION NAME : haveApplydeltarpm
 
67
     ** FUNCTION TYPE : bool
 
68
    */
 
69
    bool haveApplydeltarpm()
 
70
    {
 
71
      // To track changes in availability of applydeltarpm.
 
72
      static TriBool _last = indeterminate;
 
73
      PathInfo prog( applydeltarpm_prog );
 
74
      bool have = prog.isX();
 
75
      if ( _last == have )
 
76
        ; // TriBool! 'else' is not '_last != have'
 
77
      else
 
78
        {
 
79
          // _last is 'indeterminate' or '!have'
 
80
          if ( (_last = have) )
 
81
            MIL << "Found executable " << prog << endl;
 
82
          else
 
83
            WAR << "No executable " << prog << endl;
 
84
        }
 
85
      return _last;
 
86
    }
 
87
 
 
88
    /******************************************************************
 
89
     **
 
90
     ** FUNCTION NAME : check
 
91
     ** FUNCTION TYPE : bool
 
92
    */
 
93
    bool check( const std::string & sequenceinfo_r, bool quick_r )
 
94
    {
 
95
      if ( ! haveApplydeltarpm() )
 
96
        return false;
 
97
 
 
98
      const char *const argv[] = {
 
99
        "/usr/bin/applydeltarpm",
 
100
        ( quick_r ? "-C" : "-c" ),
 
101
        "-s", sequenceinfo_r.c_str(),
 
102
        NULL
 
103
      };
 
104
 
 
105
      return( applydeltarpm( argv ) );
 
106
    }
 
107
 
 
108
    /******************************************************************
 
109
     **
 
110
     ** FUNCTION NAME : check
 
111
     ** FUNCTION TYPE : bool
 
112
    */
 
113
    bool check( const Pathname & delta_r, bool quick_r )
 
114
    {
 
115
      if ( ! haveApplydeltarpm() )
 
116
        return false;
 
117
 
 
118
      const char *const argv[] = {
 
119
        "/usr/bin/applydeltarpm",
 
120
        ( quick_r ? "-C" : "-c" ),
 
121
        delta_r.asString().c_str(),
 
122
        NULL
 
123
      };
 
124
 
 
125
      return( applydeltarpm( argv ) );
 
126
    }
 
127
 
 
128
    /******************************************************************
 
129
     **
 
130
     ** FUNCTION NAME : provide
 
131
     ** FUNCTION TYPE : bool
 
132
    */
 
133
    bool provide( const Pathname & delta_r, const Pathname & new_r,
 
134
                  const Progress & report_r )
 
135
    {
 
136
      // cleanup on error
 
137
      AutoDispose<const Pathname> guard( new_r, filesystem::unlink );
 
138
 
 
139
      if ( ! haveApplydeltarpm() )
 
140
        return false;
 
141
 
 
142
      const char *const argv[] = {
 
143
        "/usr/bin/applydeltarpm",
 
144
        "-p", "-p", // twice to get percent output one per line
 
145
        delta_r.asString().c_str(),
 
146
        new_r.asString().c_str(),
 
147
        NULL
 
148
      };
 
149
 
 
150
      if ( ! applydeltarpm( argv, report_r ) )
 
151
        return false;
 
152
 
 
153
      guard.resetDispose(); // no cleanup on success
 
154
      return true;
 
155
    }
 
156
 
 
157
    /******************************************************************
 
158
     **
 
159
     ** FUNCTION NAME : provide
 
160
     ** FUNCTION TYPE : bool
 
161
    */
 
162
    bool provide( const Pathname & old_r, const Pathname & delta_r,
 
163
                  const Pathname & new_r,
 
164
                  const Progress & report_r )
 
165
    {
 
166
      // cleanup on error
 
167
      AutoDispose<const Pathname> guard( new_r, filesystem::unlink );
 
168
 
 
169
      if ( ! haveApplydeltarpm() )
 
170
        return false;
 
171
 
 
172
      const char *const argv[] = {
 
173
        "/usr/bin/applydeltarpm",
 
174
        "-p", "-p", // twice to get percent output one per line
 
175
        "-r", old_r.asString().c_str(),
 
176
        delta_r.asString().c_str(),
 
177
        new_r.asString().c_str(),
 
178
        NULL
 
179
      };
 
180
 
 
181
      if ( ! applydeltarpm( argv, report_r ) )
 
182
        return false;
 
183
 
 
184
      guard.resetDispose(); // no cleanup on success
 
185
      return true;
 
186
    }
 
187
 
 
188
    /////////////////////////////////////////////////////////////////
 
189
  } // namespace applydeltarpm
 
190
  ///////////////////////////////////////////////////////////////////
 
191
  /////////////////////////////////////////////////////////////////
 
192
} // namespace zypp
 
193
///////////////////////////////////////////////////////////////////