upstream/oracle/slim_source: comparison usr/src/cmd/auto-install/auto

equal deleted inserted replaced

-:fbde90ccfae9
+:6f7e708c38ec
 from osol_install.liberrsvc import ES_DATA_EXCEPTION
 from solaris_install import \
 ApplicationData, system_temp_path, post_install_logs_path, Popen
+from solaris_install.auto_install import TRANSFER_FILES_CHECKPOINT
 from solaris_install.auto_install.ai_instance import AIInstance
 from solaris_install.auto_install.checkpoints.dmm import \
 DERIVED_MANIFEST_DATA, DerivedManifestData
 from solaris_install.auto_install.checkpoints.target_selection import \
 SelectionError, TargetSelection
+from solaris_install.auto_install.checkpoints.target_selection_zone import \
+TargetSelectionZone
+from solaris_install.auto_install.checkpoints.ai_configuration import \
+AI_SERVICE_LIST_FILE, AIConfigurationError
 from solaris_install.auto_install.utmpx import users_on_console
 from solaris_install.boot import boot
 from solaris_install.data_object import ParsingError, \
 DataObject, ObjectNotFoundError
 from solaris_install.data_object.data_dict import DataObjectDict
 from solaris_install.engine import UnknownChkptError, UsageError, \
 RollbackError
 from solaris_install.ict import initialize_smf, update_dumpadm, ips, \
 device_config, apply_sysconfig, boot_archive, transfer_files, \
 create_snapshot, setup_swap
+from solaris_install.ict.apply_sysconfig import APPLY_SYSCONFIG_DICT, \
+APPLY_SYSCONFIG_PROFILE_KEY
 from solaris_install.logger import FileHandler, ProgressHandler, MAX_INT
 from solaris_install.logger import INSTALL_LOGGER_NAME
 from solaris_install.manifest.parser import ManifestError, \
 MANIFEST_PARSER_DATA
 from solaris_install.target import Target, discovery, instantiation
+from solaris_install.target.instantiation_zone import ALT_POOL_DATASET
 from solaris_install.target.logical import BE, Logical
 from solaris_install.transfer import create_checkpoint
 from solaris_install.transfer.info import Software, Destination, Image, \
 ImType, Dir, INSTALL, IPSSpec, CPIOSpec, SVR4Spec
 from solaris_install.transfer.ips import AbstractIPS
 AI_EXIT_FAILURE = 1
 AI_EXIT_AUTO_REBOOT = 64
 TARGET_INSTANTIATION_CHECKPOINT = 'target-instantiation'
 FIRST_TRANSFER_CHECKPOINT = 'first-transfer'
 MANIFEST_CHECKPOINTS = ["derived-manifest", "manifest-parser"]
-CHECKPOINTS_BEFORE_TI = ["target-discovery", "target-selection",
+CHECKPOINTS_BEFORE_TI = ["target-discovery", "target-selection", \
-TARGET_INSTANTIATION_CHECKPOINT]
+"ai-configuration", TARGET_INSTANTIATION_CHECKPOINT]
 CHECKPOINTS_BEFORE_TI.extend(MANIFEST_CHECKPOINTS)
 CHECKPOINTS_BEFORE_IPS = list(CHECKPOINTS_BEFORE_TI)
-TRANSFER_FILES_CHECKPOINT = 'transfer-ai-files'
 INSTALLED_ROOT_DIR = "/a"
 def __init__(self, args=None):
 """
 Class constructor
 """
+self.installed_root_dir = self.INSTALLED_ROOT_DIR
 self.auto_reboot = False
 self.doc = None
 self.exitval = self.AI_EXIT_SUCCESS
 self.derived_script = None
 self.manifest = None
 # Initialize Install Engine
 self.engine = InstallEngine(debug=True, stop_on_error=True)
 self.doc = self.engine.data_object_cache
