Hello community, here is the log from the commit of package webyast-software-ws for openSUSE:Factory checked in at Wed May 4 10:49:27 CEST 2011. -------- --- webyast-software-ws/webyast-software-ws.changes 2011-02-09 10:19:23.000000000 +0100 +++ /mounts/work_src_done/STABLE/webyast-software-ws/webyast-software-ws.changes 2011-05-03 11:01:41.000000000 +0200 @@ -1,0 +2,24 @@ +Tue May 3 09:01:34 UTC 2011 - schubi@novell.com + +- adapted deleting cache key +- 0.3.5 + +------------------------------------------------------------------- +Mon May 2 12:43:38 UTC 2011 - schubi@novell.com + +- adapt caching to the new job handling +- 0.3.4 + +------------------------------------------------------------------- +Tue Apr 12 13:29:12 UTC 2011 - schubi@novell.com + +- new caching +- 0.3.3 + +------------------------------------------------------------------- +Fri Feb 11 09:42:29 UTC 2011 - jreidinger@novell.com + +- fix installing patches which require EULA confirmation + (bnc#669470) + +------------------------------------------------------------------- calling whatdependson for head-i586 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ webyast-software-ws.spec ++++++ --- /var/tmp/diff_new_pack.1Mx9xm/_old 2011-05-04 10:46:53.000000000 +0200 +++ /var/tmp/diff_new_pack.1Mx9xm/_new 2011-05-04 10:46:53.000000000 +0200 @@ -48,7 +48,7 @@ Group: Productivity/Networking/Web/Utilities Url: http://en.opensuse.org/Portal:WebYaST AutoReqProv: on -Version: 0.3.2 +Version: 0.3.5 Release: 1 Summary: WebYaST - software management service Source: www.tar.bz2 @@ -128,7 +128,7 @@ %endif %endif -mkdir -p $RPM_BUILD_ROOT/var/lib/yastws/software +mkdir -p $RPM_BUILD_ROOT/var/lib/yastws/software/licenses/accepted %clean rm -rf $RPM_BUILD_ROOT @@ -143,6 +143,7 @@ # grant the permission for the webservice user polkit-auth --user %{webyast_ws_user} --grant org.freedesktop.packagekit.system-sources-configure >& /dev/null || true polkit-auth --user %{webyast_ws_user} --grant org.freedesktop.packagekit.system-update >& /dev/null || true +polkit-auth --user %{webyast_ws_user} --grant org.freedesktop.packagekit.package-eula-accept >& /dev/null || true %files %defattr(-,root,root) @@ -159,7 +160,6 @@ %{plugin_dir}/uninstall.rb %{plugin_dir}/app %{plugin_dir}/lib -%{plugin_dir}/scripts %{plugin_dir}/config %attr(644,root,root) %config /usr/share/PolicyKit/policy/org.opensuse.yast.system.patches.policy %attr(644,root,root) %config /usr/share/PolicyKit/policy/org.opensuse.yast.system.packages.policy ++++++ www.tar.bz2 ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/www/app/controllers/packages_controller.rb new/www/app/controllers/packages_controller.rb --- old/www/app/controllers/packages_controller.rb 2010-08-27 14:58:55.000000000 +0200 +++ new/www/app/controllers/packages_controller.rb 2011-04-11 12:49:05.000000000 +0200 @@ -25,13 +25,8 @@ before_filter :login_required - # always check permissions and cache expiration - # even if the result is already created and cached + # always check permissions before_filter :check_read_permissions, :only => {:index, :show} - before_filter :check_cache_status, :only => :index - - # cache 'index' method result - caches_action :index private @@ -39,24 +34,6 @@ permission_check "org.opensuse.yast.system.patches.read" end - # check whether the cached result is still valid - def check_cache_status - cache_timestamp = Rails.cache.read('patches:timestamp') - - if cache_timestamp.nil? - # this is the first run, the cache is not initialized yet, just return - Rails.cache.write('patches:timestamp', Time.now) - return - # the cache expires after 5 minutes, repository metadata - # or RPM database update invalidates the cache immeditely - # (new patches might be applicable) - elsif cache_timestamp < 5.minutes.ago || cache_timestamp < Patch.mtime - logger.debug "#### Patch cache expired" - expire_action :action => :index, :format => params["format"] - Rails.cache.write('patches:timestamp', Time.now) - end - end - def compare_lists(packages) vendor_packages = Array.new #TODO: replace by real yml file @@ -73,8 +50,8 @@ public - # GET /patch_updates - # GET /patch_updates.xml + # GET /packages + # GET /packages.xml def index # note: permission check was performed in :before_filter @packages = Package.find(:installed) @@ -87,13 +64,13 @@ end end - # GET /patch_updates/1 - # GET /patch_updates/1.xml + # GET /packages/1 + # GET /packages/1.xml def show end - # PUT /patch_updates/1 - # PUT /patch_updates/1.xml + # PUT /packages/1 + # PUT /packages/1.xml def update end diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/www/app/controllers/patch_update/state_controller.rb new/www/app/controllers/patch_update/state_controller.rb --- old/www/app/controllers/patch_update/state_controller.rb 2010-09-17 16:25:41.000000000 +0200 +++ new/www/app/controllers/patch_update/state_controller.rb 2011-05-02 16:34:56.000000000 +0200 @@ -33,7 +33,7 @@ logger.warn "Confirmation of reading patch messages" File.delete Patch::MESSAGES_FILE - + YastCache.delete(Plugin.new(),"patch") respond_to do |format| format.xml { head :ok } format.json { head :ok } diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/www/app/controllers/patches_controller.rb new/www/app/controllers/patches_controller.rb --- old/www/app/controllers/patches_controller.rb 2011-02-01 10:49:25.000000000 +0100 +++ new/www/app/controllers/patches_controller.rb 2011-04-20 12:44:33.000000000 +0200 @@ -25,15 +25,8 @@ before_filter :login_required - # always check permissions and cache expiration - # even if the result is already created and cached + # always check permissions before_filter :check_read_permissions, :only => [:index, :show] - before_filter :check_cache_status, :only => :index - - # cache 'index' method result, but don't cache message requests - # (caching messages would complicate the cache invalidation code - # and it's fast anyway so it is actually not important) - caches_action :index, :unless => Proc.new { |ctrl| ctrl.params['messages'] } private @@ -41,72 +34,38 @@ permission_check "org.opensuse.yast.system.patches.read" # RORSCAN_ITL end - # check whether the cached result is still valid - def check_cache_status - #cache contain string as it is only object supported by all caching backends - cache_timestamp = Rails.cache.read('patches:timestamp').to_i - - if cache_timestamp.nil? - # this is the first run, the cache is not initialized yet, just return - Rails.cache.write('patches:timestamp', Time.now.to_i.to_s) - # the cache expires after 5 minutes, repository metadata - # or RPM database update invalidates the cache immediately - # (new patches might be applicable) - elsif cache_timestamp < 15.minutes.ago.to_i || cache_timestamp < Patch.mtime.to_i - logger.debug "#### Patch cache expired" - expire_action :action => :index, :format => params["format"] - Rails.cache.write('patches:timestamp', Time.now.to_i.to_s) - end - end - def collect_done_patches done = [] + installed = Rails.cache.fetch("patch:installed") || [] + installed.each { |patch_id| + # e.g.: 'suse-build-key;1.0-907.30;noarch;@System' + attrs = patch_id.split(';') + done << Patch.new(:resolvable_id => attrs[1], + :name => attrs[0], + :arch => attrs[2], + :repo => attrs[3], + :installed => true) + } + return done + end - BackgroundManager.instance.done.each do |k,v| - if k.match(/^packagekit_install_(.*)/) - patch_id = $1 - if BackgroundManager.instance.process_finished? k - Rails.logger.debug "Patch installation request #{patch_id} is done" - ret = BackgroundManager.instance.get_value k - - # check for exception - if ret.is_a? StandardError - raise ret - end - - # e.g.: 'suse-build-key;1.0-907.30;noarch;@System' - attrs = patch_id.split(';') - - done << Patch.new(:resolvable_id => attrs[1], - :name => attrs[0], - :arch => attrs[2], - :repo => attrs[3], - :installed => true) - end - end + def check_license_required + if PatchesState.read[:message_id] == "PATCH_EULA" + raise LicenseRequiredException.new end - - return done end - def check_running_install + def check_running_install running = 0 - max_progress = nil - status = nil - BackgroundManager.instance.running.each do |k,v| - if k.match(/^packagekit_install_(.*)/) - patch_id = $1 - tmp = BackgroundManager.instance.get_progress k - if max_progress.nil? || tmp.progress > max_progress - max_progress = tmp.progress - status = tmp - end - logger.info "installation in progress. Patch #{k}" - running += 1 - end - end - raise InstallInProgressException.new running,status if running > 0 #there is process which runs installation - end + jobs = Delayed::Job.find(:all) + jobs.each { |job| + running += 1 if job.handler.split("\n")[1].split[1].include?("patch:install:") + } unless jobs.blank? + Rails.logger.info("#{running} installation jobs in the queue") + Rails.cache.delete("patch:installed") if running == 0 #remove installed patches from cache if the installation + #has been finished + raise InstallInProgressException.new running if running > 0 #there is process which runs installation + end def read_messages if File.exists?(Patch::MESSAGES_FILE) @@ -132,23 +91,22 @@ end return end - check_running_install + if params[:license].present? + respond_to do |format| + format.xml { render :xml => Patch.license.to_xml( :root => "licenses", :dasherize => false ) } + format.json { render :json => Patch.license.to_json( :root => "licenses", :dasherize => false ) } + end + return + end + check_license_required + check_running_install # note: permission check was performed in :before_filter - bgr = params['background'] - Rails.logger.info "Reading patches in background" if bgr - - @patches = Patch.find(:available, {:background => bgr}) + @patches = Patch.find(:all) @patches = @patches + collect_done_patches #report also which patches is installed respond_to do |format| format.xml { render :xml => @patches.to_xml( :root => "patches", :dasherize => false ) } format.json { render :json => @patches.to_json( :root => "patches", :dasherize => false ) } end - - # do not cache the background progress status - # (expire the cache in the next request) - if bgr && @patches.first.class == BackgroundStatus - Rails.cache.write('patches:timestamp', Time.at(0)) - end end # GET /patch_updates/1 @@ -179,8 +137,13 @@ # POST /patch_updates/ def create permission_check "org.opensuse.yast.system.patches.install" # RORSCAN_ITL - @patch_update = Patch.find(params[:patches][:resolvable_id].to_s) + if params[:patches][:accept_license].present? || params[:patches][:reject_license].present? + params[:patches][:accept_license].present? ? Patch.accept_license : Patch.reject_license + index + return + end + @patch_update = Patch.find(params[:patches][:resolvable_id].to_s) #Patch for Bug 560701 - [build 24.1] webYaST appears to crash after installing webclient patch #Packagekit returns empty string if the patch is allready installed. if @patch_update.is_a?(Array) && @patch_update.empty? @@ -194,8 +157,7 @@ end res = @patch_update.install(true) #always install in backend otherwise there is problem with long running updates - Rails.cache.write('patches:timestamp', Time.at(0)) #invalidate cache - index + render :show end diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/www/app/controllers/repositories_controller.rb new/www/app/controllers/repositories_controller.rb --- old/www/app/controllers/repositories_controller.rb 2011-02-01 10:49:25.000000000 +0100 +++ new/www/app/controllers/repositories_controller.rb 2011-04-27 15:12:09.000000000 +0200 @@ -22,31 +22,10 @@ class RepositoriesController < ApplicationController before_filter :login_required - - # cache index and show action - before_filter :check_cache_status, :only => [:index] before_filter :check_read_permissions, :only => [:index] - caches_action :index - - CACHE_ID = 'repositories:timestamp' private - # check whether the cached result is still valid - def check_cache_status - cache_timestamp = Rails.cache.read(CACHE_ID) - - if cache_timestamp.nil? - # this is the first run, the cache is not initialized yet, just return - Rails.cache.write(CACHE_ID, Time.now) - # the cache expires when /etc/zypp/repos.d is modified - elsif cache_timestamp < Repository.mtime - Rails.logger.debug "#### Repositories cache expired" - expire_action :action => :index, :format => params["format"] - Rails.cache.write(CACHE_ID, Time.now) - end - end - def check_read_permissions permission_check "org.opensuse.yast.system.repositories.read" # RORSCAN_ITL end @@ -154,4 +133,4 @@ render :show end -end \ No newline at end of file +end diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/www/app/models/package.rb new/www/app/models/package.rb --- old/www/app/models/package.rb 2011-02-01 10:49:25.000000000 +0100 +++ new/www/app/models/package.rb 2011-05-02 09:49:37.000000000 +0200 @@ -28,20 +28,23 @@ end def self.find(what) + what = :installed if what == :all #default search for cache if what == :installed - package_list = Array.new - self.execute("GetPackages", what.to_s, "Package") { |line1,line2,line3| # RORSCAN_ITL - columns = line2.split ";" - package = Package.new(:resolvable_id => line2, - :name => columns[0], - :version => columns[1] - ) - # :arch => columns[2], - # :repo => columns[3], - # :summary => line3 ) - package_list << package - } - package_list + YastCache.fetch(self,what) { + package_list = Array.new + PackageKit.transact("GetPackages", what.to_s, "Package") { |line1,line2,line3| # RORSCAN_ITL + columns = line2.split ";" + package = Package.new(:resolvable_id => line2, + :name => columns[0], + :version => columns[1] + ) + # :arch => columns[2], + # :repo => columns[3], + # :summary => line3 ) + package_list << package + } + package_list + } end end end diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/www/app/models/patch.rb new/www/app/models/patch.rb --- old/www/app/models/patch.rb 2011-02-01 10:49:25.000000000 +0100 +++ new/www/app/models/patch.rb 2011-04-29 18:23:25.000000000 +0200 @@ -27,370 +27,227 @@ attr_accessor :messages MESSAGES_FILE = File.join(Paths::VAR,"software","patch_installion_messages") + LICENSES_DIR = File.join(Paths::VAR,"software","licenses") + ACCEPTED_LICENSES_DIR = File.join(Paths::VAR,"software","licenses","accepted") + JOB_PRIO = -30 private - # just a short cut for accessing the singleton object - def self.bm - BackgroundManager.instance + def self.decide_license(accept) + #we don't know eula id, but as it block package kit, then there is only one license file to decide + if accept + `find #{LICENSES_DIR} -type f -exec mv {} #{ACCEPTED_LICENSES_DIR} \\;` + else + `find #{LICENSES_DIR} -type f -delete` + end end - # create unique id for the background manager - def self.id(what) - "patches_#{what}" + public + + def self.accept_license + decide_license true end - public + def self.reject_license + decide_license false + end def to_xml( options = {} ) super :patch_update, options, @messages end # install - def install(background=false) - @messages=[] + def install(background = false) + # background process doesn't work correctly if class reloading is active + # (static class members are lost between requests) + # So the job queue is also not active + if background && !YastCache.job_queue_enabled? + Rails.logger.info "Job queue is not active. Disable background mode" + background = false + end update_id = "#{self.name};#{self.resolvable_id};#{self.arch};#{self.repo}" Rails.logger.error "Install Update: #{update_id}" - Patch.install(update_id, background, ['RequireRestart','Message']) { |type, details| - Rails.logger.info "Message signal received: #{type}, #{details}" - @messages << {:kind => type, :details => details} - begin - dirname = File.dirname(MESSAGES_FILE) - FileUtils.mkdir_p(dirname) unless File.directory?(dirname) - f = File.new(MESSAGES_FILE, 'a+') - f.puts '<br/>' unless File.size(MESSAGES_FILE).zero? - # TODO: make the message traslatable - f.puts "#{details}" - rescue Exception => e - Rails.logger.error "writing #{MESSAGES_FILE} file failed: #{e.try(:message)}" - ensure - f.try(:close) - end - } + unless background + Patch.install(update_id) #install at once + else + #inserting job in background + Rails.logger.info("Inserting job #{key}") + PluginJob.run_async(JOB_PRIO, :Patch, :install, update_id ) + Delayed::Job.enqueue(PluginJob.new(key),JOB_PRIO) + end end # find patches using PackageKit - def self.do_find(what, bg_status = nil) + def self.do_find(what) + bg_status = nil #not needed due caching patch_updates = Array.new - PackageKit.transact("GetUpdates", "none", "Package", bg_status) { |line1,line2,line3| - columns = line2.split ";" - if what == :available || columns[1] == what - update = Patch.new(:resolvable_id => columns[1], - :kind => line1, - :name => columns[0], - :arch => columns[2], - :repo => columns[3], - :summary => line3 ) - - if what == :available - # add the update to the list - patch_updates << update - else - # just return this single update - patch_updates = update - end - end - } - return patch_updates - end - - def self.subprocess_find(what) - # open subprocess - subproc = open_subprocess :find, what - - result = nil - - while !eof_subprocess?(subproc) do - begin - line = read_subprocess subproc - - unless line.blank? - received = Hash.from_xml(line) - - # is it a progress or the final list? - if received.has_key? 'patches' - Rails.logger.debug "Found #{received['patches'].size} patches" - # create Patch objects - result = received['patches'].map{|patch| Patch.new(patch.symbolize_keys) } - elsif received.has_key? 'background_status' - s = received['background_status'] - - bm.update_progress id(what) do |bs| - bs.status = s['status'] - bs.progress = s['progress'] - bs.subprogress = s['subprogress'] - end - elsif received.has_key? 'error' - return PackageKitError.new(received['error']['description']) + PackageKit.lock #locking + begin + PackageKit.transact("GetUpdates", "none", "Package", bg_status) { |line1,line2,line3| + columns = line2.split ";" + if what == :available || columns[1] == what + update = Patch.new(:resolvable_id => columns[1], + :kind => line1, + :name => columns[0], + :arch => columns[2], + :repo => columns[3], + :summary => line3 ) + + if what == :available + # add the update to the list + patch_updates << update else - Rails.logger.warn "*** Patch thread: Received unknown input: #{line}" + # just return this single update + patch_updates = update end end - rescue Exception => e - Rails.logger.error "Background thread: Could not evaluate output: #{line.chomp}, exception: #{e}" # RORSCAN_ITL - Rails.logger.error "Background thread: Backtrace: #{e.backtrace.join("\n")}" - - # rethrow the exception - raise e - end + } + ensure + #unlocking PackageKit + PackageKit.unlock end - - result + return patch_updates end # find patches # Patch.find(:available) - # Patch.find(:available, :background => true) - read patches in background - # the result may the current state (progress) or the actual patch list - # call this function in a loop until a patch list (or an error) is received # Patch.find(212) def self.find(what, opts = {}) - background = opts[:background] - - # background reading doesn't work correctly if class reloading is active - # (static class members are lost between requests) - if background && !bm.background_enabled? - Rails.logger.info "Class reloading is active, cannot use background thread (set config.cache_classes = true)" - background = false - end - - if background - proc_id = id(what) - if bm.process_finished? proc_id - Rails.logger.debug "Request #{proc_id} is done" - ret = bm.get_value proc_id - - # check for exception - if ret.is_a? StandardError - raise ret - end - - return ret - end - - running = bm.get_progress proc_id - if running - Rails.logger.debug "Request #{proc_id} is already running: #{running.inspect}" - return [running] - end - - - bm.add_process proc_id - - Rails.logger.info "Starting background thread for reading patches..." - # run the patch query in a separate thread - Thread.new do - res = subprocess_find what - - # check for exception - unless res.is_a? StandardError - Rails.logger.info "*** Patches thread: Found #{res.size} applicable patches" - else - Rails.logger.debug "*** Exception raised: #{res.inspect}" - end - bm.finish_process(proc_id, res) - end - - return [ bm.get_progress(proc_id) ] - else - return do_find(what) - end + search_id = what == :all ? :available : what + YastCache.fetch(self, what) { + do_find(search_id) + } end # install an update, based on the PackageKit # id ("<name>;<id>;<arch>;<repo>") - # signal: signal to intercept (usually "Package") (optional) - # block: block to run on signal (optional) # - def self.install(pk_id, background = false, signal_list = nil, &block) - Rails.logger.debug "Installing #{pk_id}, background: #{background.inspect}" - - # background process doesn't work correctly if class reloading is active - # (static class members are lost between requests) - bm = BackgroundManager.instance - if background && !bm.background_enabled? - Rails.logger.info "Class reloading is active, cannot use background thread (set config.cache_classes = true)" - background = false - end - Rails.logger.debug "Background: #{background.inspect}" - - if background - proc_id = bgid(pk_id) - - running = bm.get_progress proc_id - if running - Rails.logger.debug "Request #{proc_id} is already running: #{running.inspect}" - return running + def self.install(pk_id) + Rails.logger.debug "Installing #{pk_id}" + @messages=[] + ret = do_install(pk_id,['RequireRestart','Message']) { |type, details| + Rails.logger.info "Message signal received: #{type}, #{details}" + @messages << {:kind => type, :details => details} + begin + dirname = File.dirname(MESSAGES_FILE) + FileUtils.mkdir_p(dirname) unless File.directory?(dirname) + f = File.new(MESSAGES_FILE, 'a+') + f.puts '<br/>' unless File.size(MESSAGES_FILE).zero? + # TODO: make the message traslatable + f.puts "#{details}" + rescue Exception => e + Rails.logger.error "writing #{MESSAGES_FILE} file failed: #{e.try(:message)}" + ensure + f.try(:close) end + } + #save installed patches in cache + i = Rails.cache.fetch("patch:installed") || [] + installed = i.dup #cache is frozen + installed << pk_id + Rails.cache.write("patch:installed", installed) + + YastCache.delete(self,pk_id.split(';')[1]) + return ret + end - bm.add_process proc_id - - Rails.logger.info "Starting background thread for installing patches..." - # run the patch query in a separate thread - Thread.new do - @@package_kit_mutex ||= Mutex.new #TODO move to packagekit lib - @@package_kit_mutex.synchronize do - res = subprocess_install pk_id - - # check for exception - unless res.is_a? StandardError - Rails.logger.info "*** Patch install thread: Result: #{res.inspect}" - else - Rails.logger.debug "*** Patch install thread: Exception raised: #{res.inspect}" - end - bm.finish_process(proc_id, res) - end + def self.license + Dir.glob(File.join(LICENSES_DIR,"*")).reduce([]) do |res,f| + if File.file? f + res << ({ + :name => File.basename(f), + :text => File.read(f) + }) end - - return bm.get_progress(proc_id) - else - return do_install(pk_id,signal_list,&block) + res end end + def self.do_install(pk_id, signal_list = [], &block) + #locking PackageKit for single use + PackageKit.lock + ok = true - transaction_iface, packagekit_iface = PackageKit.connect + begin + transaction_iface, packagekit_iface = PackageKit.connect - proxy = transaction_iface.object + proxy = transaction_iface.object - if block_given? - signal_list.each { |signal| - # set the custom signal handle - proxy.on_signal(signal.to_s, &block) - } - end - - proxy.on_signal("Package") do |line1,line2,line3| - Rails.logger.debug " update package: #{line2}" - end - - error = '' - dbusloop = PackageKit.dbusloop proxy, error - dbusloop << proxy.bus - - proxy.on_signal("Error") do |u1,u2| - ok = false - dbusloop.quit - end - if transaction_iface.methods["UpdatePackages"] && # catch mocking - transaction_iface.methods["UpdatePackages"].params.size == 2 && - transaction_iface.methods["UpdatePackages"].params[0][0] == "only_trusted" - #PackageKit of 11.2 - transaction_iface.UpdatePackages(true, #only_trusted - [pk_id]) - else - #PackageKit older versions like SLES11 - transaction_iface.UpdatePackages([pk_id]) - end - - dbusloop.run - packagekit_iface.SuggestDaemonQuit - - ok &= error.blank? - - # bnc#617350, remove signals - proxy.on_signal "Error" - proxy.on_signal "Package" - if block_given? - signal_list.each { |signal| - proxy.on_signal signal.to_s - } - end - - return ok - end - -private - - def self.bgid(what) - "packagekit_install_#{what}" - end - - def self.subprocess_script(type) - file = case type - when :find then "list_patches.rb" - when :install then "install_patches.rb" - else raise "unsupported type" - end - # find the helper script - script = File.join(RAILS_ROOT, 'vendor/plugins/software/scripts',file) # RORSCAN_ITL - - unless File.exists? script # RORSCAN_ITL - script = File.join(RAILS_ROOT, '../plugins/software/scripts',file) # RORSCAN_ITL - - unless File.exists? script # RORSCAN_ITL - raise "File software/scripts/#{file} was not found!" # RORSCAN_ITL + if block_given? + signal_list.each { |signal| + # set the custom signal handle + proxy.on_signal(signal.to_s, &block) + } + end + + proxy.on_signal("Package") do |line1,line2,line3| + Rails.logger.debug " update package: #{line2}" + end + + error = '' + dbusloop = PackageKit.dbusloop proxy, error + dbusloop << proxy.bus + + proxy.on_signal("Error") do |u1,u2| + ok = false + dbusloop.quit + end + proxy.on_signal("EulaRequired") do |eula_id,package_id,vendor_name,license_text| + #FIXME check if user already agree with license + if handle_eula(eula_id,license_text) + PackageKit.transact :AcceptEula, [eula_id],nil,nil + PackageKit.transact :UpdatePackages, [[pk_id]], nil, nil + dbusloop.quit + else + ok = false + dbusloop.quit + end end + if transaction_iface.methods["UpdatePackages"] && # catch mocking + transaction_iface.methods["UpdatePackages"].params.size == 2 && + transaction_iface.methods["UpdatePackages"].params[0][0] == "only_trusted" + #PackageKit of 11.2 + transaction_iface.UpdatePackages(true, #only_trusted + [pk_id]) + else + #PackageKit older versions like SLES11 + transaction_iface.UpdatePackages([pk_id]) + end + + dbusloop.run + + ok &= error.blank? + + # bnc#617350, remove signals + proxy.on_signal "Error" + proxy.on_signal "Package" + proxy.on_signal "EulaRequired" + if block_given? + signal_list.each { |signal| + proxy.on_signal signal.to_s + } + end + ensure + #unlocking PackageKit + PackageKit.unlock end - Rails.logger.debug "Using #{script} script file" # RORSCAN_ITL - script - end - - def self.subprocess_command(type,what) - raise "Invalid parameter" if what.to_s.include?("'") or what.to_s.include?('\\') - ret = "cd #{RAILS_ROOT} && RAILS_ENV=#{ENV['RAILS_ENV'] || 'development'} #{File.join(RAILS_ROOT, 'script/runner')} #{subprocess_script type} " - ret = ret + "'#{what}'" if type == :install #only install use specified patches - return ret - end - - # IO functions moved to separate methods for easy mocking/testing - - def self.open_subprocess(type,what) - IO.popen subprocess_command(type,what) - end - - def self.read_subprocess(subproc) - subproc.readline + return ok end - def self.eof_subprocess?(subproc) - subproc.eof? + def self.handle_eula(eula_id,license_text) + #TODO check if user already accept exactly same license + license_file = File.join(LICENSES_DIR,eula_id) + File.open(license_file,"w") { |f| f.write license_text } + while File.exists?(license_file) + sleep 1 #prevent turning server into radiator + end + accepted_path = File.join(ACCEPTED_LICENSES_DIR,eula_id) + ret = File.exists?(accepted_path) #eula is in accepted dir + File.delete accepted_path if ret #require new confirmation every patch same as zypper + ret end - def self.subprocess_install(what) - # open subprocess - subproc = open_subprocess :install, what - - result = nil - - while !eof_subprocess?(subproc) do - begin - line = read_subprocess subproc - - unless line.blank? - received = Hash.from_xml(line) - - # is it a progress or the final list? - if received.has_key? 'patch_installation' - Rails.logger.debug "Received background patch installation result: #{received['patch_installation'].inspect}" - # create Patch objects - result = received['patch_installation']['result'] - elsif received.has_key? 'background_status' - s = received['background_status'] - - bm.update_progress bgid(what) do |bs| - bs.status = s['status'] - bs.progress = s['progress'] - bs.subprogress = s['subprogress'] - end - elsif received.has_key? 'error' - return PackageKitError.new(received['error']['description']) - else - Rails.logger.warn "*** Patch installtion thread: Received unknown input: #{line}" - end - end - rescue Exception => e - Rails.logger.error "Background thread: Could not evaluate output: #{line.chomp}, exception: #{e}" # RORSCAN_ITL - Rails.logger.error "Background thread: Backtrace: #{e.backtrace.join("\n")}" - - # rethrow the exception - raise e - end - end - - result - end end diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/www/app/models/patches_state.rb new/www/app/models/patches_state.rb --- old/www/app/models/patches_state.rb 2010-09-17 16:23:35.000000000 +0200 +++ new/www/app/models/patches_state.rb 2011-04-20 11:40:23.000000000 +0200 @@ -24,7 +24,21 @@ class PatchesState include GetText def self.read() - if File.exist? Patch::MESSAGES_FILE + licenses_to_confirm = Dir.glob(File.join(Patch::LICENSES_DIR,"*")).select {|f| File.file? f} + if !licenses_to_confirm.empty? + file = licenses_to_confirm[0] #take first one + text = File.read file + return { :level => "warning", + :message_id => "PATCH_EULA", + :short_description => _("EULA accept required"), + :long_description => _("Package require accept specific EULA before its installation. Please follow bellowed link."), + :details => "", + :confirmation_host => "client", + :confirmation_link => "/patch_updates/license", + :confirmation_label => _("decide"), + :confirmation_kind => "link" } + + elsif File.exist? Patch::MESSAGES_FILE f = File.new(Patch::MESSAGES_FILE, 'r') messages = f.gets(nil) || "" @@ -32,13 +46,14 @@ :message_id => "PATCH_MESSAGES", :short_description => _("Patch installation messages not confirmed"), :long_description => messages, - :details => "", + :details => "", :confirmation_host => "service", :confirmation_link => "/patch_update/state", :confirmation_label => _("OK"), - :confirmation_kind => "button" } + :confirmation_kind => "button" } else return {} - end + end end + end diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/www/app/models/repository.rb new/www/app/models/repository.rb --- old/www/app/models/repository.rb 2010-12-13 11:21:27.000000000 +0100 +++ new/www/app/models/repository.rb 2011-04-29 18:23:25.000000000 +0200 @@ -63,22 +63,28 @@ end def self.find(what) - repositories = Array.new - - PackageKit.transact('GetRepoList', 'none', 'RepoDetail') { |id, name, enabled| - Rails.logger.debug "RepoDetail signal received: #{id}, #{name}, #{enabled}" - - if what == :all || id == what - repo = Repository.new(id, name, enabled) - # read other attributes directly from *.repo file, - # because PackageKit doesn't have API for that - repo.read_file - - repositories << repo + YastCache.fetch(self,what) { + PackageKit.lock #locking + begin + repositories = Array.new + + PackageKit.transact('GetRepoList', 'none', 'RepoDetail') { |id, name, enabled| + Rails.logger.debug "RepoDetail signal received: #{id}, #{name}, #{enabled}" + + if what == :all || id == what + repo = Repository.new(id, name, enabled) + # read other attributes directly from *.repo file, + # because PackageKit doesn't have API for that + repo.read_file + + repositories << repo + end + } + ensure + PackageKit.unlock #locking end + repositories } - - repositories end def self.mtime @@ -152,29 +158,36 @@ # def update # create a new repository if it does not exist yet - if !Repository.exists?(@id) - Rails.logger.info "Adding a new repository '#{@id}': #{self.inspect}" - PackageKit.transact('RepoSetData', [@id, 'add', @url]) - else - Rails.logger.info "Modifying repository '#{@id}': #{self.inspect}" - # set url - PackageKit.transact('RepoSetData', [@id, 'url', @url]) - end - - # set enabled flag - PackageKit.transact('RepoEnable', [@id, @enabled]) + repo_exist = Repository.exists?(@id) + PackageKit.lock #locking + begin + unless repo_exist + Rails.logger.info "Adding a new repository '#{@id}': #{self.inspect}" + PackageKit.transact('RepoSetData', [@id, 'add', @url]) + else + Rails.logger.info "Modifying repository '#{@id}': #{self.inspect}" + # set url + PackageKit.transact('RepoSetData', [@id, 'url', @url]) + end - # set priority - PackageKit.transact('RepoSetData', [@id, 'prio', @priority.to_s]) + # set enabled flag + PackageKit.transact('RepoEnable', [@id, @enabled]) - # set autorefresh - PackageKit.transact('RepoSetData', [@id, 'refresh', @autorefresh.to_s]) + # set priority + PackageKit.transact('RepoSetData', [@id, 'prio', @priority.to_s]) - # set name - PackageKit.transact('RepoSetData', [@id, 'name', @name.to_s]) + # set autorefresh + PackageKit.transact('RepoSetData', [@id, 'refresh', @autorefresh.to_s]) - # set keep_package - PackageKit.transact('RepoSetData', [@id, 'keep', @keep_packages.to_s]) + # set name + PackageKit.transact('RepoSetData', [@id, 'name', @name.to_s]) + + # set keep_package + PackageKit.transact('RepoSetData', [@id, 'keep', @keep_packages.to_s]) + ensure + PackageKit.unlock #locking + end + YastCache.reset(self,@id) end # @@ -182,8 +195,16 @@ # def destroy return false if @id.blank? - - PackageKit.transact('RepoSetData', [@id, 'remove', 'NONE']) + ret = false + PackageKit.lock #locking + begin + ret = PackageKit.transact('RepoSetData', [@id, 'remove', 'NONE']) + ensure + PackageKit.unlock #locking + return ret + end + YastCache.delete(self,@id) + return ret end diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/www/config/resources/packages.yml new/www/config/resources/packages.yml --- old/www/config/resources/packages.yml 2010-08-27 14:58:55.000000000 +0200 +++ new/www/config/resources/packages.yml 2011-04-11 12:49:05.000000000 +0200 @@ -1,2 +1,9 @@ interface: org.opensuse.yast.system.packages controller: packages + +#cache: +# enabled: true/false +# priority: -100..100 +# reload_after: seconds (0 == do not reload) +cache: + enabled: false diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/www/config/resources/patches.yml new/www/config/resources/patches.yml --- old/www/config/resources/patches.yml 2010-08-27 14:58:55.000000000 +0200 +++ new/www/config/resources/patches.yml 2011-04-19 11:37:20.000000000 +0200 @@ -1,2 +1,11 @@ interface: org.opensuse.yast.system.patches controller: patches + +#cache: +# enabled: true/false +# priority: -100..100 +# reload_after: seconds (0 == do not reload) +cache: + enabled: true + priority: 20 + reload_after: 360 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/www/lib/install_in_progress_exception.rb new/www/lib/install_in_progress_exception.rb --- old/www/lib/install_in_progress_exception.rb 2010-08-27 14:58:55.000000000 +0200 +++ new/www/lib/install_in_progress_exception.rb 2011-04-11 12:49:05.000000000 +0200 @@ -20,21 +20,19 @@ #++ class InstallInProgressException < BackendException - def initialize(count,progress) - @progress = progress + def initialize(count) @count = count - end + end - def to_xml + def to_xml xml = Builder::XmlMarkup.new({}) xml.instruct! xml.error do xml.type "PACKAGEKIT_INSTALL" - xml.description "Cannot obtain patches, installation in progress. Remain #{@count} packages. Status of currently installed package #{@progress.progress}" - xml.progress @progress + xml.description "Cannot obtain patches, installation in progress. Remain #{@count} packages." xml.count @count, :type => "integer" xml.bug false, :type => "boolean" end - end + end end diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/www/lib/license_required_exception.rb new/www/lib/license_required_exception.rb --- old/www/lib/license_required_exception.rb 1970-01-01 01:00:00.000000000 +0100 +++ new/www/lib/license_required_exception.rb 2011-04-20 12:45:00.000000000 +0200 @@ -0,0 +1,37 @@ +#-- +# Copyright (c) 2009-2011 Novell, Inc. +# +# All Rights Reserved. +# +# This program is free software; you can redistribute it and/or modify it +# under the terms of version 2 of the GNU General Public License +# as published by the Free Software Foundation. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, contact Novell, Inc. +# +# To contact Novell about this file by physical or electronic mail, +# you may find current contact information at www.novell.com +#++ + +class LicenseRequiredException < BackendException + def initialize + super "License confirm required to continue with installation. Please go to patch module, where you can decide about license confirmation." + end + + def to_xml + xml = Builder::XmlMarkup.new({}) + xml.instruct! + + xml.error do + xml.type "PACKAGEKIT_LICENSE" + xml.description message + xml.bug false, :type => "boolean" + end + end +end diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/www/lib/packagekit.rb new/www/lib/packagekit.rb --- old/www/lib/packagekit.rb 2011-02-01 10:49:25.000000000 +0100 +++ new/www/lib/packagekit.rb 2011-04-20 12:42:18.000000000 +0200 @@ -51,7 +51,7 @@ private def self.improve_error(dbus_error) # check if it is a known error - if dbus_error.message =~ /org.freedesktop.DBus.Error.([A-Za-z.]*)/ + if dbus_error.name =~ /org.freedesktop.DBus.Error.([A-Za-z.]*)/ case $1 when "ServiceUnknown" return ServiceNotAvailable.new('PackageKit') @@ -99,6 +99,30 @@ end public + + # + # PackageKit.lock + # + # Lock PackagKit for single use + # + def self.lock + Rails.logger.info "PackageKit locking via DBUS lock" + YastService.lock # Only one thread have access to DBUS. + # So we have to synchronize with YastService calls + # Otherwise DBUS hangs + Rails.logger.info "PackageKit locked" + end + + # + # PackageKit.unlock + # + # Unlock PackagKit + # + def self.unlock + YastService.unlock + Rails.logger.info "PackageKit unlocked via DBUS unlock" + end + # # PackageKit.connect # @@ -160,15 +184,15 @@ # def self.transact(method, args, signal = nil, bg_stat = nil, &block) begin + error = '' + result = nil transaction_iface, packagekit_iface = self.connect proxy = transaction_iface.object - error = '' - # set the custom signal handler if set proxy.on_signal(signal.to_s, &block) if !signal.blank? && block_given? - + proxy.on_signal("Error") { dbusloop.quit } if bg_stat proxy.on_signal("StatusChanged") do |s| Rails.logger.debug "PackageKit progress: StatusChanged: #{s}" @@ -182,17 +206,13 @@ bg_stat.subprogress = p2 < 101 ? p2 : -1 end end - dbusloop = self.dbusloop proxy, error - dbusloop << proxy.bus - # Do the call only when all signal handlers are in place, # otherwise Finished can arrive early and dbusloop will never # quit, bnc#561578 # call it after creating the DBus loop (bnc#579001) result = transaction_iface.send(method.to_sym, *args) - # run the main loop, process the incoming signals dbusloop.run @@ -203,8 +223,7 @@ proxy.on_signal("StatusChanged") end proxy.on_signal(signal.to_s) if !signal.blank? && block_given? - - packagekit_iface.SuggestDaemonQuit + proxy.on_signal("Error") raise PackageKitError.new(error) unless error.blank? diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/www/scripts/install_patches.rb new/www/scripts/install_patches.rb --- old/www/scripts/install_patches.rb 2010-12-13 11:21:27.000000000 +0100 +++ new/www/scripts/install_patches.rb 1970-01-01 01:00:00.000000000 +0100 @@ -1,77 +0,0 @@ -#-- -# Copyright (c) 2009-2010 Novell, Inc. -# -# All Rights Reserved. -# -# This program is free software; you can redistribute it and/or modify it -# under the terms of version 2 of the GNU General Public License -# as published by the Free Software Foundation. -# -# This program is distributed in the hope that it will be useful, -# but WITHOUT ANY WARRANTY; without even the implied warranty of -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -# GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License -# along with this program; if not, contact Novell, Inc. -# -# To contact Novell about this file by physical or electronic mail, -# you may find current contact information at www.novell.com -#++ - - -# this is a helper script -# -# ruby-dbus is NOT thread safe and therefore patches cannot be safely read -# in a separate thread, workaround is to use a separate process (this script) - -# this is an observer class which prints changes in the progress -# in XML format on stdout -class ProgressPrinter - def initialize(prog) - # watch changes in a progress status object - prog.add_observer(self) - end - - # this is the callback method - def update(progress) - # print the progress in XML format on single line - puts progress.to_xml.gsub("\n", '') - - # print it immediately, flush the output buffer - $stdout.flush - end -end - -bs = BackgroundStatus.new - -# register a progress printer for the progress object -ProgressPrinter.new(bs) - -pk_id = ARGV[0] - -begin - result = Patch.do_install(pk_id, ['RequireRestart','Message']) { |type, details| - Rails.logger.info "** Background process: Message signal received: #{type}, #{details}" - begin - dirname = File.dirname(Patch::MESSAGES_FILE) - FileUtils.mkdir_p(dirname) unless File.directory?(dirname) - f = File.new(Patch::MESSAGES_FILE, 'a+') - f.puts '<br/>' unless File.size(Patch::MESSAGES_FILE).zero? - # TODO: make the message traslatable - f.puts "#{details}" - rescue Exception => e - Rails.logger.error "writing #{Patch::MESSAGES_FILE} file failed: #{e.try(:message)}" - ensure - f.try(:close) - end - } - - puts ({'result' => result}).to_xml(:root => "patch_installation", :dasherize => false).gsub("\n", '') -rescue Exception => e - if e.respond_to? :to_xml - puts e.to_xml.gsub("\n", '') - else - puts PackageKitError.new(e.message).to_xml.gsub("\n", '') - end -end diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/www/scripts/list_patches.rb new/www/scripts/list_patches.rb --- old/www/scripts/list_patches.rb 2010-08-27 14:58:55.000000000 +0200 +++ new/www/scripts/list_patches.rb 1970-01-01 01:00:00.000000000 +0100 @@ -1,62 +0,0 @@ -#-- -# Copyright (c) 2009-2010 Novell, Inc. -# -# All Rights Reserved. -# -# This program is free software; you can redistribute it and/or modify it -# under the terms of version 2 of the GNU General Public License -# as published by the Free Software Foundation. -# -# This program is distributed in the hope that it will be useful, -# but WITHOUT ANY WARRANTY; without even the implied warranty of -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -# GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License -# along with this program; if not, contact Novell, Inc. -# -# To contact Novell about this file by physical or electronic mail, -# you may find current contact information at www.novell.com -#++ - - -# this is a helper script -# -# ruby-dbus is NOT thread safe and therefore patches cannot be safely read -# in a separate thread, workaround is to use a separate process (this script) - -# this an observer class which prints changes in the progress -# in XML format on stdout -class ProgressPrinter - def initialize(prog) - # watch changes in a progress status object - prog.add_observer(self) - end - - # this is the callback method - def update(progress) - # print the progress in XML format on single line - puts progress.to_xml.gsub("\n", '') - - # print it immediately, flush the output buffer - $stdout.flush - end -end - -bs = BackgroundStatus.new - -# register a progress printer for the progress object -ProgressPrinter.new(bs) - -what = :available - -begin - patches = Patch.do_find(what, bs) - puts patches.to_xml(:root => "patches", :dasherize => false).gsub("\n", '') -rescue Exception => e - if e.respond_to? :to_xml - puts e.to_xml.gsub("\n", '') - else - puts PackageKitError.new(e.message).to_xml.gsub("\n", '') - end -end diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/www/test/functional/patches_controller_test.rb new/www/test/functional/patches_controller_test.rb --- old/www/test/functional/patches_controller_test.rb 2010-12-13 11:21:27.000000000 +0100 +++ new/www/test/functional/patches_controller_test.rb 2011-04-20 13:07:36.000000000 +0200 @@ -51,7 +51,7 @@ :repo => "openSUSE-11.1-Updates") Patch.stubs(:mtime).returns(Time.now) - Patch.stubs(:find).with(:available, {:background => nil}).returns([@p1, @p2]) + Patch.stubs(:find).with(:all).returns([@p1, @p2]) Patch.stubs(:find).with('462').returns(@p1) Patch.stubs(:find).with('wrong_id').returns(nil) Patch.stubs(:find).with('not_found').returns(nil) @@ -137,4 +137,12 @@ assert Hash.from_xml(@response.body)["messages"].empty? end + test "license required" do + PatchesState.stubs(:read).returns(:message_id => "PATCH_EULA").once + + get :index + assert_response 503 + assert_equal "PACKAGEKIT_LICENSE", Hash.from_xml(@response.body)["error"]["type"] + end + end diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/www/test/functional/repositories_controller_test.rb new/www/test/functional/repositories_controller_test.rb --- old/www/test/functional/repositories_controller_test.rb 2010-08-27 14:58:55.000000000 +0200 +++ new/www/test/functional/repositories_controller_test.rb 2011-04-11 12:49:05.000000000 +0200 @@ -219,58 +219,6 @@ assert_response :missing end - # Test cache expiration - test "cache expired" do - cached = Time.utc(2010,"jan",1,20,0,0) #=> Fri Jan 01 20:00:00 UTC 2010 - modified = cached + 60 # modified 1 minute after caching - current_time = modified + 60 # now it's 1 minute after the modification - Time.stubs(:now).returns(current_time) - - Rails.cache.expects(:read).with(RepositoriesController::CACHE_ID).returns(cached) - Repository.expects(:mtime).returns(modified) - - # check that the actions are expired - @controller.expects(:expire_action).with(:action => :index, :format => nil) - - Rails.cache.expects(:write).with(RepositoriesController::CACHE_ID, current_time) - - get :index - end - - test "cache still valid" do - cached = Time.utc(2010,"jan",1,20,0,0) #=> Fri Jan 01 20:00:00 UTC 2010 - modified = cached - 60 # modified 1 minute before caching - current_time = cached + 60 # now it's 1 minute after caching the first call - Time.stubs(:now).returns(current_time) - - Rails.cache.expects(:read).with(RepositoriesController::CACHE_ID).returns(cached) - Repository.expects(:mtime).returns(modified) - - # check that the actions are not expired - @controller.expects(:expire_action).never - # do not update the cache time stamp - Rails.cache.expects(:write).never - - get :index - end - - test "not cached yet" do - cached = nil # not cached yet - modified = Time.utc(2010,"jan",1,20,0,0) #=> Fri Jan 01 20:00:00 UTC 2010 - current_time = modified + 60 # now it's 1 minute after the modification - Time.stubs(:now).returns(current_time) - - Rails.cache.expects(:read).with(RepositoriesController::CACHE_ID).returns(cached) - - # check that the actions are not expired - @controller.expects(:expire_action).never - - # just update the cache time stamp - Rails.cache.expects(:write).with(RepositoriesController::CACHE_ID, current_time) - - get :index - end - # Test validations test "create with invalid priority" do Repository.any_instance.expects(:update).never diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/www/test/unit/packagekit_test.rb new/www/test/unit/packagekit_test.rb --- old/www/test/unit/packagekit_test.rb 2010-08-27 14:58:55.000000000 +0200 +++ new/www/test/unit/packagekit_test.rb 2011-04-11 12:49:05.000000000 +0200 @@ -59,7 +59,7 @@ def test_install @transaction.stubs(:UpdatePackages).returns(true) - result = Patch.install :id1 + result = Patch.install "id1" assert result end diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/www/test/unit/patch_test.rb new/www/test/unit/patch_test.rb --- old/www/test/unit/patch_test.rb 2010-08-27 14:58:55.000000000 +0200 +++ new/www/test/unit/patch_test.rb 2011-04-11 12:49:05.000000000 +0200 @@ -93,39 +93,6 @@ assert_equal [], patch end - SCRIPT_OUTPUT_ERROR = read_test_data('patch_test-script_error.out') - - def test_available_patches_background_mode_error - - Patch.stubs(:read_subprocess).returns(*SCRIPT_OUTPUT_ERROR) - # return EOF when all lines are read - Patch.stubs(:eof_subprocess?).returns(*(Array.new(SCRIPT_OUTPUT_ERROR.size, false) << true)) - - # note: Patch.find(:available, {:background => true}) - # cannot be used here, Threading support in test mode doesn't work :-( - patches = Patch.subprocess_find(:available) - - assert_equal PackageKitError, patches.class - end - - SCRIPT_OUTPUT_OK = read_test_data('patch_test-script_ok.out') - - def test_available_patches_background_mode_ok - Patch.stubs(:read_subprocess).returns(*SCRIPT_OUTPUT_OK) - - # return EOF when all lines are read - Patch.stubs(:eof_subprocess?).returns(*(Array.new(SCRIPT_OUTPUT_OK.size, false) << true)) - - # note: Patch.find(:available, {:background => true}) - # cannot be used here, Threading support in test mode doesn't work :-( - patches = Patch.subprocess_find(:available) - - assert_equal 4, patches.size - assert_equal 1579, patches.first.resolvable_id - assert_equal 'slessp0-openslp', patches.first.name - end - - def test_patch_install rset = PackageKitResultSet.new "Package", :info => :s, :id => :s, :summary => :s rset << [ 'important', 'update-test-affects-package-manager;847;noarch;updates-test', 'update-test: Test updates for 11.2' ] ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Remember to have fun... -- To unsubscribe, e-mail: opensuse-commit+unsubscribe@opensuse.org For additional commands, e-mail: opensuse-commit+help@opensuse.org