Merge pull request xapi-project#2810 from huizh/CA-223030

CA-223030: Introduce update API error code and refine error message accordingly.

Author: lindig

ocaml/idl/api_errors.ml

@@ -350,12 +350,18 @@ let patch_already_applied = "PATCH_ALREADY_APPLIED"
 let update_already_applied = "UPDATE_ALREADY_APPLIED"
 let update_already_applied_in_pool = "UPDATE_ALREADY_APPLIED_IN_POOL"
 let update_pool_apply_failed = "UPDATE_POOL_APPLY_FAILED"
+let update_apply_failed = "UPDATE_APPLY_FAILED"
+let update_precheck_failed_unknown_error = "UPDATE_PRECHECK_FAILED_UNKNOWN_ERROR"
+let update_precheck_failed_prerequisite_missing = "UPDATE_PRECHECK_FAILED_PREREQUISITE_MISSING"
+let update_precheck_failed_conflict_present = "UPDATE_PRECHECK_FAILED_CONFLICT_PRESENT"
+let update_precheck_failed_wrong_server_version = "UPDATE_PRECHECK_FAILED_WRONG_SERVER_VERSION"
 let patch_precheck_failed_unknown_error = "PATCH_PRECHECK_FAILED_UNKNOWN_ERROR"
 let patch_precheck_failed_prerequisite_missing = "PATCH_PRECHECK_FAILED_PREREQUISITE_MISSING"
 let patch_precheck_failed_wrong_server_version = "PATCH_PRECHECK_FAILED_WRONG_SERVER_VERSION"
 let patch_precheck_failed_wrong_server_build = "PATCH_PRECHECK_FAILED_WRONG_SERVER_BUILD"
 let patch_precheck_failed_vm_running = "PATCH_PRECHECK_FAILED_VM_RUNNING"
 let patch_precheck_failed_out_of_space = "PATCH_PRECHECK_FAILED_OUT_OF_SPACE"
+let update_precheck_failed_out_of_space = "UPDATE_PRECHECK_FAILED_OUT_OF_SPACE"
 let patch_precheck_tools_iso_mounted = "PATCH_PRECHECK_FAILED_ISO_MOUNTED"
 let patch_apply_failed = "PATCH_APPLY_FAILED"
 let patch_apply_failed_backup_files_exist = "PATCH_APPLY_FAILED_BACKUP_FILES_EXIST"

ocaml/idl/datamodel.ml

@@ -1192,19 +1192,30 @@ let _ =
     ~doc:"This command is not allowed on the OEM edition." ();
 
   (* Update errors *)
-  error Api_errors.invalid_update []
+  error Api_errors.invalid_update [ "info" ]
     ~doc:"The uploaded update package is invalid." ();
   error Api_errors.update_is_applied [ ]
     ~doc:"The specified update has been applied and cannot be destroyed." ();
   error Api_errors.cannot_find_update []
     ~doc:"The requested update could not be found. Please upload the update again. This can occur when you run xe update-pool-clean before xe update-apply. " ();
   error Api_errors.update_pool_apply_failed [ "hosts" ]
     ~doc:"The update cannot be applied for the following host(s)." ();
+  error Api_errors.update_apply_failed [ "output" ]
+    ~doc:"The update failed to apply. Please see attached output." ();
   error Api_errors.update_already_applied [ "update" ]
     ~doc:"This update has already been applied." ();
   error Api_errors.update_already_applied_in_pool [ "update" ]
     ~doc:"This update has already been applied to all hosts in the pool." ();
-
+  error Api_errors.update_precheck_failed_unknown_error [ "update"; "info" ]
+    ~doc:"The update precheck stage failed with an unknown error." ();
+  error Api_errors.update_precheck_failed_prerequisite_missing [ "update"; "info" ]
+    ~doc:"The update precheck stage failed: prerequisite update(s) are missing." ();
+  error Api_errors.update_precheck_failed_conflict_present ["update"; "info"]
+    ~doc:"The update precheck stage failed: conflicting updates are present." ();
+  error Api_errors.update_precheck_failed_wrong_server_version ["update"; "info"]
+    ~doc:"The update precheck stage failed: the server is of an incorrect version." ();
+  error Api_errors.update_precheck_failed_out_of_space ["update"; "available_space"; "required_space "]
+    ~doc:"The update precheck stage failed: the server does not have enough space." ();
 
   (* Pool errors *)
 

ocaml/xapi/xapi_pool_update.ml