-# Add ApplicationData to the DOC
+if self.options.zone_pool_dataset is not None:
-self._app_data = ApplicationData("auto-install")
+# If we're installing a zone root, generate a work_dir
+# location based on the current PID.
+work_dir = "/system/volatile/install." + str(os.getpid())
+# Add ApplicationData to the DOC
+self._app_data = ApplicationData("auto-install", work_dir=work_dir)
+self._app_data.data_dict[ALT_POOL_DATASET] = \
+self.options.zone_pool_dataset
+# Set installed_root_dir to be based off work_dir
+self.installed_root_dir = work_dir + self.INSTALLED_ROOT_DIR
+else:
+# Add ApplicationData to the DOC
+self._app_data = ApplicationData("auto-install")
+# Add profile location to the ApplySysconfig checkpoint's data dict.
+if self.options.profile is not None:
+# Try to find the ApplySysconfig data dict from
+# the DOC in case it already exists.
+as_doc_dict = None
+as_doc_dict = self.doc.volatile.get_first_child( \
+name=APPLY_SYSCONFIG_DICT)
+if as_doc_dict is None:
+# Initialize new dictionary in DOC
+as_dict = {APPLY_SYSCONFIG_PROFILE_KEY : self.options.profile}
+as_doc_dict = DataObjectDict(APPLY_SYSCONFIG_DICT, as_dict)
+self.doc.volatile.insert_children(as_doc_dict)
+else:
+# Add to existing dictionary in DOC
+as_doc_dict.data_dict[APPLY_SYSCONFIG_PROFILE_KEY] = \
+self.options.profile
+# Add service list file to ApplicationData
+if self.options.service_list_file is not None:
+self._app_data.data_dict[AI_SERVICE_LIST_FILE] = \
+self.options.service_list_file
 self.doc.persistent.insert_children(self._app_data)
 # Clear error service
 errsvc.clear_error_list()
 if self.options.stop_checkpoint:
 self.logger.debug("Pausing AI install before checkpoint: %s" % \
 (self.options.stop_checkpoint))
 if not self.options.list_checkpoints:
+if self.manifest:
-if self.options.manifest:
+self.logger.info("Using XML Manifest: %s" % (self.manifest))
-self.logger.info("Using Profile: %s" % (self.options.manifest))
 if self.derived_script:
 self.logger.info("Using Derived Script: %s" % \
 (self.derived_script))
-if self.manifest:
+if self.options.profile:
-self.logger.info("Using Manifest: %s" % (self.manifest))
+self.logger.info("Using profile specification: %s" % \
+(self.options.profile))
+if self.options.service_list_file:
+self.logger.info("Using service list file: %s" % \
+(self.options.service_list_file))
+if self.options.zone_pool_dataset:
+self.logger.info("Installing zone under dataset: %s" % \
+(self.options.zone_pool_dataset))
 if self.options.dry_run:
 self.logger.info("Dry Run mode enabled")
 def parse_args(self, args):
 """
 Method to parse command line arguments
 """
-usage = "%prog -m <manifest>\n" + \
+usage = "%prog -m <manifest> [-c <profile/dir>]\n"\
 "\t[-i - Stop installation before Target Instantiation |\n" + \
 "\t -I - Stop installation after Target Instantiation]\n" + \
-"\t[-n - Enable dry run mode]"
+"\t[-n - Enable dry run mode]\n" + \
+"\t[-r <service_list_file>]" + \
+"\t[-Z <zone_pool_dataset]"
 parser = optparse.OptionParser(usage=usage)
 parser.add_option("-m", "--manifest", dest="manifest",
 help="Specify script or XML manifest to use")
+parser.add_option("-c", "--profile", dest="profile",
+help="Specify a profile or directory of profiles")
 parser.add_option("-i", "--break-before-ti", dest="break_before_ti",
 action="store_true", default=False,
 help="Break execution before Target Instantiation, testing only")
 parser.add_option("-n", "--dry-run", dest="dry_run",
 action="store_true", default=False,
 help="Enable dry-run mode for testing")
