def _create_version(self):
new_version = self.ptask.next_version_number
location_code = current_location_code()
try:
self._new_ptask_version = PTaskVersion.create(
current_username(),
"in progress...".format(n=new_version),
location_code,
ptask_spec=self.ptask.spec,
number=new_version,
parent_spec=self.source_version.spec,
)
except PTaskVersionError as e:
raise ActionError("Failed to create ptask version: " + str(e))
else:
print "\nNew version successfully created in the database."
# ---- provision a version directory in the ptask area
try:
self.ptask.area.provision(
self.ptask.area.dir(version=new_version, verify=False)
)
except PTaskAreaError as e:
raise ActionError("Unable to provision version directory.")
else:
print "\nSuccessfully provisioned directory for version: " + \
str(new_version)
def version(self, version_number):
from dpa.ptask.version import PTaskVersion, PTaskVersionError
try:
versions = PTaskVersion.list(
ptask=self.spec,
number=int(version_number),
)
except PTaskVersionError:
return None
else:
if len(versions) != 1:
return None
else:
return versions[0]
def version(self, version_number):
from dpa.ptask.version import PTaskVersion, PTaskVersionError
try:
versions = PTaskVersion.list(
ptask=self.spec,
number=int(version_number),
)
except PTaskVersionError:
return None
else:
if len(versions) != 1:
return None
else:
return versions[0]
def validate(self):
# current ptask/version
try:
area = PTaskArea.current()
self._current_ptask = PTask.get(area.spec)
self._current_ptask_version = self._current_ptask.latest_version
except PTaskError:
raise ActionError("Unable to find ptask: " + str(self._ptask))
# source ptask
if not isinstance(self._ptask, PTask):
try:
cur_spec = PTaskArea.current().spec
full_spec = PTaskSpec.get(self._ptask, relative_to=cur_spec)
self._ptask = PTask.get(full_spec)
except PTaskError:
raise ActionError("Unable to find ptask: " + str(self._ptask))
# source ptask version
if isinstance(self._version, PTaskVersion):
pass
elif self._version:
matches = PTaskVersion.list(
ptask=self._ptask.spec, number=self._version
)
if len(matches) != 1:
raise ActionError(
"Unable to find ptask '{p}' at version '{v}'".format(
p=self._ptask.spec, v=self._version
)
)
else:
self._version = matches[0]
else:
self._version = self._ptask.latest_version
# source subs
self._match_str = self._match_str.replace("%", ".*")
all_subs = self._version.subscriptions
self._subs_to_source = []
for sub in all_subs:
if re.search(self._match_str, sub.product_version_spec):
self._subs_to_source.append(sub)
if not self._subs_to_source:
raise ActionAborted("No subscriptions to source.")
def validate(self):
# current ptask/version
try:
area = PTaskArea.current()
self._current_ptask = PTask.get(area.spec)
self._current_ptask_version = self._current_ptask.latest_version
except PTaskError:
raise ActionError("Unable to find ptask: " + str(self._ptask))
# source ptask
if not isinstance(self._ptask, PTask):
try:
cur_spec = PTaskArea.current().spec
full_spec = PTaskSpec.get(self._ptask, relative_to=cur_spec)
self._ptask = PTask.get(full_spec)
except PTaskError:
raise ActionError("Unable to find ptask: " + str(self._ptask))
# source ptask version
if isinstance(self._version, PTaskVersion):
pass
elif self._version:
matches = PTaskVersion.list(ptask=self._ptask.spec,
number=self._version)
if len(matches) != 1:
raise ActionError(
"Unable to find ptask '{p}' at version '{v}'".format(
p=self._ptask.spec, v=self._version))
else:
self._version = matches[0]
else:
self._version = self._ptask.latest_version
# source subs
self._match_str = self._match_str.replace("%", ".*")
all_subs = self._version.subscriptions
self._subs_to_source = []
for sub in all_subs:
if re.search(self._match_str, sub.product_version_spec):
self._subs_to_source.append(sub)
if not self._subs_to_source:
raise ActionAborted("No subscriptions to source.")
def _create_ptask_version(self):
version = 1
location_code = current_location_code()
if self.ptask.versions:
if not self.force:
raise ActionError("PTask version already exists.")
else:
try:
ptask_version = PTaskVersion.create(
self.creator,
"In progress...",
location_code,
ptask_spec=self.ptask.spec,
number=version,
)
except PTaskVersionError as e:
raise ActionError("Failed to create ptask version: " + str(e))
# provision a version directory in the ptask area
self.ptask_area.provision(
self.ptask_area.dir(version=version, verify=False))
def _create_ptask_version(self):
version = 1
location_code = current_location_code()
if self.ptask.versions:
if not self.force:
raise ActionError("PTask version already exists.")
else:
try:
ptask_version = PTaskVersion.create(
self.creator,
"In progress...",
location_code,
ptask_spec=self.ptask.spec,
number=version,
)
except PTaskVersionError as e:
raise ActionError("Failed to create ptask version: " + str(e))
# provision a version directory in the ptask area
self.ptask_area.provision(
self.ptask_area.dir(version=version, verify=False)
)
def versions(self):
""":returns: PTaskVersions created for this ptask."""
# import here to avoid circular dependencies
from dpa.ptask.version import PTaskVersion
return PTaskVersion.list(ptask=self.spec)
def versions(self):
""":returns: PTaskVersions created for this ptask."""
# import here to avoid circular dependencies
from dpa.ptask.version import PTaskVersion
return PTaskVersion.list(ptask=self.spec)
def validate(self):
# validate the ptask
if not isinstance(self._ptask, PTask):
try:
cur_spec = PTaskArea.current().spec
full_spec = PTaskSpec.get(self._ptask, relative_to=cur_spec)
self._ptask = PTask.get(full_spec)
except PTaskError:
raise ActionError("Could not determine ptask from: {p}".format(
p=self._ptask))
# find the version of the ptask to update
if isinstance(self._ptask_version, PTaskVersion):
if not self._ptask_version.ptask_spec == self._ptask_spec:
raise ActionError(
"Supplied ptask version doesn't match supplied ptask.")
elif self._ptask_version:
matches = PTaskVersion.list(
ptask=self._ptask.spec, number=self._ptask_version
)
if len(matches) != 1:
raise ActionError(
"Unable to find ptask '{p}' at version '{v}'".format(
p=self._ptask.spec, v=self._ptask_version
)
)
else:
self._ptask_version = matches[0]
else:
self._ptask_version = self._ptask.latest_version
# XXX rule
# don't allow if ptask_version already has published products
if self._ptask_version.published:
raise ActionError(
"Subscriptions can not be modified." + \
"Version {v} of {p} has published products.".format(
v=self._ptask_version.number_padded,
p=self._ptask.spec
))
# XXX
subs = []
# valdiate the subscriptions to update
if self._subs:
# get explicit subs
for sub in self._subs:
if isinstance(sub, ProductSubscription):
subs_to_udpate.append(sub)
continue
try:
sub = int(sub)
except:
raise ActionError("Could not determine sub from: {s}".\
format(s=sub))
else:
matches = ProductSubscription.list(id=sub)
if len(matches) != 1:
raise ActionError("Unable to identify sub for id: " + \
str(sub))
else:
subs.append(matches[0])
else:
# all subs for ptask version
subs.extend(self._ptask_version.subscriptions)
self._subs = subs
update_map = defaultdict(dict)
for sub in subs:
sub_product_ver = sub.product_version
update_map[sub.id]['old'] = sub_product_ver
if sub.locked:
update_map[sub.id]['new'] = None
update_map[sub.id]['note'] = 'Subscription locked'
continue
if sub_product_ver.is_official:
update_map[sub.id]['new'] = None
update_map[sub.id]['note'] = 'Already subscribed to official'
continue
sub_product = sub_product_ver.product
official_ver = sub_product.official_version
if official_ver and official_ver.number > sub_product_ver.number:
update_map[sub.id]['new'] = official_ver
update_map[sub.id]['note'] = 'Official version'
continue
if sub.product_version.product.ptask.spec == self.ptask.spec:
all_vers = [v for v in sub_product.versions]
else:
all_vers = [v for v in sub_product.versions if v.published]
all_vers.sort(key=lambda v: v.number_padded)
if all_vers:
latest = all_vers[-1]
if latest.number > sub_product_ver.number:
update_map[sub.id]['new'] = latest
if latest.published:
update_map[sub.id]['note'] = 'Latest published version'
else:
update_map[sub.id]['note'] = 'Latest version'
continue
else:
update_map[sub.id]['new'] = None
if sub_product_ver.published:
update_map[sub.id]['note'] = \
'Already using latest published'
else:
update_map[sub.id]['note'] = 'Already using latest'
continue
else:
update_map[sub.id]['new'] = None
update_map[sub.id]['note'] = 'No new versions'
continue
self._update_map = update_map
def validate(self):
# need to identify the product version being subscribed to and the
# ptask version subscribing to it.
# get the product
if not isinstance(self._product, Product):
try:
self._product = Product.get(self._product)
except ProductError:
raise ActionError("Unable to find product: " + str(self._product))
# get ptask
if not isinstance(self._ptask, PTask):
try:
cur_spec = PTaskArea.current().spec
full_spec = PTaskSpec.get(self._ptask, relative_to=cur_spec)
self._ptask = PTask.get(full_spec)
except PTaskError:
raise ActionError("Unable to find ptask: " + str(self._ptask))
# find the version to subscribe to
if isinstance(self._product_version, ProductVersion):
pass
elif self._product_version:
matches = ProductVersion.list(product=self.product.spec, number=int(self._product_version))
if len(matches) != 1:
raise ActionError(
"Unable to find product '{p}' at version '{v}'".format(p=self.product.spec, v=self._product_version)
)
else:
self._product_version = matches[0]
else:
# get the official version
official_version = self._product.official_version
if official_version:
self._product_version = official_version
else:
# get the latest, non-deprecated version
latest_published = self._product.latest_published()
if latest_published:
self._product_version = latest_published
else:
raise ActionError("No available versions of product '{p}'".format(p=self._product.spec))
# find the version of the ptask doing the subscribing
if isinstance(self._ptask_version, PTaskVersion):
pass
elif self._ptask_version:
matches = PTaskVersion.list(ptask=self._ptask.spec, number=self._ptask_version)
if len(matches) != 1:
raise ActionError(
"Unable to find ptask '{p}' at version '{v}'".format(p=self._ptask.spec, v=self._ptask_version)
)
else:
self._ptask_version = matches[0]
else:
self._ptask_version = self._ptask.latest_version
# XXX the rules below need to be exposed outside of just the create
# code. UIs, for example, should be able to check these cases before
# allowing the user to perform actions...
# if this ptask has any existing published versions, error out
published = ProductVersion.list(ptask_version=self._ptask_version, published=True)
if len(published) > 0:
raise ActionError(
"Unable to create new subscription. This ptask version "
+ "already has published product versions.\n"
+ "You need to version up to modify subscriptions."
)
# see if there is an existing subscription:
self._existing_sub = self._ptask_version.is_subscribed(self._product)
if self._existing_sub:
if self._existing_sub.product_version_spec == self._product_version.spec:
raise ActionError("Subscription already exists!")
if self._product_version.deprecated:
raise ActionError("Product version is deprecated. Specify an alternate version.")
# make sure product is published or from same ptask
if not self._product_version.published and not self._product.ptask_spec == self._ptask.spec:
raise ActionError("Product version is not published. Specify a published version.")
def ptask_version(self):
from dpa.ptask.version import PTaskVersion
return PTaskVersion.get(self.ptask_version_spec)
def ptask_version(self):
from dpa.ptask.version import PTaskVersion
return PTaskVersion.get(self.ptask_version_spec)
def ptask_version(self):
return PTaskVersion.get(self.ptask_version_spec)
def ptask_version(self):
return PTaskVersion.get(self.ptask_version_spec)
def validate(self):
# need to identify the product version being subscribed to and the
# ptask version subscribing to it.
# get the product
if not isinstance(self._product, Product):
try:
self._product = Product.get(self._product)
except ProductError:
raise ActionError("Unable to find product: " +
str(self._product))
# get ptask
if not isinstance(self._ptask, PTask):
try:
cur_spec = PTaskArea.current().spec
full_spec = PTaskSpec.get(self._ptask, relative_to=cur_spec)
self._ptask = PTask.get(full_spec)
except PTaskError:
raise ActionError("Unable to find ptask: " + str(self._ptask))
# find the version to subscribe to
if isinstance(self._product_version, ProductVersion):
pass
elif self._product_version:
matches = ProductVersion.list(product=self.product.spec,
number=int(self._product_version))
if len(matches) != 1:
raise ActionError(
"Unable to find product '{p}' at version '{v}'".format(
p=self.product.spec, v=self._product_version))
else:
self._product_version = matches[0]
else:
# get the official version
official_version = self._product.official_version
if official_version:
self._product_version = official_version
else:
# get the latest, non-deprecated version
latest_published = self._product.latest_published()
if latest_published:
self._product_version = latest_published
else:
raise ActionError(
"No available versions of product '{p}'".format(
p=self._product.spec))
# find the version of the ptask doing the subscribing
if isinstance(self._ptask_version, PTaskVersion):
pass
elif self._ptask_version:
matches = PTaskVersion.list(ptask=self._ptask.spec,
number=self._ptask_version)
if len(matches) != 1:
raise ActionError(
"Unable to find ptask '{p}' at version '{v}'".format(
p=self._ptask.spec, v=self._ptask_version))
else:
self._ptask_version = matches[0]
else:
self._ptask_version = self._ptask.latest_version
# XXX the rules below need to be exposed outside of just the create
# code. UIs, for example, should be able to check these cases before
# allowing the user to perform actions...
# if this ptask has any existing published versions, error out
published = ProductVersion.list(ptask_version=self._ptask_version,
published=True)
if len(published) > 0:
raise ActionError(
"Unable to create new subscription. This ptask version " + \
"already has published product versions.\n" + \
"You need to version up to modify subscriptions."
)
# see if there is an existing subscription:
self._existing_sub = self._ptask_version.is_subscribed(self._product)
if self._existing_sub:
if (self._existing_sub.product_version_spec == \
self._product_version.spec):
raise ActionError("Subscription already exists!")
if self._product_version.deprecated:
raise ActionError(
"Product version is deprecated. Specify an alternate version.")
# make sure product is published or from same ptask
if (not self._product_version.published
and not self._product.ptask_spec == self._ptask.spec):
raise ActionError(
"Product version is not published. Specify a published version."
)