)
continue
elif src_package.domain.path == src_domain.path:
# same domain
utils.print_verbose(
"publishing package (%s) from src domain (%s)" %
(src_package_name, src_domain.path))
dst_package = Package(dst_domain, src_package_name)
else:
# other domain
utils.print_verbose(
"publishing package (%s) from alt src domain (%s)"
% (src_package_name, src_package.domain.path))
dst_package = src_package
if dst_domain.is_published(src_package_name,
publish_platform):
if republish:
dst_domain.unpublish_package(
dst_package, published_platform)
else:
utils.print_warning(
"warning: skipping published package (%s)" %
(src_package_name, ))
continue
dst_domain.publish_package(dst_package, publish_platform)
# set frozen?
if src_domain.is_frozen():
utils.print_verbose("freezing domain (%s)" % dst_domain_home)
dst_domain.freeze()
except SystemExit:
raise Exception()
except SystemExit:
raise
except:
if globls.debug:
traceback.print_exc()
utils.print_exit("error: bad/missing argument(s)")
if not package_name:
utils.print_exit("error: missing package name")
try:
domain = Domain(domain_home)
if not domain.is_compatible():
utils.print_exit(MSG_INCOMPATIBLE_DOMAIN)
pkg = Package(domain, package_name)
if domain.is_published(package_name):
utils.print_exit("error: package is published")
if not pkg.exists() and not domain.is_installed(package_name):
utils.print_exit("error: package is not installed")
pkg.uninstall()
except SystemExit:
raise
except utils.SSMExitException, detail:
utils.print_exit(detail)
except Exception, detail:
if globls.debug:
traceback.print_exc()
utils.print_exit("error: operation failed")
sys.exit(0)
def get_output_records(domain_home, publish_platform, format_fields):
"""Produce records for a domain according to the selected
format_fields.
"""
records = []
try:
if os.path.isdir(domain_home):
domain = Domain(domain_home)
#published_platforms = domain.get_published_platforms()
published_packages = domain.get_packages_with_state(
"published", publish_platform)
# generate record for each package
for package_name in domain.get_package_names(package_name_pattern):
dom_package = Package(domain, package_name)
#if package_name in published_packages:
#platforms = published_platforms
#else:
#platforms = [""]
# for each publish platform
#for publish_platform in platforms:
#if publish_platform != "" \
#and not domain.is_published(package_name, publish_platform):
## must be installed or published
#continue
if package_name.endswith(
"_" + publish_platform) or domain.is_published(
package_name, publish_platform):
state = domain.get_package_state(package_name,
publish_platform)
pub_package = published_packages.get(package_name)
package = pub_package or dom_package
publish_timestamp = pub_package and utils.get_path_timestamp(
pub_package.path)
timestamp = install_timestamp = utils.get_path_timestamp(
package.path)
# generate record
record = []
for fname in format_fields:
if fname in ["title"]:
# load only if necessary
control_map = package and package.get_control(
) or {}
if fname.startswith("_"):
record.append("")
elif fname in ["domain", "publish_domain"]:
record.append(domain.path)
elif fname in ["domain_owner", "publish_domain_owner"]:
record.append(domain.get_owner())
elif fname in ["domain_state", "publish_domain_state"]:
record.append(domain.is_frozen() and "F" or "")
elif fname == "domains":
record.append("%s (%s)" %
(domain.path, package.domain.path))
elif fname == "install_domain":
record.append(package.domain.path)
elif fname == "install_domain_owner":
record.append(package.domain.get_owner())
elif fname == "install_domain_state":
record.append(package.domain.is_frozen() and "F"
or "")
elif fname == "install_timestamp":
record.append(install_timestamp)
elif fname == "name":
record.append(package_name)
elif fname == "name_and_publish_platform":
if not publish_platform or package_name.endswith(
"_" + publish_platform):
record.append(package_name)
else:
record.append("%s (%s)" %
(package_name, publish_platform))
elif fname == "publish_platform":
record.append(publish_platform or "")
elif fname == "publish_timestamp":
record.append(publish_timestamp or "")
elif fname == "state":
record.append(state)
elif fname == "title":
record.append(control_map.get("title", "***"))
else:
record.append("***")
records.append(record)
except:
if globls.debug:
traceback.print_exc()
raise
return records
raise Exception()
except SystemExit:
raise
except:
if globls.debug:
traceback.print_exc()
utils.print_exit("error: bad/missing argument(s)")
if not package_name:
utils.print_exit("error: missing package name")
try:
domain = Domain(domain_home)
if not domain.is_compatible():
utils.print_exit(MSG_INCOMPATIBLE_DOMAIN)
package = Package(domain, package_name)
if publish_platform == None:
_, _, publish_platform = package.name.split("_", 2)
if not domain.is_published(package_name, publish_platform) and not globls.force:
utils.print_exit("error: package not published")
domain.unpublish_package(package, publish_platform)
except SystemExit:
raise
except utils.SSMExitException, detail:
utils.print_exit(detail)
except:
if globls.debug:
traceback.print_exc()
utils.print_exit("error: operation failed")
sys.exit(0)
if not domain.is_compatible():
utils.print_exit(MSG_INCOMPATIBLE_DOMAIN)
if publish_home == None:
publish_home = domain_home
publish_domain = Domain(publish_home)
if not publish_domain.is_domain():
utils.print_exit("error: cannot find domain (%s)" % publish_domain)
package = Package(domain, package_name)
publish_platform = publish_platform or package.platform
# check for package
if not package.domain.is_installed(package_name):
utils.print_exit("error: cannot find package (%s)" % package_name)
# unpublish named package if necessary
if publish_domain.is_published(package_name, publish_platform):
if skip_on_published:
utils.print_exit("skipping published package", 0)
if not globls.force and not globls.auto_yes:
if utils.prompt("unpublish current package (y/n)?").lower() not in ["y"]:
utils.print_exit("operation aborted")
publish_domain.unpublish_package(package, publish_platform)
# unpublish "similar" package
for pp_path in publish_domain.get_published(publish_platform):
pp_name = os.path.basename(pp_path)
if package.is_similar(pp_name):
publish_domain.unpublish_package(Package(domain, pp_name), publish_platform)
# ready to publish
publish_domain.publish_package(package, publish_platform)