-parser.add_option("-l", "--list-checkpoints",  dest="list_checkpoints",
+parser.add_option("-l", "--list-checkpoints", dest="list_checkpoints",
 action="store_true", default=False,
 help=optparse.SUPPRESS_HELP)
 parser.add_option("-s", "--stop-checkpoint", dest="stop_checkpoint",
 help=optparse.SUPPRESS_HELP)
+parser.add_option("-r", "--service-list-file",
+dest="service_list_file", help="Specify service list file")
+parser.add_option("-Z", "--zone-pool-dataset",
+dest="zone_pool_dataset",
+help="Specify zone pool dataset to install into")
 (options, args) = parser.parse_args(args)
-# If manifest argument provided, determine if script or manifest
+# If manifest argument provided, determine if script or XML manifest
 if options.manifest:
 (self.derived_script, self.manifest) =  \
 self.determine_manifest_type(options.manifest)
 if not self.derived_script and not self.manifest:
 parser.error("Must specify manifest with -m option")
 return (options, args)
 @staticmethod
 def determine_manifest_type(manifest):
 """
-Determine of manifest file argument is a script or xml manifest.
+Determine if manifest file argument is a script or xml manifest.
 Simply check reading first two characters of file for #!
 """
 derived_script = None
 xml_manifest = None
 # Create logger for AI
 self.logger = logging.getLogger(INSTALL_LOGGER_NAME)
 # Log progress and info messages to the console.
 self.progress_ph = AIProgressHandler(self.logger,
-skip_console_msg=self.options.list_checkpoints)
+skip_console_msg=(self.options.list_checkpoints or \
+self.options.zone_pool_dataset))
 self.progress_ph.start_progress_server()
 self.logger.addHandler(self.progress_ph)
 # Only ever send debug info to the logs, use INFO for console
 self.progress_ph.removeFilter(self.logger._prog_filter)
 self.progress_ph.setFormatter(formatter)
 # create a install_log file handler and add it to the ai_logger
 # set the logfile names
-install_log = self._app_data.work_dir + self.INSTALL_LOG
+install_log = os.path.join(self._app_data.work_dir, self.INSTALL_LOG)
 self.install_log_fh = FileHandler(install_log)
 self.install_log_fh.setLevel(logging.DEBUG)
 if not self.options.list_checkpoints:
 self.logger.info("Install Log: %s" % install_log)
 def __transfer_install_log(self):
 """If BE exists, then transfer Log Files to New BE"""
 new_be = self.be
 if new_be is not None:
-if new_be.exists:
+# Assumes BE is still mounted, should be, if it exists.
-# Assumes BE is still mounted, should be, if it exists.
+self.logger.debug("Transferring log to %s" %
-self.logger.info("Transferring log to %s" %
+new_be.mountpoint + self.BE_LOG_DIR)
-new_be.mountpoint + self.BE_LOG_DIR)
+self.install_log_fh.transfer_log(
-self.install_log_fh.transfer_log(
+new_be.mountpoint + self.BE_LOG_DIR, isdir=True)
-new_be.mountpoint + self.BE_LOG_DIR, isdir=True)
-else:
-self.logger.error(
-"Unable to determine BE mountpoint")
-return False
 else:
 self.logger.error(
 "Unable to determine location to transfer logs to")
 return False
 def __cleanup_before_exit(self, error_val):
 """Do some clean up and set exit code.
 """
+unmount_be = False
 self.exitval = error_val
 if not self.options.list_checkpoints:
 if error_val in [self.AI_EXIT_SUCCESS, self.AI_EXIT_AUTO_REBOOT]:
-if error_val == self.AI_EXIT_AUTO_REBOOT:
+self.logger.info("Automated Installation succeeded.")
-self.logger.info("Automated Installation succeeded.")
+if self.options.zone_pool_dataset is None:
-self.logger.info("System will be rebooted now")
+if error_val == self.AI_EXIT_AUTO_REBOOT:
-else:
+self.logger.info("System will be rebooted now")
-self.logger.info("Automated Installation succeeded.")
+else:
 self.logger.info("You may wish to reboot the system at "
 "this time.")