@@ -377,7 +377,7 @@ let pool_apply ~__context ~self =
   if List.length unapplied_hosts = 0
   then begin
     debug "pool_update.pool_apply, %s has already been applied on all hosts." pool_update_name;
-    raise (Api_errors.Server_error(Api_errors.update_already_applied_in_pool, []))
+    raise (Api_errors.Server_error(Api_errors.update_already_applied_in_pool, [Ref.string_of self]))
   end
   else
     let failed_hosts = unapplied_hosts |>

scripts/extensions/pool_update.apply

@@ -7,6 +7,7 @@ import json
 import traceback
 import subprocess
 import os
+import re
 import fasteners
 import errno
 import shutil
@@ -17,13 +18,19 @@ TMP_DIR = '/tmp/'
 UPDATE_ALREADY_APPLIED = 'UPDATE_ALREADY_APPLIED'
 UPDATE_APPLY_FAILED = 'UPDATE_APPLY_FAILED'
 OTHER_OPERATION_IN_PROGRESS = 'OTHER_OPERATION_IN_PROGRESS'
-PATCH_PRECHECK_FAILED_UNKNOWN_ERROR = 'PATCH_PRECHECK_FAILED_UNKNOWN_ERROR'
+UPDATE_PRECHECK_FAILED_UNKNOWN_ERROR = 'UPDATE_PRECHECK_FAILED_UNKNOWN_ERROR'
 CANNOT_FIND_UPDATE = 'CANNOT_FIND_UPDATE'
+INVALID_UPDATE = 'INVALID_UPDATE'
+ERROR_MESSAGE_DOWNLOAD_PACKAGE = 'Error downloading packages:\n'
+ERROR_MESSAGE_START = 'Error: '
+ERROR_MESSAGE_END = 'You could try '
 
 
 class ApplyFailure(Exception):
     pass
 
+class InvalidUpdate(Exception):
+    pass
 
 def success_message():
     rpcparams = {'Status': 'Success', 'Value': ''}
@@ -42,14 +49,17 @@ def execute_apply(session, update_package, yum_conf_file):
     output, _ = p.communicate()
     xcp.logger.info('pool_update.apply %r returncode=%r output=%r', cmd, p.returncode, output)
     if p.returncode != 0:
-        lines = output.splitlines()
-        errorlines = [l for l in lines if l.startswith('Error: ')]
-        if errorlines:
-            errmsg = errorlines[-1].split(':', 1)[-1].strip()
+        if ERROR_MESSAGE_DOWNLOAD_PACKAGE in output:
+            raise InvalidUpdate('Missing package(s) in the update.')
+
+        m = re.search('(?<=' + ERROR_MESSAGE_START + ').+$', output, flags=re.DOTALL)
+        if m:
+            errmsg = m.group()
+            errmsg = re.sub(ERROR_MESSAGE_END + '.+', '', errmsg, flags=re.DOTALL)
+            errmsg = re.sub('\n +', ' ', errmsg, flags=re.DOTALL)
+            raise ApplyFailure(errmsg)
         else:
-            errmsg = lines[-1]
-        raise ApplyFailure(
-            'Install %s error: %s' % (update_package, errmsg))
+            raise ApplyFailure()
 
 
 if __name__ == '__main__':
@@ -68,7 +78,7 @@ if __name__ == '__main__':
         # Check if the update has been applied.
         if update in session.xenapi.host.get_updates(host):
             print(failure_message(
-                UPDATE_ALREADY_APPLIED, ['This update has already been applied.']))
+                UPDATE_ALREADY_APPLIED, [update]))
             sys.exit(0)
 
         update_uuid = session.xenapi.pool_update.get_uuid(update)
@@ -82,26 +92,24 @@ if __name__ == '__main__':
 
         if not lock_acquired:
             print(failure_message(
-                OTHER_OPERATION_IN_PROGRESS, ['Another apply operation is in progress.']))
+                OTHER_OPERATION_IN_PROGRESS, ['Applying the update', update]))
             sys.exit(0)
 
         # Run precheck
         try:
             session.xenapi.pool_update.precheck(update, host)
         except Exception as e:
             try:
-                errors = json.loads(str(e))
-                print(failure_message(errors[0], errors[1:]))
+                print(failure_message(e.details[0], e.details[1:]))
             except:
-                print(failure_message(PATCH_PRECHECK_FAILED_UNKNOWN_ERROR, [str(e)]))
+                print(failure_message(UPDATE_PRECHECK_FAILED_UNKNOWN_ERROR, [str(e)]))
             sys.exit(0)
 
         update_vdi = session.xenapi.pool_update.get_vdi(update)
         try:
             update_vdi_uuid = session.xenapi.VDI.get_uuid(update_vdi)
         except Exception as e:
