def test_unavoid_noargs(self):
'''Test that an IPS package can be unavoided'''
self.tr_node.action = "unavoid"
self.tr_node.contents = ["solaris-large-server"]
self.tr_node2 = IPSSpec()
self.tr_node2.action = "unavoid"
self.tr_node2.contents = ["system/library/svm-rcm"]
self.soft_node.insert_children([self.tr_node2])
try:
self.tr_ips.execute(dry_run=DRY_RUN)
except Exception as err:
self.fail(str(err))
def test_uninstall(self):
'''Test that an IPS package can be uninstalled'''
self.tr_node.action = "install"
self.tr_node.contents = ["SUNWcs", "system/library/svm-rcm"]
self.tr_node2 = IPSSpec()
self.tr_node2.action = "uninstall"
self.tr_node2.contents = ["system/library/svm-rcm"]
self.soft_node.insert_children([self.tr_node2])
try:
self.tr_ips.execute(dry_run=DRY_RUN)
except Exception as err:
self.fail(str(err))
def test_uninstall_args(self):
'''Test that setting Args for the uninstall works'''
uninstall_args = Args(arg_dict={"update_index": False})
self.tr_node.action = "install"
self.tr_node.contents = ["SUNWcs", "system/library/svm-rcm"]
self.tr_node2 = IPSSpec()
self.tr_node2.action = "uninstall"
self.tr_node2.contents = ["system/library/svm-rcm"]
self.tr_node2.insert_children([uninstall_args])
self.soft_node.insert_children([self.tr_node2])
try:
self.tr_ips.execute(dry_run=DRY_RUN)
except Exception as err:
self.fail(str(err))
def test_unavoid_with_args(self):
'''Test that an IPS package can be rejected with args'''
install_args = Args(arg_dict={"update_index": False})
self.tr_node.action = "unavoid"
self.tr_node.contents = ["solaris-large-server"]
self.tr_node.insert_children([install_args])
self.tr_node2 = IPSSpec()
self.tr_node2.action = "unavoid"
self.tr_node2.contents = ["system/library/svm-rcm"]
self.soft_node.insert_children([self.tr_node2])
try:
self.tr_ips.execute(dry_run=DRY_RUN)
except Exception as err:
self.fail(str(err))
def setUp(self):
InstallEngine._instance = None
InstallEngine()
self.engine = InstallEngine.get_instance()
self.doc = self.engine.data_object_cache.volatile
self.soft_node = Software("IPS transfer")
self.tr_node = IPSSpec()
dst = Destination()
self.ips_image = Image(self.IPS_IMG_DIR, "create")
ips_im_type = ImType("full")
self.ips_image.insert_children([ips_im_type])
dst.insert_children([self.ips_image])
self.soft_node.insert_children([self.tr_node, dst])
self.doc.insert_children([self.soft_node])
self.tr_ips = TransferIPS("IPS transfer")
def test_multiple_source_info(self):
'''Test that specifying multiple sources succeeds.'''
soft_node = Software("transfer test 2")
src1 = Source()
pub1 = Publisher("test1.org")
origin1 = Origin("http://test1/dev")
pub1.insert_children([origin1])
src1.insert_children([pub1])
src2 = Source()
pub2 = Publisher("test2.org")
origin2 = Origin("http://test2/dev")
pub2.insert_children([origin2])
src2.insert_children([pub2])
tr_node = IPSSpec()
soft_node.insert_children([src1, src2, tr_node])
self.doc.insert_children([soft_node])
soft_list = self.doc.get_children("transfer test 2", Software)
for soft in soft_list:
src_list = soft.get_children("source", Source)
pub = src_list[0].get_children("publisher", Publisher)
origin = pub[0].get_children("origin", Origin)
self.assertEqual(pub[0].publisher, "test1.org")
self.assertEqual(origin[0].origin, "http://test1/dev")
pub = src_list[1].get_children("publisher", Publisher)
origin = pub[0].get_children("origin", Origin)
self.assertEqual(pub[0].publisher, "test2.org")
self.assertEqual(origin[0].origin, "http://test2/dev")
def test_live_cd_cleanup_dry(self):
'''Test the dry run functionality for cleanup_livecd'''
# Create an IPS node for packages to be removed
self.soft_node = Software("cleanup_cpio_install")
self.pkg_rm_node = IPSSpec()
self.pkg_rm_node.action = "uninstall"
self.pkg_rm_node.contents = self.TEXT_PKG_REMOVE_LIST
self.soft_node.insert_children([self.pkg_rm_node])
self.simple.doc.persistent.insert_children([self.soft_node])
# Create a CPIO node for files to be removed
self.add_cleanup_node = CPIOSpec()
self.add_cleanup_node.action = "uninstall"
self.add_cleanup_node.contents = self.add_files
self.soft_node.insert_children([self.add_cleanup_node])
cleanup_list = ['.livecd', '.volsetid', '.textinstall',
'etc/sysconfig/language', '.liveusb', 'a',
'bootcd_microroot', 'var/user/jack',
'var/cache/gdm/jack/dmrc', 'var/cache/gdm/jack/',
'file1', 'file2', 'file3']
# Instantiate the checkpoint
self.clean_lcd = CleanupCPIOInstall("cleanup_cpio_install")
# Call the execute command for the checkpoint
# with dry_run set to true.
try:
self.clean_lcd.execute(dry_run=True)
except Exception as e:
self.fail(str(e))
self.assertEquals(cleanup_list, self.clean_lcd.cleanup_list)
def test_args(self):
'''Test that setting the ips arguments works'''
soft_node = Software("transfer test 4")
tr_node = IPSSpec()
ips_args_node = Args({"force": True, "set-something": 12})
tr_node.insert_children([ips_args_node])
soft_node.insert_children([tr_node])
self.doc.insert_children([soft_node])
soft_list = self.doc.get_children("transfer test 4", Software)
for soft in soft_list:
tr_list = soft.get_children(class_type=IPSSpec)
for tr in tr_list:
ips_args = tr.get_children("args", Args)
for args in ips_args:
for key in args.arg_dict:
if key is not "force" or key is not "set-something":
self.assertTrue(True)
if key is "force":
self.assertEqual(args.arg_dict[key], True)
if key is "set-something":
self.assertEqual(args.arg_dict[key], 12)
def test_args(self):
'''Test that setting the ips arguments works'''
soft_node = Software("transfer test 4")
tr_node = IPSSpec()
ips_args_node = Args({"force": True, "set-something": 12})
tr_node.insert_children([ips_args_node])
soft_node.insert_children([tr_node])
self.doc.insert_children([soft_node])
soft_list = self.doc.get_children("transfer test 4", Software)
for soft in soft_list:
tr_list = soft.get_children(class_type=IPSSpec)
for tr in tr_list:
ips_args = tr.get_children("args", Args)
for args in ips_args:
for key in args.arg_dict:
if key is not "force" or key is not "set-something":
self.assertTrue(True)
if key is "force":
self.assertEqual(args.arg_dict[key], True)
if key is "set-something":
self.assertEqual(args.arg_dict[key], 12)
def test_uninstall(self):
'''Test that an IPS package can be uninstalled'''
self.tr_node.action = "install"
self.tr_node.contents = ["SUNWcs", "system/library/svm-rcm"]
self.tr_node2 = IPSSpec()
self.tr_node2.action = "uninstall"
self.tr_node2.contents = ["system/library/svm-rcm"]
self.soft_node.insert_children([self.tr_node2])
try:
self.tr_ips.execute(dry_run=DRY_RUN)
except Exception as err:
self.fail(str(err))
def test_uninstall_args(self):
'''Test that setting Args for the uninstall works'''
uninstall_args = Args(arg_dict={"update_index": False})
self.tr_node.action = "install"
self.tr_node.contents = ["SUNWcs", "system/library/svm-rcm"]
self.tr_node2 = IPSSpec()
self.tr_node2.action = "uninstall"
self.tr_node2.contents = ["system/library/svm-rcm"]
self.tr_node2.insert_children([uninstall_args])
self.soft_node.insert_children([self.tr_node2])
try:
self.tr_ips.execute(dry_run=DRY_RUN)
except Exception as err:
self.fail(str(err))
def setUp(self):
InstallEngine._instance = None
InstallEngine()
self.engine = InstallEngine.get_instance()
self.doc = self.engine.data_object_cache.volatile
self.soft_node = Software("IPS transfer")
self.tr_node = IPSSpec()
dst = Destination()
self.ips_image = Image(self.IPS_IMG_DIR, "create")
ips_im_type = ImType("full")
self.ips_image.insert_children([ips_im_type])
dst.insert_children([self.ips_image])
self.soft_node.insert_children([self.tr_node, dst])
self.doc.insert_children([self.soft_node])
self.tr_ips = TransferIPS("IPS transfer")
def test_mirror_info(self):
'''Test that writting to the mirror object works'''
soft_node = Software("transfer test 1")
src = Source()
pub = Publisher("test.org")
origin = Origin("http://test/dev")
mirror = Mirror("http://mirror")
pub.insert_children([origin, mirror])
src.insert_children([pub])
tr_node = IPSSpec()
soft_node.insert_children([src, tr_node])
self.doc.insert_children([soft_node])
soft_list = self.doc.get_children("transfer test 1", Software)
for soft in soft_list:
src_list = soft.get_children("source", Source)
pub = src_list[0].get_children("publisher", Publisher)
origin = pub[0].get_children("origin", Origin)
mirror = pub[0].get_children("mirror", Mirror)
self.assertEqual(pub[0].publisher, "test.org")
self.assertEqual(origin[0].origin, "http://test/dev")
self.assertEqual(mirror[0].mirror, "http://mirror")
class TestIPSFunctions(unittest.TestCase):
IPS_IMG_DIR = "/rpool/test_ips"
def setUp(self):
InstallEngine._instance = None
InstallEngine()
self.engine = InstallEngine.get_instance()
self.doc = self.engine.data_object_cache.volatile
self.soft_node = Software("IPS transfer")
self.tr_node = IPSSpec()
dst = Destination()
self.ips_image = Image(self.IPS_IMG_DIR, "create")
ips_im_type = ImType("full")
self.ips_image.insert_children([ips_im_type])
dst.insert_children([self.ips_image])
self.soft_node.insert_children([self.tr_node, dst])
self.doc.insert_children([self.soft_node])
self.tr_ips = TransferIPS("IPS transfer")
def tearDown(self):
self.engine.data_object_cache.clear()
InstallEngine._instance = None
self.doc = None
self.soft_node = None
self.tr_node = None
self.tr_ips = None
self.engine = None
def test_create(self):
'''Test that the IPS Transfer object is created'''
try:
try_ips = TransferIPS("IPS transfer")
except (TypeError, NameError):
self.fail("Failed to create TransferIPS object")
def test_install(self):
'''Test that an IPS package can be installed'''
self.tr_node.action = "install"
self.tr_node.contents = ["SUNWcs", "entire"]
try:
self.tr_ips.execute(dry_run=DRY_RUN)
except Exception as err:
self.fail(str(err))
def test_uninstall(self):
'''Test that an IPS package can be uninstalled'''
self.tr_node.action = "install"
self.tr_node.contents = ["SUNWcs", "system/library/svm-rcm"]
self.tr_node2 = IPSSpec()
self.tr_node2.action = "uninstall"
self.tr_node2.contents = ["system/library/svm-rcm"]
self.soft_node.insert_children([self.tr_node2])
try:
self.tr_ips.execute(dry_run=DRY_RUN)
except Exception as err:
self.fail(str(err))
def test_purge_history(self):
'''Test that the history is purged'''
self.tr_node.purge_history = True
self.tr_node.action = "install"
self.tr_node.contents = ["SUNWcs"]
try:
self.tr_ips.execute(dry_run=DRY_RUN)
except Exception as err:
self.fail(str(err))
def test_image_type(self):
'''Test that image_type functionality succeeds'''
self.tr_ips = TransferIPS("IPS transfer", {"zonename": "zonename"})
self.ips_image.delete_children()
ips_im_type = ImType("partial", zone=True)
self.ips_image = Image(self.IPS_IMG_DIR, "create")
self.ips_image.insert_children([ips_im_type])
dst = Destination()
dst.insert_children([self.ips_image])
self.soft_node.delete_children()
self.soft_node.insert_children([self.tr_node, dst])
self.doc.delete_children()
self.doc.insert_children([self.soft_node])
try:
self.tr_ips.execute(dry_run=DRY_RUN)
except Exception as err:
self.fail(str(err))
def test_image_args(self):
'''Test that setting Args for the image works'''
image_args = Args(arg_dict={"force": True})
self.ips_image.insert_children([image_args])
try:
self.tr_ips.execute(dry_run=DRY_RUN)
except Exception as err:
self.fail(str(err))
def test_ssl_key_in_image_args(self):
'''Test that setting ssl_key in image_args produces an error'''
image_args = Args(arg_dict={"ssl_key": "aaa"})
self.ips_image.insert_children([image_args])
self.assertRaises(Exception, self.tr_ips.execute, dry_run=DRY_RUN)
def test_ssl_cert_in_image_args(self):
'''Test that setting ssl_cert in image_args produces an error'''
image_args = Args(arg_dict={"ssl_cert": "aaa"})
self.ips_image.insert_children([image_args])
self.assertRaises(Exception, self.tr_ips.execute, dry_run=DRY_RUN)
def test_install_args(self):
'''Test that setting Args for the install works'''
install_args = Args(arg_dict={"refresh_catalogs": False})
self.tr_node.insert_children([install_args])
self.tr_node.action = "install"
self.tr_node.contents = ["SUNWcs"]
try:
self.tr_ips.execute(dry_run=DRY_RUN)
except Exception as err:
self.fail(str(err))
def test_uninstall_args(self):
'''Test that setting Args for the uninstall works'''
uninstall_args = Args(arg_dict={"update_index": False})
self.tr_node.action = "install"
self.tr_node.contents = ["SUNWcs", "system/library/svm-rcm"]
self.tr_node2 = IPSSpec()
self.tr_node2.action = "uninstall"
self.tr_node2.contents = ["system/library/svm-rcm"]
self.tr_node2.insert_children([uninstall_args])
self.soft_node.insert_children([self.tr_node2])
try:
self.tr_ips.execute(dry_run=DRY_RUN)
except Exception as err:
self.fail(str(err))
def test_default_publisher(self):
'''Test that using the default publisher succeeds'''
src = Source()
pub = Publisher()
origin = Origin("http://ipkg.sfbay.sun.com/release/")
pub.insert_children([origin])
src.insert_children([pub])
self.soft_node.insert_children([src])
try:
self.tr_ips.execute(dry_run=DRY_RUN)
except Exception as err:
self.fail(str(err))
def test_multiple_sources(self):
'''Test that setting multiple sources succeeds'''
src = Source()
pub = Publisher("opensolaris.org")
origin = Origin("http://ipkg.sfbay.sun.com/release/")
pub2 = Publisher("contrib.opensolaris.org")
origin2 = Origin("http://ipkg.sfbay.sun.com/contrib/")
pub3 = Publisher("extra")
origin3 = Origin("http://ipkg.sfbay.sun.com/extra/")
pub.insert_children([origin])
pub2.insert_children([origin2])
pub3.insert_children([origin3])
src.insert_children([pub, pub2, pub3])
self.soft_node.insert_children([src])
try:
self.tr_ips.execute(dry_run=DRY_RUN)
except Exception as err:
self.fail(str(err))
def test_source_addition(self):
'''Test that adding additional sources succeeds'''
src = Source()
pub = Publisher("opensolaris.org")
origin = Origin("http://ipkg.sfbay.sun.com/dev/")
pub.insert_children([origin])
src.insert_children([pub])
self.soft_node.insert_children([src])
try:
self.tr_ips.execute(dry_run=DRY_RUN)
except Exception as err:
self.fail(str(err))
# Now add another publisher to the repo
self.ips_image.action = "update"
pub2 = Publisher("extra")
origin2 = Origin("http://ipkg.sfbay.sun.com/extra/")
pub2.insert_children([origin2])
src.insert_children([pub2])
try:
self.tr_ips.execute(dry_run=DRY_RUN)
except Exception as err:
self.fail(str(err))
def test_source_replacement(self):
'''Test that replacing a source succeeds'''
# Setup an IPS image
src = Source()
pub = Publisher("opensolaris.org")
origin = Origin("http://ipkg.sfbay.sun.com/release/")
pub2 = Publisher("extra")
origin2 = Origin("http://ipkg.sfbay.sun.com/extra/")
pub2.insert_children([origin2])
pub.insert_children([origin])
src.insert_children([pub, pub2])
self.soft_node.insert_children([src])
try:
self.tr_ips.execute(dry_run=DRY_RUN)
except Exception as err:
self.fail(str(err))
# Create a new transaction with a differnt publisher/origin.
# Specify to update the image created above.
self.soft_node = Software("IPS post install")
self.doc.insert_children([self.soft_node])
src = Source()
pub = Publisher("opensolaris.org")
origin = Origin("http://ipkg.sfbay.sun.com/dev/")
pub.insert_children([origin])
src.insert_children([pub])
dst = Destination()
self.ips_image = Image(self.IPS_IMG_DIR, "update")
dst.insert_children([self.ips_image])
self.soft_node.insert_children([dst, src])
try:
self.tr_ips.execute(dry_run=DRY_RUN)
except Exception as err:
self.fail(str(err))
def test_mirrors(self):
'''Test creating mirrors succeeds'''
src = Source()
pub = Publisher("opensolaris.org")
origin = Origin("http://ipkg.sfbay.sun.com/release/")
mirror = Mirror("http://ipkg.central.sun.com:8000/")
pub.insert_children([origin, mirror])
src.insert_children([pub])
self.soft_node.insert_children([src])
try:
self.tr_ips.execute(dry_run=DRY_RUN)
except Exception as err:
self.fail(str(err))
def test_set_property(self):
'''Test that setting properties succeeds'''
src = Source()
pub = Publisher("opensolaris.org")
origin = Origin("http://ipkg.sfbay.sun.com/release/")
pub2 = Publisher("contrib.opensolaris.org")
origin2 = Origin("http://ipkg.sfbay.sun.com/contrib/")
pub3 = Publisher("extra")
origin3 = Origin("http://ipkg.sfbay.sun.com/extra/")
pub.insert_children([origin])
pub2.insert_children([origin2])
pub3.insert_children([origin3])
src.insert_children([pub, pub2, pub3])
self.soft_node.insert_children([src])
prop = Property("display-copyrights", 'False')
prop2 = Property("preferred-publisher", "extra")
self.ips_image.insert_children([prop, prop2])
try:
self.tr_ips.execute(dry_run=DRY_RUN)
except Exception as err:
self.fail(str(err))
def test_set_create_facets(self):
'''Test that creating facets succeeds'''
src = Source()
pub = Publisher("opensolaris.org")
origin = Origin("http://ipkg.sfbay.sun.com/release/")
pub.insert_children([origin])
src.insert_children([pub])
self.soft_node.insert_children([src])
facet = Facet("facet.doc", 'True')
self.ips_image.insert_children([facet])
try:
self.tr_ips.execute(dry_run=DRY_RUN)
except Exception as err:
self.fail(str(err))
def test_set_invalid_facets(self):
'''Ensure an error is raised for an invalid facet'''
src = Source()
pub = Publisher("opensolaris.org")
origin = Origin("http://ipkg.sfbay.sun.com/release/")
pub.insert_children([origin])
src.insert_children([pub])
self.soft_node.insert_children([src])
facet = Facet("doc", 'True')
self.ips_image.insert_children([facet])
self.assertRaises(Exception, self.tr_ips.execute)
def test_progress_estimate(self):
'''Test that progress estimate succeeds'''
self.tr_node.action = "install"
self.tr_node.contents = ["SUNWcs", "SUNWcsd", "entire",
"SUNWmd", "babel_install"]
try:
estimate = self.tr_ips.get_progress_estimate()
except Exception as err:
self.fail(str(err))
self.assertTrue(estimate == self.tr_ips.DEFAULT_PROG_EST * \
(len(self.tr_node.contents) / self.tr_ips.DEFAULT_PKG_NUM))
def test_invalid_args(self):
'''Ensure error raised when repo components are set as args'''
image_args = Args(arg_dict={"prefix": "prefix string"})
self.ips_image.insert_children([image_args])
self.assertRaises(ValueError, self.tr_ips.execute, dry_run=DRY_RUN)
# Test repo_uri fails
self.ips_image.delete_children()
image_args = Args(arg_dict={"repo_uri": "url string"})
self.ips_image.insert_children([image_args])
self.assertRaises(Exception, self.tr_ips.execute, dry_run=DRY_RUN)
# Test origins fails
self.ips_image.delete_children()
image_args = Args(arg_dict={"origins": "origin string"})
self.ips_image.insert_children([image_args])
self.assertRaises(Exception, self.tr_ips.execute, dry_run=DRY_RUN)
# Test mirrors fails
self.ips_image.delete_children()
image_args = Args(arg_dict={"mirrors": "mirror string"})
self.ips_image.insert_children([image_args])
self.assertRaises(Exception, self.tr_ips.execute, dry_run=DRY_RUN)
def test_checkpoint_soft_node_match(self):
'''The checkpoint and software node match'''
try:
tr_ips = TransferIPS("IPS transfer")
except Exception as err:
self.fail(str(err))
def perform_installation(self):
'''method which actually does the installation.'''
# establish the timer that will update the screen messaging
timer = glib.timeout_add(INSTALLATION_TIMEOUT,
self._update_screen_message)
eng = InstallEngine.get_instance()
errsvc.clear_error_list()
eng.execute_checkpoints(start_from=TRANSFER_PREP,
pause_before=VARSHARE_DATASET)
# Setup progress handling
self.setup_progress_handling()
self.logger.info("Setting up software to install/uninstall")
# Add the list of packages to be removed after the install to the DOC
pkg_remove_list = [
'pkg:/system/install/media/internal',
'pkg:/system/install/gui-install'
]
pkg_spec = IPSSpec(action=IPSSpec.UNINSTALL, contents=pkg_remove_list)
pkg_rm_node = Software(CLEANUP_CPIO_INSTALL, type="IPS")
pkg_rm_node.insert_children(pkg_spec)
eng.doc.volatile.insert_children(pkg_rm_node)
# Setup system configuration data
profile = from_engine()
gui_profile = eng.data_object_cache.volatile.get_first_child(
name="GUI Install", class_type=InstallProfile)
if gui_profile is None:
SystemExit('Internal Error, GUI Install DOC not found')
profile.system = SystemInfo(hostname=gui_profile.hostname,
tz_region=gui_profile.continent,
tz_country=gui_profile.country,
tz_timezone=gui_profile.timezone,
locale=gui_profile.default_locale)
profile.nic = NetworkInfo(net_type="automatic")
# Setup user configuration data
root = UserInfo(login_name="root",
is_role=True,
password=gui_profile.userpassword,
expire="0")
user = UserInfo(gid=10,
shell="/usr/bin/bash",
login_name=gui_profile.loginname,
real_name=gui_profile.username,
password=gui_profile.userpassword,
roles="root",
profiles="System Administrator",
sudoers="ALL=(ALL) ALL")
profile.users = UserInfoContainer(user, root)
self.logger.debug('from_engine returned %s', profile)
gui_profile.set_log(DEFAULT_LOG_LOCATION, LOG_LOCATION_FINAL)
# Run the registered checkpoints
errsvc.clear_error_list()
eng.execute_checkpoints(callback=self.install_callback)
self.logger.info("Install Started")
return False
def test_info(self):
'''Test that the arguments get into the node correctly'''
# just dst, need to check default repo
soft_node = Software("transfer test 1")
tr_node = IPSSpec()
soft_node.insert_children([tr_node])
self.doc.insert_children([soft_node])
dst = Destination()
ips_image = Image("/rpool/dc", "create")
self.img_type = ImType("full")
ips_image.insert_children([self.img_type])
dst.insert_children([ips_image])
src = Source()
pub = Publisher()
origin = Origin("http://pkg.omniti.com/omnios/release")
pub.insert_children([origin])
src.insert_children([pub])
# first check src and dst
soft_node.insert_children([dst, src, soft_node])
soft_list = self.doc.get_children("transfer test 1", Software)
for soft in soft_list:
tr_list = soft.get_children(class_type=IPSSpec)
for tr in tr_list:
src_list = soft.get_children("source", Source)
self.assertEqual(len(src_list), 1)
pub = src_list[0].get_children("publisher", Publisher)
origin = pub[0].get_children("origin", Origin)
self.assertEqual(origin[0].origin,
"http://pkg.omniti.com/omnios/release")
dst_list = soft.get_children("destination", Destination)
self.assertEqual(len(dst_list), 1)
image = dst_list[0].get_children("image", Image)
self.assertEqual(len(image), 1)
img_type = image[0].get_children("img_type", ImType)
self.assertEqual(len(img_type), 1)
self.assertEqual(image[0].img_root, "/rpool/dc")
self.assertEqual(image[0].action, "create")
self.assertEqual(img_type[0].completeness, "full")
self.assertEqual(img_type[0].zone, False)
self.assertEqual(tr.action, None)
self.assertEqual(tr.contents, None)
self.assertEqual(tr.app_callback, None)
self.assertEqual(tr.purge_history, False)
# pkg install list is set
tr_node.action = "install"
tr_node.contents = ["SUNWcs", "SUNWcsr"]
soft_list = self.doc.get_children("transfer test 1", Software)
for soft in soft_list:
tr_list = soft.get_children(class_type=IPSSpec)
for tr in tr_list:
src_list = soft.get_children("source", Source)
self.assertEqual(len(src_list), 1)
pub = src_list[0].get_children("publisher", Publisher)
origin = pub[0].get_children("origin", Origin)
self.assertEqual(origin[0].origin,
"http://pkg.omniti.com/omnios/release")
dst_list = soft.get_children("destination", Destination)
self.assertEqual(len(dst_list), 1)
image = dst_list[0].get_children("image", Image)
self.assertEqual(len(image), 1)
img_type = image[0].get_children("img_type", ImType)
self.assertEqual(len(img_type), 1)
self.assertEqual(image[0].img_root, "/rpool/dc")
self.assertEqual(image[0].action, "create")
self.assertEqual(img_type[0].completeness, "full")
self.assertEqual(img_type[0].zone, False)
self.assertEqual(tr.contents, ["SUNWcs", "SUNWcsr"])
self.assertEqual(tr.action, "install")
self.assertEqual(tr.purge_history, False)
self.assertEqual(tr.app_callback, None)
# pkg uninstall list is set
tr_node.action = "uninstall"
tr_node.contents = ["SUNWcs"]
soft_list = self.doc.get_children("transfer test 1", Software)
for soft in soft_list:
tr_list = soft.get_children(class_type=IPSSpec)
for tr in tr_list:
src_list = soft.get_children("source", Source)
self.assertEqual(len(src_list), 1)
pub = src_list[0].get_children("publisher", Publisher)
origin = pub[0].get_children("origin", Origin)
self.assertEqual(origin[0].origin,
"http://pkg.omniti.com/omnios/release")
dst_list = soft.get_children("destination", Destination)
self.assertEqual(len(dst_list), 1)
image = dst_list[0].get_children("image", Image)
self.assertEqual(len(image), 1)
img_type = image[0].get_children("img_type", ImType)
self.assertEqual(len(img_type), 1)
self.assertEqual(image[0].img_root, "/rpool/dc")
self.assertEqual(image[0].action, "create")
self.assertEqual(img_type[0].completeness, "full")
self.assertEqual(img_type[0].zone, False)
self.assertEqual(tr.action, "uninstall")
self.assertEqual(tr.contents, ["SUNWcs"])
self.assertEqual(tr.purge_history, False)
self.assertEqual(tr.app_callback, None)
# purge history is set to true
tr_node.purge_history = True
soft_list = self.doc.get_children("transfer test 1", Software)
for soft in soft_list:
tr_list = soft.get_children(class_type=IPSSpec)
for tr in tr_list:
src_list = soft.get_children("source", Source)
self.assertEqual(len(src_list), 1)
pub = src_list[0].get_children("publisher", Publisher)
origin = pub[0].get_children("origin", Origin)
self.assertEqual(origin[0].origin,
"http://pkg.omniti.com/omnios/release")
dst_list = soft.get_children("destination", Destination)
self.assertEqual(len(dst_list), 1)
image = dst_list[0].get_children("image", Image)
self.assertEqual(len(image), 1)
img_type = image[0].get_children("img_type", ImType)
self.assertEqual(len(img_type), 1)
self.assertEqual(image[0].img_root, "/rpool/dc")
self.assertEqual(image[0].action, "create")
self.assertEqual(img_type[0].completeness, "full")
self.assertEqual(img_type[0].zone, False)
self.assertEqual(tr.action, "uninstall")
self.assertEqual(tr.contents, ["SUNWcs"])
self.assertEqual(tr.purge_history, True)
# is zone is set to True
self.img_type.zone = True
soft_list = self.doc.get_children("transfer test 1", Software)
for soft in soft_list:
tr_list = soft.get_children(class_type=IPSSpec)
for tr in tr_list:
src_list = soft.get_children("source", Source)
self.assertEqual(len(src_list), 1)
pub = src_list[0].get_children("publisher", Publisher)
origin = pub[0].get_children("origin", Origin)
self.assertEqual(origin[0].origin,
"http://pkg.omniti.com/omnios/release")
dst_list = soft.get_children("destination", Destination)
self.assertEqual(len(dst_list), 1)
image = dst_list[0].get_children("image", Image)
self.assertEqual(len(image), 1)
img_type = image[0].get_children("img_type", ImType)
self.assertEqual(len(img_type), 1)
self.assertEqual(image[0].img_root, "/rpool/dc")
self.assertEqual(image[0].action, "create")
self.assertEqual(img_type[0].completeness, "full")
self.assertEqual(img_type[0].zone, True)
self.assertEqual(tr.action, "uninstall")
self.assertEqual(tr.contents, ["SUNWcs"])
self.assertEqual(tr.purge_history, True)
# completeness is set to IMG_TYPE_PARTIAL
self.img_type.completeness = IMG_TYPE_PARTIAL
soft_list = self.doc.get_children("transfer test 1", Software)
for soft in soft_list:
tr_list = soft.get_children(class_type=IPSSpec)
for tr in tr_list:
src_list = soft.get_children("source", Source)
self.assertEqual(len(src_list), 1)
pub = src_list[0].get_children("publisher", Publisher)
origin = pub[0].get_children("origin", Origin)
self.assertEqual(origin[0].origin,
"http://pkg.omniti.com/omnios/release")
dst_list = soft.get_children("destination", Destination)
self.assertEqual(len(dst_list), 1)
image = dst_list[0].get_children("image", Image)
self.assertEqual(len(image), 1)
img_type = image[0].get_children("img_type", ImType)
self.assertEqual(len(img_type), 1)
self.assertEqual(image[0].img_root, "/rpool/dc")
self.assertEqual(image[0].action, "create")
self.assertEqual(img_type[0].completeness, IMG_TYPE_PARTIAL)
self.assertEqual(img_type[0].zone, True)
self.assertEqual(tr.action, "uninstall")
self.assertEqual(tr.contents, ["SUNWcs"])
self.assertEqual(tr.purge_history, True)
class TestIPSFunctions(unittest.TestCase):
IPS_IMG_DIR = "/rpool/test_ips"
def setUp(self):
InstallEngine._instance = None
InstallEngine()
self.engine = InstallEngine.get_instance()
self.doc = self.engine.data_object_cache.volatile
self.soft_node = Software("IPS transfer")
self.tr_node = IPSSpec()
dst = Destination()
self.ips_image = Image(self.IPS_IMG_DIR, "create")
ips_im_type = ImType("full")
self.ips_image.insert_children([ips_im_type])
dst.insert_children([self.ips_image])
self.soft_node.insert_children([self.tr_node, dst])
self.doc.insert_children([self.soft_node])
self.tr_ips = TransferIPS("IPS transfer")
def tearDown(self):
self.engine.data_object_cache.clear()
InstallEngine._instance = None
self.doc = None
self.soft_node = None
self.tr_node = None
self.tr_ips = None
self.engine = None
def test_create(self):
'''Test that the IPS Transfer object is created'''
try:
try_ips = TransferIPS("IPS transfer")
except (TypeError, NameError):
self.fail("Failed to create TransferIPS object")
def test_install(self):
'''Test that an IPS package can be installed'''
self.tr_node.action = "install"
self.tr_node.contents = ["SUNWcs", "entire"]
try:
self.tr_ips.execute(dry_run=DRY_RUN)
except Exception as err:
self.fail(str(err))
def test_uninstall(self):
'''Test that an IPS package can be uninstalled'''
self.tr_node.action = "install"
self.tr_node.contents = ["SUNWcs", "system/library/svm-rcm"]
self.tr_node2 = IPSSpec()
self.tr_node2.action = "uninstall"
self.tr_node2.contents = ["system/library/svm-rcm"]
self.soft_node.insert_children([self.tr_node2])
try:
self.tr_ips.execute(dry_run=DRY_RUN)
except Exception as err:
self.fail(str(err))
def test_purge_history(self):
'''Test that the history is purged'''
self.tr_node.purge_history = True
self.tr_node.action = "install"
self.tr_node.contents = ["SUNWcs"]
try:
self.tr_ips.execute(dry_run=DRY_RUN)
except Exception as err:
self.fail(str(err))
def test_image_type(self):
'''Test that image_type functionality succeeds'''
self.tr_ips = TransferIPS("IPS transfer", {"zonename": "zonename"})
self.ips_image.delete_children()
ips_im_type = ImType("partial", zone=True)
self.ips_image = Image(self.IPS_IMG_DIR, "create")
self.ips_image.insert_children([ips_im_type])
dst = Destination()
dst.insert_children([self.ips_image])
self.soft_node.delete_children()
self.soft_node.insert_children([self.tr_node, dst])
self.doc.delete_children()
self.doc.insert_children([self.soft_node])
try:
self.tr_ips.execute(dry_run=DRY_RUN)
except Exception as err:
self.fail(str(err))
def test_image_args(self):
'''Test that setting Args for the image works'''
image_args = Args(arg_dict={"force": True})
self.ips_image.insert_children([image_args])
try:
self.tr_ips.execute(dry_run=DRY_RUN)
except Exception as err:
self.fail(str(err))
def test_ssl_key_in_image_args(self):
'''Test that setting ssl_key in image_args produces an error'''
image_args = Args(arg_dict={"ssl_key": "aaa"})
self.ips_image.insert_children([image_args])
self.assertRaises(Exception, self.tr_ips.execute, dry_run=DRY_RUN)
def test_ssl_cert_in_image_args(self):
'''Test that setting ssl_cert in image_args produces an error'''
image_args = Args(arg_dict={"ssl_cert": "aaa"})
self.ips_image.insert_children([image_args])
self.assertRaises(Exception, self.tr_ips.execute, dry_run=DRY_RUN)
def test_install_args(self):
'''Test that setting Args for the install works'''
install_args = Args(arg_dict={"refresh_catalogs": False})
self.tr_node.insert_children([install_args])
self.tr_node.action = "install"
self.tr_node.contents = ["SUNWcs"]
try:
self.tr_ips.execute(dry_run=DRY_RUN)
except Exception as err:
self.fail(str(err))
def test_uninstall_args(self):
'''Test that setting Args for the uninstall works'''
uninstall_args = Args(arg_dict={"update_index": False})
self.tr_node.action = "install"
self.tr_node.contents = ["SUNWcs", "system/library/svm-rcm"]
self.tr_node2 = IPSSpec()
self.tr_node2.action = "uninstall"
self.tr_node2.contents = ["system/library/svm-rcm"]
self.tr_node2.insert_children([uninstall_args])
self.soft_node.insert_children([self.tr_node2])
try:
self.tr_ips.execute(dry_run=DRY_RUN)
except Exception as err:
self.fail(str(err))
def test_install_reject_noargs(self):
'''Test that an IPS package can be rejected'''
self.tr_node.action = "install"
self.tr_node.contents = ["solaris-large-server"]
self.tr_node.reject_list = ["slocate"]
self.tr_node2 = IPSSpec()
self.tr_node2.action = "install"
self.tr_node2.contents = ["system/library/svm-rcm"]
self.soft_node.insert_children([self.tr_node2])
try:
self.tr_ips.execute(dry_run=DRY_RUN)
except Exception as err:
self.fail(str(err))
def test_install_reject_with_args(self):
'''Test that an IPS package can be rejected with args'''
install_args = Args(arg_dict={"update_index": False})
self.tr_node.action = "install"
self.tr_node.reject_list = ["slocate"]
self.tr_node.contents = ["solaris-large-server"]
self.tr_node.insert_children([install_args])
self.tr_node2 = IPSSpec()
self.tr_node2.action = "install"
self.tr_node2.contents = ["system/library/svm-rcm"]
self.soft_node.insert_children([self.tr_node2])
try:
self.tr_ips.execute(dry_run=DRY_RUN)
except Exception as err:
self.fail(str(err))
def test_avoid_noargs(self):
'''Test that an IPS package can be avoided'''
self.tr_node.action = "avoid"
self.tr_node.contents = ["solaris-large-server"]
self.tr_node2 = IPSSpec()
self.tr_node2.action = "avoid"
self.tr_node2.contents = ["system/library/svm-rcm"]
self.soft_node.insert_children([self.tr_node2])
try:
self.tr_ips.execute(dry_run=DRY_RUN)
except Exception as err:
self.fail(str(err))
def test_avoid_with_args(self):
'''Test that an IPS package can be avoided with args'''
install_args = Args(arg_dict={"update_index": False})
self.tr_node.action = "avoid"
self.tr_node.contents = ["solaris-large-server"]
self.tr_node.insert_children([install_args])
self.tr_node2 = IPSSpec()
self.tr_node2.action = "avoid"
self.tr_node2.contents = ["system/library/svm-rcm"]
self.soft_node.insert_children([self.tr_node2])
try:
self.tr_ips.execute(dry_run=DRY_RUN)
except Exception as err:
self.fail(str(err))
def test_unavoid_noargs(self):
'''Test that an IPS package can be unavoided'''
self.tr_node.action = "unavoid"
self.tr_node.contents = ["solaris-large-server"]
self.tr_node2 = IPSSpec()
self.tr_node2.action = "unavoid"
self.tr_node2.contents = ["system/library/svm-rcm"]
self.soft_node.insert_children([self.tr_node2])
try:
self.tr_ips.execute(dry_run=DRY_RUN)
except Exception as err:
self.fail(str(err))
def test_unavoid_with_args(self):
'''Test that an IPS package can be rejected with args'''
install_args = Args(arg_dict={"update_index": False})
self.tr_node.action = "unavoid"
self.tr_node.contents = ["solaris-large-server"]
self.tr_node.insert_children([install_args])
self.tr_node2 = IPSSpec()
self.tr_node2.action = "unavoid"
self.tr_node2.contents = ["system/library/svm-rcm"]
self.soft_node.insert_children([self.tr_node2])
try:
self.tr_ips.execute(dry_run=DRY_RUN)
except Exception as err:
self.fail(str(err))
def test_default_publisher(self):
'''Test that using the default publisher succeeds'''
src = Source()
pub = Publisher()
origin = Origin("http://ipkg.sfbay.sun.com/release/")
pub.insert_children([origin])
src.insert_children([pub])
self.soft_node.insert_children([src])
try:
self.tr_ips.execute(dry_run=DRY_RUN)
except Exception as err:
self.fail(str(err))
def test_multiple_sources(self):
'''Test that setting multiple sources succeeds'''
src = Source()
pub = Publisher("opensolaris.org")
origin = Origin("http://ipkg.sfbay.sun.com/release/")
pub2 = Publisher("contrib.opensolaris.org")
origin2 = Origin("http://ipkg.sfbay.sun.com/contrib/")
pub3 = Publisher("extra")
origin3 = Origin("http://ipkg.sfbay.sun.com/extra/")
pub.insert_children([origin])
pub2.insert_children([origin2])
pub3.insert_children([origin3])
src.insert_children([pub, pub2, pub3])
self.soft_node.insert_children([src])
try:
self.tr_ips.execute(dry_run=DRY_RUN)
except Exception as err:
self.fail(str(err))
def test_source_addition(self):
'''Test that adding additional sources succeeds'''
src = Source()
pub = Publisher("opensolaris.org")
origin = Origin("http://ipkg.sfbay.sun.com/dev/")
pub.insert_children([origin])
src.insert_children([pub])
self.soft_node.insert_children([src])
try:
self.tr_ips.execute(dry_run=DRY_RUN)
except Exception as err:
self.fail(str(err))
# Now add another publisher to the repo
self.ips_image.action = "update"
pub2 = Publisher("extra")
origin2 = Origin("http://ipkg.sfbay.sun.com/extra/")
pub2.insert_children([origin2])
src.insert_children([pub2])
try:
self.tr_ips.execute(dry_run=DRY_RUN)
except Exception as err:
self.fail(str(err))
def test_source_omit_name_first_success(self):
'''Test that omitting name is allowed for first publisher'''
src = Source()
pub = Publisher("")
origin = Origin("http://ipkg.sfbay.sun.com/dev/")
pub.insert_children([origin])
src.insert_children([pub])
self.soft_node.insert_children([src])
try:
self.tr_ips.execute(dry_run=DRY_RUN)
except Exception as err:
self.fail(str(err))
def test_source_omit_additional_publ_name_fails_1(self):
'''Test that adding additional sources omitting name fails'''
src = Source()
pub = Publisher("")
origin = Origin("http://ipkg.sfbay.sun.com/dev/")
pub.insert_children([origin])
src.insert_children([pub])
self.soft_node.insert_children([src])
try:
self.tr_ips.execute(dry_run=DRY_RUN)
except Exception as err:
self.fail(str(err))
# Now add another publisher to the repo
self.ips_image.action = "update"
pub2 = Publisher("")
origin2 = Origin("http://ipkg.sfbay.sun.com/extra/")
pub2.insert_children([origin2])
src.insert_children([pub2])
try:
self.tr_ips.execute(dry_run=DRY_RUN)
self.fail("Shouldn't succeed omitting name of second publisher")
except ValueError as err:
pass
except Exception as err:
self.fail(str(err))
def test_source_omit_additional_publ_name_fails_2(self):
'''Test that adding additional sources omitting name fails'''
src = Source()
pub = Publisher("")
origin = Origin("http://ipkg.sfbay.sun.com/dev/")
pub.insert_children([origin])
src.insert_children([pub])
self.soft_node.insert_children([src])
try:
self.tr_ips.execute(dry_run=DRY_RUN)
except Exception as err:
self.fail(str(err))
# Now add another publisher to the repo
self.ips_image.action = "update"
pub2 = Publisher("extra")
origin2 = Origin("http://ipkg.sfbay.sun.com/extra/")
pub2.insert_children([origin2])
src.insert_children([pub2])
try:
self.tr_ips.execute(dry_run=DRY_RUN)
except Exception as err:
self.fail(str(err))
# Now add another publisher to the repo
self.ips_image.action = "update"
pub3 = Publisher("")
origin3 = Origin("http://ipkg.sfbay.sun.com/an-other/")
pub3.insert_children([origin3])
src.insert_children([pub3])
try:
self.tr_ips.execute(dry_run=DRY_RUN)
self.fail("Shouldn't succeed omitting name of third publisher")
except ValueError as err:
pass
except Exception as err:
self.fail(str(err))
def test_source_replacement(self):
'''Test that replacing a source succeeds'''
# Setup an IPS image
src = Source()
pub = Publisher("opensolaris.org")
origin = Origin("http://ipkg.sfbay.sun.com/release/")
pub2 = Publisher("extra")
origin2 = Origin("http://ipkg.sfbay.sun.com/extra/")
pub2.insert_children([origin2])
pub.insert_children([origin])
src.insert_children([pub, pub2])
self.soft_node.insert_children([src])
try:
self.tr_ips.execute(dry_run=DRY_RUN)
except Exception as err:
self.fail(str(err))
# Create a new transaction with a differnt publisher/origin.
# Specify to update the image created above.
self.soft_node = Software("IPS post install")
self.doc.insert_children([self.soft_node])
src = Source()
pub = Publisher("opensolaris.org")
origin = Origin("http://ipkg.sfbay.sun.com/dev/")
pub.insert_children([origin])
src.insert_children([pub])
dst = Destination()
self.ips_image = Image(self.IPS_IMG_DIR, "update")
dst.insert_children([self.ips_image])
self.soft_node.insert_children([dst, src])
try:
self.tr_ips.execute(dry_run=DRY_RUN)
except Exception as err:
self.fail(str(err))
def test_mirrors(self):
'''Test creating mirrors succeeds'''
src = Source()
pub = Publisher("opensolaris.org")
origin = Origin("http://ipkg.sfbay.sun.com/release/")
mirror = Mirror("http://ipkg.central.sun.com:8000/")
pub.insert_children([origin, mirror])
src.insert_children([pub])
self.soft_node.insert_children([src])
try:
self.tr_ips.execute(dry_run=DRY_RUN)
except Exception as err:
self.fail(str(err))
def test_set_property(self):
'''Test that setting properties succeeds'''
src = Source()
pub = Publisher("opensolaris.org")
origin = Origin("http://ipkg.sfbay.sun.com/release/")
pub2 = Publisher("contrib.opensolaris.org")
origin2 = Origin("http://ipkg.sfbay.sun.com/contrib/")
pub3 = Publisher("extra")
origin3 = Origin("http://ipkg.sfbay.sun.com/extra/")
pub.insert_children([origin])
pub2.insert_children([origin2])
pub3.insert_children([origin3])
src.insert_children([pub, pub2, pub3])
self.soft_node.insert_children([src])
prop = Property("display-copyrights", 'False')
prop2 = Property("preferred-publisher", "extra")
self.ips_image.insert_children([prop, prop2])
try:
self.tr_ips.execute(dry_run=DRY_RUN)
except Exception as err:
self.fail(str(err))
def test_set_create_facets(self):
'''Test that creating facets succeeds'''
src = Source()
pub = Publisher("opensolaris.org")
origin = Origin("http://ipkg.sfbay.sun.com/release/")
pub.insert_children([origin])
src.insert_children([pub])
self.soft_node.insert_children([src])
facet = Facet("facet.doc", 'True')
self.ips_image.insert_children([facet])
try:
self.tr_ips.execute(dry_run=DRY_RUN)
except Exception as err:
self.fail(str(err))
def test_set_invalid_facets(self):
'''Ensure an error is raised for an invalid facet'''
src = Source()
pub = Publisher("opensolaris.org")
origin = Origin("http://ipkg.sfbay.sun.com/release/")
pub.insert_children([origin])
src.insert_children([pub])
self.soft_node.insert_children([src])
facet = Facet("doc", 'True')
self.ips_image.insert_children([facet])
self.assertRaises(Exception, self.tr_ips.execute)
def test_progress_estimate(self):
'''Test that progress estimate succeeds'''
self.tr_node.action = "install"
self.tr_node.contents = [
"SUNWcs", "SUNWcsd", "entire", "SUNWmd", "babel_install"
]
try:
estimate = self.tr_ips.get_progress_estimate()
except Exception as err:
self.fail(str(err))
self.assertTrue(estimate == self.tr_ips.DEFAULT_PROG_EST * \
(len(self.tr_node.contents) / self.tr_ips.DEFAULT_PKG_NUM))
def test_invalid_args(self):
'''Ensure error raised when repo components are set as args'''
image_args = Args(arg_dict={"prefix": "prefix string"})
self.ips_image.insert_children([image_args])
self.assertRaises(ValueError, self.tr_ips.execute, dry_run=DRY_RUN)
# Test repo_uri fails
self.ips_image.delete_children()
image_args = Args(arg_dict={"repo_uri": "url string"})
self.ips_image.insert_children([image_args])
self.assertRaises(Exception, self.tr_ips.execute, dry_run=DRY_RUN)
# Test origins fails
self.ips_image.delete_children()
image_args = Args(arg_dict={"origins": "origin string"})
self.ips_image.insert_children([image_args])
self.assertRaises(Exception, self.tr_ips.execute, dry_run=DRY_RUN)
# Test mirrors fails
self.ips_image.delete_children()
image_args = Args(arg_dict={"mirrors": "mirror string"})
self.ips_image.insert_children([image_args])
self.assertRaises(Exception, self.tr_ips.execute, dry_run=DRY_RUN)
def test_checkpoint_soft_node_match(self):
'''The checkpoint and software node match'''
try:
tr_ips = TransferIPS("IPS transfer")
except Exception as err:
self.fail(str(err))
def do_ti_install(install_data, screen, update_status_func):
'''Installation engine for text installer.
Raises InstallationError for any error occurred during install.
'''
sysconfig_profile = sysconfig.profile.from_engine()
#
# The following information is needed for installation.
# Make sure they are provided before even starting
#
# timezone
timezone = sysconfig_profile.system.tz_timezone
LOGGER.debug("time zone: %s", timezone)
# Validate the value specified for timezone
if not tz_isvalid(timezone):
LOGGER.error("Timezone value specified (%s) is not valid", timezone)
raise ti_utils.InstallationError
# Compute the time to set.
install_time = datetime.datetime.now() + \
sysconfig_profile.system.time_offset
# Set the system time to the time specified by the user.
cmd = ["/usr/bin/date", install_time.strftime("%m%d%H%M%y")]
Popen.check_call(cmd,
stdout=Popen.STORE,
stderr=Popen.STORE,
logger=LOGGER)
hostname = sysconfig_profile.system.hostname
LOGGER.debug("hostname: " + hostname)
engine = InstallEngine.get_instance()
doc = engine.doc
# look to see if the target disk has 'whole_disk' set
disk = get_desired_target_disk(doc)
if disk.whole_disk:
inst_device_size = disk.disk_prop.dev_size
else:
# look for a GPT partition first
gpt_partition = get_solaris_gpt_partition(doc)
if gpt_partition is None:
solaris_slice = get_solaris_slice(doc)
if solaris_slice is None:
raise ti_utils.InstallationError("Unable to find solaris "
"slice")
inst_device_size = solaris_slice.size
else:
inst_device_size = gpt_partition.size
LOGGER.info("Installation Device Size: %s", inst_device_size)
minimum_size = screen.tc.minimum_target_size
LOGGER.info("Minimum required size: %s", minimum_size)
if inst_device_size < minimum_size:
LOGGER.error("Size of device specified for installation "
"is too small")
LOGGER.error("Size of install device: %s", inst_device_size)
LOGGER.error("Minimum required size: %s", minimum_size)
raise ti_utils.InstallationError
recommended_size = screen.tc.recommended_target_size
LOGGER.info("Recommended size: %s", recommended_size)
if inst_device_size < recommended_size:
# Warn users that their install target size is not optimal
# Just log the warning, but continue with the installation.
LOGGER.warning("Size of device specified for installation is "
"not optimal")
LOGGER.warning("Size of install device: %s", inst_device_size)
LOGGER.warning("Recommended size: %s", recommended_size)
(swap_type, swap_size, dump_type, dump_size) = \
screen.tc.calc_swap_dump_size(minimum_size, inst_device_size,
swap_included=True)
desired_zpool = get_desired_target_zpool(doc)
if swap_type == TargetController.SWAP_DUMP_ZVOL:
desired_zpool.add_zvol("swap",
swap_size.get(Size.mb_units),
Size.mb_units,
use="swap")
if dump_type == TargetController.SWAP_DUMP_ZVOL:
desired_zpool.add_zvol("dump",
dump_size.get(Size.mb_units),
Size.mb_units,
use="dump",
create_failure_ok=True)
LOGGER.info("Swap type: %s", swap_type)
LOGGER.info("Swap size: %s", swap_size)
LOGGER.info("Dump type: %s", dump_type)
LOGGER.info("Dump size: %s", dump_size)
# Specify for the shared datasets <root_pool>/export and
# <root_pool>/export/home be created. We will specify
# a mountpoint for <root_pool>/export dataset.
# We must not specify a mountpoint for <root_pool>/export/home.
# It should inherit the mountpoint from <root_pool>/export.
desired_zpool.add_filesystem("export", mountpoint="/export")
desired_zpool.add_filesystem("export/home")
# Add the list of packages to be removed after the install to the DOC
pkg_remove_list = [
'pkg:/system/install/media/internal',
'pkg:/system/install/text-install'
]
pkg_spec = IPSSpec(action=IPSSpec.UNINSTALL, contents=pkg_remove_list)
pkg_rm_node = Software(CLEANUP_CPIO_INSTALL, type="IPS")
pkg_rm_node.insert_children(pkg_spec)
doc.volatile.insert_children(pkg_rm_node)
# execute the prepare transfer checkpoint. This checkpoint must be
# executed by itself, before executing any of the transfer related
# checkpoints. The transfer checkpoints requires data setup from the
# prepare transfer checkpoint.
status, failed_cp = engine.execute_checkpoints(
start_from=TRANSFER_PREP, pause_before=VARSHARE_DATASET)
if status != InstallEngine.EXEC_SUCCESS:
err_data = errsvc.get_errors_by_mod_id(TRANSFER_PREP)[0]
LOGGER.error("%s checkpoint failed" % TRANSFER_PREP)
err = err_data.error_data[liberrsvc.ES_DATA_EXCEPTION]
LOGGER.error(err)
raise ti_utils.InstallationError("Failed to execute checkpoint "
"%s", TRANSFER_PREP)
global INSTALL_STATUS
INSTALL_STATUS = InstallStatus(screen, update_status_func)
LOGGER.debug("Executing rest of checkpoints")
engine.execute_checkpoints(callback=exec_callback,
dry_run=install_data.no_install_mode)
INSTALL_STATUS.report_status()
if INSTALL_STATUS.exec_status is InstallEngine.EXEC_CANCELED:
raise ti_utils.InstallationCanceledError("User selected cancel.")
if INSTALL_STATUS.exec_status is InstallEngine.EXEC_FAILED:
raise ti_utils.InstallationError("Failed executing checkpoints")
if install_data.no_install_mode:
# all subsequent code depends on the install target being setup
return
new_be = get_desired_target_be(doc)
install_mountpoint = new_be.mountpoint
# If swap was created, add appropriate entry to <target>/etc/vfstab
LOGGER.debug("install mountpoint: %s", install_mountpoint)
LOGGER.debug("new_be: %s", new_be)
screen.tc.setup_vfstab_for_swap(ROOT_POOL, install_mountpoint)
post_install_cleanup(install_data)
def test_info(self):
'''Test that the arguments get into the node correctly'''
# just dst, need to check default repo
soft_node = Software("transfer test 1")
tr_node = IPSSpec()
soft_node.insert_children([tr_node])
self.doc.insert_children([soft_node])
dst = Destination()
ips_image = Image("/rpool/dc", "create")
self.img_type = ImType("full")
ips_image.insert_children([self.img_type])
dst.insert_children([ips_image])
src = Source()
pub = Publisher()
origin = Origin("http://pkg.syneto.eu")
pub.insert_children([origin])
src.insert_children([pub])
# first check src and dst
soft_node.insert_children([dst, src, soft_node])
soft_list = self.doc.get_children("transfer test 1", Software)
for soft in soft_list:
tr_list = soft.get_children(class_type=IPSSpec)
for tr in tr_list:
src_list = soft.get_children("source", Source)
self.assertEqual(len(src_list), 1)
pub = src_list[0].get_children("publisher", Publisher)
origin = pub[0].get_children("origin", Origin)
self.assertEqual(origin[0].origin, "http://pkg.syneto.eu")
dst_list = soft.get_children("destination", Destination)
self.assertEqual(len(dst_list), 1)
image = dst_list[0].get_children("image", Image)
self.assertEqual(len(image), 1)
img_type = image[0].get_children("img_type", ImType)
self.assertEqual(len(img_type), 1)
self.assertEqual(image[0].img_root, "/rpool/dc")
self.assertEqual(image[0].action, "create")
self.assertEqual(img_type[0].completeness, "full")
self.assertEqual(img_type[0].zone, False)
self.assertEqual(tr.action, None)
self.assertEqual(tr.contents, None)
self.assertEqual(tr.app_callback, None)
self.assertEqual(tr.purge_history, False)
# pkg install list is set
tr_node.action = "install"
tr_node.contents = ["SUNWcs", "SUNWcsr"]
soft_list = self.doc.get_children("transfer test 1", Software)
for soft in soft_list:
tr_list = soft.get_children(class_type=IPSSpec)
for tr in tr_list:
src_list = soft.get_children("source", Source)
self.assertEqual(len(src_list), 1)
pub = src_list[0].get_children("publisher", Publisher)
origin = pub[0].get_children("origin", Origin)
self.assertEqual(origin[0].origin, "http://pkg.syneto.eu")
dst_list = soft.get_children("destination", Destination)
self.assertEqual(len(dst_list), 1)
image = dst_list[0].get_children("image", Image)
self.assertEqual(len(image), 1)
img_type = image[0].get_children("img_type", ImType)
self.assertEqual(len(img_type), 1)
self.assertEqual(image[0].img_root, "/rpool/dc")
self.assertEqual(image[0].action, "create")
self.assertEqual(img_type[0].completeness, "full")
self.assertEqual(img_type[0].zone, False)
self.assertEqual(tr.contents, ["SUNWcs", "SUNWcsr"])
self.assertEqual(tr.action, "install")
self.assertEqual(tr.purge_history, False)
self.assertEqual(tr.app_callback, None)
# pkg uninstall list is set
tr_node.action = "uninstall"
tr_node.contents = ["SUNWcs"]
soft_list = self.doc.get_children("transfer test 1", Software)
for soft in soft_list:
tr_list = soft.get_children(class_type=IPSSpec)
for tr in tr_list:
src_list = soft.get_children("source", Source)
self.assertEqual(len(src_list), 1)
pub = src_list[0].get_children("publisher", Publisher)
origin = pub[0].get_children("origin", Origin)
self.assertEqual(origin[0].origin, "http://pkg.syneto.eu")
dst_list = soft.get_children("destination", Destination)
self.assertEqual(len(dst_list), 1)
image = dst_list[0].get_children("image", Image)
self.assertEqual(len(image), 1)
img_type = image[0].get_children("img_type", ImType)
self.assertEqual(len(img_type), 1)
self.assertEqual(image[0].img_root, "/rpool/dc")
self.assertEqual(image[0].action, "create")
self.assertEqual(img_type[0].completeness, "full")
self.assertEqual(img_type[0].zone, False)
self.assertEqual(tr.action, "uninstall")
self.assertEqual(tr.contents, ["SUNWcs"])
self.assertEqual(tr.purge_history, False)
self.assertEqual(tr.app_callback, None)
# purge history is set to true
tr_node.purge_history = True
soft_list = self.doc.get_children("transfer test 1", Software)
for soft in soft_list:
tr_list = soft.get_children(class_type=IPSSpec)
for tr in tr_list:
src_list = soft.get_children("source", Source)
self.assertEqual(len(src_list), 1)
pub = src_list[0].get_children("publisher", Publisher)
origin = pub[0].get_children("origin", Origin)
self.assertEqual(origin[0].origin, "http://pkg.syneto.eu")
dst_list = soft.get_children("destination", Destination)
self.assertEqual(len(dst_list), 1)
image = dst_list[0].get_children("image", Image)
self.assertEqual(len(image), 1)
img_type = image[0].get_children("img_type", ImType)
self.assertEqual(len(img_type), 1)
self.assertEqual(image[0].img_root, "/rpool/dc")
self.assertEqual(image[0].action, "create")
self.assertEqual(img_type[0].completeness, "full")
self.assertEqual(img_type[0].zone, False)
self.assertEqual(tr.action, "uninstall")
self.assertEqual(tr.contents, ["SUNWcs"])
self.assertEqual(tr.purge_history, True)
# is zone is set to True
self.img_type.zone = True
soft_list = self.doc.get_children("transfer test 1", Software)
for soft in soft_list:
tr_list = soft.get_children(class_type=IPSSpec)
for tr in tr_list:
src_list = soft.get_children("source", Source)
self.assertEqual(len(src_list), 1)
pub = src_list[0].get_children("publisher", Publisher)
origin = pub[0].get_children("origin", Origin)
self.assertEqual(origin[0].origin, "http://pkg.syneto.eu")
dst_list = soft.get_children("destination", Destination)
self.assertEqual(len(dst_list), 1)
image = dst_list[0].get_children("image", Image)
self.assertEqual(len(image), 1)
img_type = image[0].get_children("img_type", ImType)
self.assertEqual(len(img_type), 1)
self.assertEqual(image[0].img_root, "/rpool/dc")
self.assertEqual(image[0].action, "create")
self.assertEqual(img_type[0].completeness, "full")
self.assertEqual(img_type[0].zone, True)
self.assertEqual(tr.action, "uninstall")
self.assertEqual(tr.contents, ["SUNWcs"])
self.assertEqual(tr.purge_history, True)
# completeness is set to IMG_TYPE_PARTIAL
self.img_type.completeness = IMG_TYPE_PARTIAL
soft_list = self.doc.get_children("transfer test 1", Software)
for soft in soft_list:
tr_list = soft.get_children(class_type=IPSSpec)
for tr in tr_list:
src_list = soft.get_children("source", Source)
self.assertEqual(len(src_list), 1)
pub = src_list[0].get_children("publisher", Publisher)
origin = pub[0].get_children("origin", Origin)
self.assertEqual(origin[0].origin, "http://pkg.syneto.eu")
dst_list = soft.get_children("destination", Destination)
self.assertEqual(len(dst_list), 1)
image = dst_list[0].get_children("image", Image)
self.assertEqual(len(image), 1)
img_type = image[0].get_children("img_type", ImType)
self.assertEqual(len(img_type), 1)
self.assertEqual(image[0].img_root, "/rpool/dc")
self.assertEqual(image[0].action, "create")
self.assertEqual(img_type[0].completeness, IMG_TYPE_PARTIAL)
self.assertEqual(img_type[0].zone, True)
self.assertEqual(tr.action, "uninstall")
self.assertEqual(tr.contents, ["SUNWcs"])
self.assertEqual(tr.purge_history, True)