+unmount_be = True
 else:
 # error_val == self.AI_EXIT_FAILURE:
 self.logger.info("Automated Installation Failed")
 self.logger.info("Please see logs for more information")
 self.progress_ph.stop_progress_server()
 self.logger.close()
 # Only attempt to unmount BE if Target Instantiation has completed
 if self.options.stop_checkpoint not in self.CHECKPOINTS_BEFORE_TI:
-# Unmount the BE now.
+# If we didn't fail unmount the BE now.
-if self.be is not None:
+if unmount_be:
-try:
+if self.be is not None:
-self.be.unmount(self.options.dry_run)
+try:
-except (RuntimeError) as ex:
+self.be.unmount(self.options.dry_run,
-print ex  # Print since logger is closed now.
+altpool=self.options.zone_pool_dataset)
-self.exitval = self.AI_EXIT_FAILURE
+except RuntimeError as ex:
+# Use print since logger is now closed.
+print >> sys.stderr, str(ex)
+self.exitval = self.AI_EXIT_FAILURE
 def import_preserved_zpools(self):
 '''
 Check if we are preserving Zpools in manifest.
 If we are ensure any referenced zpools are imported.
 self.logger.error("Invalid stop checkpoint specified: %s" % \
 self.options.stop_checkpoint)
 self.__cleanup_before_exit(self.AI_EXIT_FAILURE)
 return
-# specifying to list checkpoints, do so then exit
+# If specifying to list checkpoints, do so then exit
 # List of checkpoints available depend on what has just been
 # registered.
 if self.options.list_checkpoints:
 self.list_checkpoints()
 self.__cleanup_before_exit(self.AI_EXIT_SUCCESS)
 if ai_instance.http_proxy is not None and \
 len(ai_instance.http_proxy) > 0:
 # Set the HTTP Proxy environment variable
 os.environ["http_proxy"] = ai_instance.http_proxy
-self.logger.info("Auto Reboot set to : %s" % (self.auto_reboot))
+self.logger.debug("Auto Reboot set to: %s" % (self.auto_reboot))
 # Ensure preserved zpools are online (imported)
 if not self.import_preserved_zpools():
 self.__cleanup_before_exit(self.AI_EXIT_FAILURE)
 return
 if self.options.stop_checkpoint not in self.CHECKPOINTS_BEFORE_IPS:
 if not self.__transfer_install_log():
 self.__cleanup_before_exit(self.AI_EXIT_FAILURE)
 else:
-if self.auto_reboot:
+if self.auto_reboot and \
+self.options.zone_pool_dataset is None:
 self.__cleanup_before_exit(self.AI_EXIT_AUTO_REBOOT)
 else:
 self.__cleanup_before_exit(self.AI_EXIT_SUCCESS)
 # Successful Execution
 else:
 # No manifest specified to parse
 return True
 if not self.options.list_checkpoints:
-self.logger.info("Registering Manifest Parser Checkpoint")
+self.logger.debug("Registering Manifest Parser Checkpoint")
 self.engine.register_checkpoint("manifest-parser",
 "solaris_install.manifest.parser",
 "ManifestParser", args=args, kwargs=kwargs)
 return True
 manifest as an explicit argument. (This is not implemented yet)
 """
 # Execute Checkpoints
 if not self.options.list_checkpoints:
 if self.derived_script:
-self.logger.info("Executing Derived Manifest and Manifest " \
+self.logger.debug("Executing Derived Manifest and Manifest " \
 "Parser Checkpoints")
 else:
-self.logger.info("Executing Manifest Parser Checkpoint")
+self.logger.debug("Executing Manifest Parser Checkpoint")
 if self.options.stop_checkpoint in self.MANIFEST_CHECKPOINTS:
 pause_cp = self.options.stop_checkpoint
 else:
 pause_cp = None
 return False
 except (ValueError) as ex:
 self.logger.error("Value errors occured :")
 print "\t\t%s" % str(ex)
 return False
+except (AIConfigurationError) as ex:
+self.logger.error("AI Configuration checkpoint error :")
+print "\t\t%s" % str(ex)
+return False
 except (RollbackError, UnknownChkptError, UsageError) as ex:
 self.logger.error("RollbackError, UnknownChkptError, UsageError :")
 print "\t\t%s" % str(ex)
 raise RuntimeError(str(ex))
 except Exception, ex:
 def configure_checkpoints(self):
 """
 Wrapper to configure required checkpoints for performing an
 automated installation
 """
-# Need to set following Checkpoints for installation
+# Need to set following Checkpoints for installation.  Checkpoints
-#   Derived Manifest (If script passed as argument)
+# marked with a 'G' are applicable when installing a global zone.
-#   Manifest Parser (If manifest passed or derived)
+# Checkpoings marked with a 'N' are application when installing a
-#   Target Discovery
+# non-global zone.
-#   Target Selection
+#   G- -- Derived Manifest (If script passed as argument)
-#   Device Driver Update - Install Root
+#   GN -- Manifest Parser (If manifest passed or derived)
-#   Target Instantiation
+#   G- -- Target Discovery
-#   Transfer
+#   G- -- Target Selection
-#   Target Configuration
+#   -N -- Target Selection Zone
-#   Device Driver Update - New BE
+#   GN -- AI Configuration
+#   G- -- Device Driver Update - Install Root
+#   G- -- Target Instantiation
+#   -N -- Target Instantiation Zone
+#   GN -- Transfer
+#   GN -- Target Configuration
+#   G- -- Device Driver Update - New BE
 try:
 if not self.options.list_checkpoints:
 self.logger.info("Configuring Checkpoints")
 # Register TargetDiscovery
-self.engine.register_checkpoint("target-discovery",
+if self.options.zone_pool_dataset is None:
+self.engine.register_checkpoint("target-discovery",
 "solaris_install.target.discovery",
 "TargetDiscovery", args=None, kwargs=None)
 # Register TargetSelection
-self.logger.debug("Adding Target Selection Checkpoint")
+if self.options.zone_pool_dataset is None:
-self.engine.register_checkpoint("target-selection",
+self.logger.debug("Adding Target Selection Checkpoint")
-"solaris_install.auto_install.checkpoints.target_selection",
+self.engine.register_checkpoint("target-selection",
-"TargetSelection", args=None, kwargs=None)
+"solaris_install.auto_install.checkpoints."
+"target_selection", "TargetSelection", args=None,
+kwargs=None)
+else:
+self.logger.debug("Adding Target Selection Zone Checkpoint")
+self.engine.register_checkpoint("target-selection",
+"solaris_install.auto_install.checkpoints."
+"target_selection_zone", "TargetSelectionZone", args=None,
+kwargs={"be_mountpoint": self.installed_root_dir})
+# Register AIConfiguration
+self.logger.debug("Adding AI Configuration Checkpoint")
+self.engine.register_checkpoint("ai-configuration",
+"solaris_install.auto_install.checkpoints.ai_configuration",
+"AIConfiguration", args=None, kwargs=None)
 # Register TargetInstantiation
-self.logger.debug("Adding Target Instantiation Checkpoint")
+if self.options.zone_pool_dataset is None:
-self.engine.register_checkpoint(self.TARGET_INSTANTIATION_CHECKPOINT,
+self.logger.debug("Adding Target Instantiation Checkpoint")
+self.engine.register_checkpoint(self.TARGET_INSTANTIATION_CHECKPOINT,
 "solaris_install.target.instantiation",
 "TargetInstantiation", args=None, kwargs=None)
+else:
+self.logger.debug("Adding Target Instantiation Zone "
+"Checkpoint")
+self.engine.register_checkpoint("target-instantiation",
+"solaris_install/target/instantiation_zone",
+"TargetInstantiationZone", args=None,
+kwargs=None)
 # Add destination for transfer nodes, and register checkpoints.
 sw_nodes = self.doc.volatile.get_descendants(class_type=Software)
 image_action = AbstractIPS.CREATE  # For first IPS only
 transfer_count = 0  # For generating names if none provided
 self.CHECKPOINTS_BEFORE_IPS.append(sw.name)
 if self.options.stop_checkpoint is not None:
 if self.options.stop_checkpoint == \
 self.FIRST_TRANSFER_CHECKPOINT:
 self.options.stop_checkpoint = sw.name
 # Ensure there is at least one software_data element with
 # Install action exists, and that all software_data elements
 # contain at least one 'name' sub element.
 found_install_sw_data = False
 if tran_type == "IPS" and isinstance(sw_child, IPSSpec):
 found_sw_data = True
 if sw_child.action == IPSSpec.INSTALL:
 found_install_sw_data = True
 elif tran_type == "CPIO" and \
 isinstance(sw_child, CPIOSpec):
 found_sw_data = True
 if sw_child.action == CPIOSpec.INSTALL:
 found_install_sw_data = True
 elif tran_type == "SVR4" and \
 isinstance(sw_child, SVR4Spec):
 found_sw_data = True
 if sw_child.action == SVR4Spec.INSTALL:
 found_install_sw_data = True
 if found_sw_data and len(sw_child.contents) == 0:
 "Manifest must contain at least one <software_data> "
 "element with 'install' action.")
 return False
 self.logger.debug("Setting destination for transfer: %s to %s"
-% (sw.name, self.INSTALLED_ROOT_DIR))
+% (sw.name, self.installed_root_dir))
 dst = sw.get_first_child(class_type=Destination)
 if dst is None:
 dst = Destination()
 if sw.tran_type.upper() == "IPS":
-image = Image(self.INSTALLED_ROOT_DIR, image_action)
+image = Image(self.installed_root_dir, image_action)
-img_type = ImType("full")
+if self.options.zone_pool_dataset is None:
+img_type = ImType("full", zone=False)
+else:
+img_type = ImType("full", zone=True)
 image.insert_children(img_type)
 dst.insert_children(image)
 image_action = AbstractIPS.EXISTING
 else:
-directory = Dir(self.INSTALLED_ROOT_DIR)
+directory = Dir(self.installed_root_dir)
 dst.insert_children(directory)
 sw.insert_children(dst)
 # Next images are use_existing, not create.
 else:
 raise RuntimeError(
 self.engine.register_checkpoint(*ckpt_info)
 # Register ICT Checkpoints
 #=========================
 # 1. Initialize SMF Repository
-self.engine.register_checkpoint("initialize-smf",
+if self.options.zone_pool_dataset is None:
-"solaris_install.ict.initialize_smf",
+self.engine.register_checkpoint("initialize-smf",
-"InitializeSMF", args=None, kwargs=None)
+"solaris_install.ict.initialize_smf",
+"InitializeSMF", args=None, kwargs=None)
+else:
+self.engine.register_checkpoint("initialize-smf-zone",
+"solaris_install.ict.initialize_smf",
+"InitializeSMFZone", args=None, kwargs=None)
 # 2. Boot Configuration
-self.engine.register_checkpoint("boot-configuration",
+if self.options.zone_pool_dataset is None:
-"solaris_install.boot.boot",
+self.engine.register_checkpoint("boot-configuration",
-"SystemBootMenu", args=None, kwargs=None)
+"solaris_install.boot.boot",
+"SystemBootMenu", args=None, kwargs=None)
 # 3. Update dumpadm / Dump Configuration
-self.engine.register_checkpoint("update-dump-adm",
+if self.options.zone_pool_dataset is None:
-"solaris_install.ict.update_dumpadm",
+self.engine.register_checkpoint("update-dump-adm",
-"UpdateDumpAdm", args=None, kwargs=None)
+"solaris_install.ict.update_dumpadm",
+"UpdateDumpAdm", args=None, kwargs=None)
 # 4. Setup Swap in Vfstab
 self.engine.register_checkpoint("setup-swap",
 "solaris_install.ict.setup_swap",
 "SetupSwap", args=None, kwargs=None)
 self.engine.register_checkpoint("set-flush-ips-content-cache",
 "solaris_install.ict.ips",
 "SetFlushContentCache", args=None, kwargs=None)
 # 6. Device Configuration / Create Device Namespace
-self.engine.register_checkpoint("device-config",
+if self.options.zone_pool_dataset is None:
-"solaris_install.ict.device_config",
+self.engine.register_checkpoint("device-config",
-"DeviceConfig", args=None, kwargs=None)
+"solaris_install.ict.device_config",
+"DeviceConfig", args=None, kwargs=None)
-# 7. Transfer System Configuration To BE / ApplyStsConfig
-self.engine.register_checkpoint("apply-sysconfig",
+# 7. Transfer System Configuration To BE / ApplySysConfig
-"solaris_install.ict.apply_sysconfig",
+if self.options.profile is not None:
-"ApplySysConfig", args=None, kwargs=None)
+self.engine.register_checkpoint("apply-sysconfig",
+"solaris_install.ict.apply_sysconfig",
+"ApplySysConfig", args=None, kwargs=None)
 # 8. Boot Archive
-self.engine.register_checkpoint("boot-archive",
+if self.options.zone_pool_dataset is None:
-"solaris_install.ict.boot_archive",
+self.engine.register_checkpoint("boot-archive",
-"BootArchive", args=None, kwargs=None)
+"solaris_install.ict.boot_archive",
+"BootArchive", args=None, kwargs=None)
 # 9. Transfer Files to New BE
 self.add_transfer_files()
-self.engine.register_checkpoint(self.TRANSFER_FILES_CHECKPOINT,
+self.engine.register_checkpoint(TRANSFER_FILES_CHECKPOINT,
 "solaris_install.ict.transfer_files",
 "TransferFiles", args=None, kwargs=None)
 # 10. CreateSnapshot before reboot
 self.engine.register_checkpoint("create-snapshot",
 """
 # Check for existence of transfer-ai-files data object dictionary,
 # insert if not found
 tf_doc_dict = None
 tf_doc_dict = self.doc.volatile.get_first_child( \
-name=self.TRANSFER_FILES_CHECKPOINT)
+name=TRANSFER_FILES_CHECKPOINT)
 if tf_doc_dict is None:
 # Initialize dictionary in DOC
 tf_dict = dict()
-tf_doc_dict = DataObjectDict(self.TRANSFER_FILES_CHECKPOINT,
+tf_doc_dict = DataObjectDict(TRANSFER_FILES_CHECKPOINT,
 tf_dict)
 self.doc.volatile.insert_children(tf_doc_dict)
 else:
 tf_dict = tf_doc_dict.data_dict
 mp = self.doc.volatile.get_first_child(name=MANIFEST_PARSER_DATA)
 if mp is not None and mp.manifest is not None:
 tf_dict[mp.manifest] = \
 post_install_logs_path('derived/manifest.xml')
+# Else transfer the XML manifest passed in
+else:
+tf_dict[self.manifest] = post_install_logs_path('ai.xml')
 # Transfer smf logs
 tf_dict['/var/svc/log/application-auto-installer:default.log'] = \
 post_install_logs_path('application-auto-installer:default.log')
 tf_dict['/var/svc/log/application-manifest-locator:default.log'] = \
 post_install_logs_path('application-manifest-locator:default.log')
-# Transfer default manifest
-tf_dict[system_temp_path('ai.xml')] = post_install_logs_path('ai.xml')
 # Transfer AI Service Discovery Log
 tf_dict[system_temp_path('ai_sd_log')] = \
 post_install_logs_path('ai_sd_log')

changeset 1160	6f7e708c38ec
parent 1154	8cb36a37e75d
child 1162	a4dac96d1eaa