-            print(failure_message(CANNOT_FIND_UPDATE,
-                ['Missing update package [uuid=%s]' % update_uuid]))
+            print(failure_message(CANNOT_FIND_UPDATE, []))
             sys.exit(0)
 
         # Apply the update.
@@ -121,9 +129,10 @@ if __name__ == '__main__':
 
             session.xenapi.pool_update.resync_host(host)
             print(success_message())
+        except InvalidUpdate as e:
+            print(failure_message(INVALID_UPDATE, [str(e)]))
         except Exception as e:
-            print(failure_message(UPDATE_APPLY_FAILED,
-                                  ['Failed to apply the update: %s' % e]))
+            print(failure_message(UPDATE_APPLY_FAILED, [str(e)]))
         finally:
             session.xenapi.pool_update.detach(update)
             try:

scripts/extensions/pool_update.precheck

@@ -10,6 +10,7 @@ import traceback
 import subprocess
 import os
 import errno
+import re
 import shutil
 import StringIO
 import ConfigParser
@@ -18,12 +19,35 @@ import xcp.logger
 
 
 TMP_DIR = '/tmp/'
-PATCH_PRECHECK_FAILED_UNKNOWN_ERROR = 'PATCH_PRECHECK_FAILED_UNKNOWN_ERROR'
+UPDATE_PRECHECK_FAILED_UNKNOWN_ERROR = 'UPDATE_PRECHECK_FAILED_UNKNOWN_ERROR'
+UPDATE_PRECHECK_FAILED_PREREQUISITE_MISSING = 'UPDATE_PRECHECK_FAILED_PREREQUISITE_MISSING'
+UPDATE_PRECHECK_FAILED_CONFLICT_PRESENT = 'UPDATE_PRECHECK_FAILED_CONFLICT_PRESENT'
+UPDATE_PRECHECK_FAILED_WRONG_SERVER_VERSION = 'UPDATE_PRECHECK_FAILED_WRONG_SERVER_VERSION'
+UPDATE_PRECHECK_FAILED_OUT_OF_SPACE = 'UPDATE_PRECHECK_FAILED_OUT_OF_SPACE'
+INVALID_UPDATE = 'INVALID_UPDATE'
 CANNOT_FIND_UPDATE = 'CANNOT_FIND_UPDATE'
+ERROR_MESSAGE_START = 'Error: '
+ERROR_MESSAGE_END = 'You could try '
+ERROR_MESSAGE_CONFLICT = ' conflicts with '
+ERROR_MESSAGE_PREREQUISITE = 'Requires: '
+ERROR_MESSAGE_VERSION_REQUIRED = 'Requires: '
+ERROR_MESSAGE_VERSION_INSTALLED = 'Installed: '
+ERROR_MESSAGE_DOWNLOAD_PACKAGE = 'Error downloading packages:\n'
 
 class PrecheckFailure(Exception):
     pass
 
+class PrerequisiteMissing(Exception):
+    pass
+
+class ConflictPresent(Exception):
+    pass
+
+class WrongServerVersion(Exception):
+    pass
+
+class InvalidUpdate(Exception):
+    pass
 
 def success_message(result):
     rpcparams = {'Status': 'Success', 'Value': result}
@@ -41,10 +65,10 @@ def parse_control_package(session, yum_url):
         update_xml = urllib2.urlopen(yum_url + '/update.xml').read()
         xmldoc = xml.dom.minidom.parse(StringIO.StringIO(update_xml))
     else:
-        raise PrecheckFailure('Incorrect yum repo (%r)' % yum_url)
+        raise PrecheckFailure('Incorrect yum repo')
     items = xmldoc.getElementsByTagName('update')
     if not items:
-        raise PrecheckFailure('Parse Control Package from yum (%r)' % yum_url)
+        raise PrecheckFailure('Missing <update> in update.xml')
     return items[0].getAttribute('control')
 
 
@@ -54,19 +78,29 @@ def execute_precheck(session, control_package, yum_conf_file):
     livepatch_dic = {'PATCH_PRECHECK_LIVEPATCH_COMPLETE': 'ok_livepatch_complete', 'PATCH_PRECHECK_LIVEPATCH_INCOMPLETE': 'ok_livepatch_incomplete', 'PATCH_PRECHECK_LIVEPATCH_NOT_APPLICABLE': 'ok'}
     cmd = ['yum', 'install', '-y', '--noplugins', '-c', yum_conf_file, control_package]
     p = subprocess.Popen(cmd, shell=False, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, close_fds=True)
-    p.wait()
-    output = p.stdout.read()
+    output, _ = p.communicate()
     xcp.logger.info('pool_update.precheck %r returncode=%r output=%r', cmd, p.returncode, output)
-    lines = output.splitlines()
     if p.returncode != 0:
-        errorlines = [l for l in lines if l.startswith('Error: ')]
-        if errorlines:
-            errmsg = errorlines[-1].split(':', 1)[-1].strip()
+        if ERROR_MESSAGE_DOWNLOAD_PACKAGE in output:
+            raise InvalidUpdate('Missing package(s) in the update')
+
+        m = re.search('(?<=' + ERROR_MESSAGE_START + ').+$', output, flags=re.DOTALL)
+        if m:
+            errmsg = m.group()
+            errmsg = re.sub(ERROR_MESSAGE_END + '.+', '', errmsg, flags=re.DOTALL)
+            errmsg = re.sub('\n +', ' ', errmsg, flags=re.DOTALL)
+            if ERROR_MESSAGE_CONFLICT in errmsg:
+                raise ConflictPresent(errmsg)
+            elif ERROR_MESSAGE_VERSION_REQUIRED in errmsg and ERROR_MESSAGE_VERSION_INSTALLED in errmsg:
+                 raise WrongServerVersion(errmsg)
+            elif ERROR_MESSAGE_PREREQUISITE in errmsg:
+                raise PrerequisiteMissing(errmsg)
+            else:
+                raise PrecheckFailure(errmsg)
         else:
-            errmsg = lines[-1]
-        raise PrecheckFailure(
-            'Install %s error: %s' % (control_package, errmsg))
+            raise PrecheckFailure()
     else:
+        lines = output.splitlines()
         resultlines = [l for l in lines if l.startswith('<livepatch ')]
         if resultlines:
             result = resultlines[-1].split('\"')[1]
@@ -102,8 +136,20 @@ if __name__ == '__main__':
             update_vdi_uuid = session.xenapi.VDI.get_uuid(update_vdi)
             update_vdi_valid = True
         except Exception as e:
-            print(failure_message(CANNOT_FIND_UPDATE,
-                ['Missing update package [uuid=%s]' % update_uuid]))
+            print(failure_message(CANNOT_FIND_UPDATE, []))
+            sys.exit(0)
+
+        # verify that dom0 has enough space to install the package
+        statvfs = os.statvfs('/')
+        available_dom0_disk_size = statvfs.f_frsize * statvfs.f_bavail
+        try:
+            required_size = int(int(session.xenapi.pool_update.get_installation_size(update)) * 1.5)
+            if required_size > available_dom0_disk_size:
+                print(failure_message(UPDATE_PRECHECK_FAILED_OUT_OF_SPACE,
+                    [update_package, str(available_dom0_disk_size), str(required_size)]))
+                sys.exit(0)
+        except:
+            print(failure_message(INVALID_UPDATE, ["Issue with <installation-size> in update.xml"]))
             sys.exit(0)
 
         # attach and get the yum configuration
@@ -126,9 +172,16 @@ if __name__ == '__main__':
 
         control_package = parse_control_package(session, yum_url)
         print(success_message(execute_precheck(session, control_package, yum_conf_file)))
+    except PrerequisiteMissing as e:
+        print(failure_message(UPDATE_PRECHECK_FAILED_PREREQUISITE_MISSING, [update_package, str(e)]))
+    except ConflictPresent as e:
+        print(failure_message(UPDATE_PRECHECK_FAILED_CONFLICT_PRESENT, [update_package, str(e)]))
+    except WrongServerVersion as e:
+        print(failure_message(UPDATE_PRECHECK_FAILED_WRONG_SERVER_VERSION, [update_package, str(e)]))
+    except InvalidUpdate as e:
+        print(failure_message(INVALID_UPDATE, [update_package, str(e)]))
     except Exception as e:
-        print(failure_message(PATCH_PRECHECK_FAILED_UNKNOWN_ERROR,
-                              ['Precheck failed on host %s [uuid=%s]: %s' % (host_name_label ,host_uuid, e)]))
+        print(failure_message(UPDATE_PRECHECK_FAILED_UNKNOWN_ERROR, [update_package, str(e)]))
     finally:
         if session is not None and update_vdi_valid is True:
             session.xenapi.pool_update.detach(update)