def _init_task(self):
super(SchedulePushOrgList, self)._init_task()
self.push = SalesforcePushApi(
self.sf,
self.logger,
self.options['batch_size'],
)
def _get_push_request_query(self, request_id):
default_where = {"PackagePushRequest": "Id = '{}'".format(request_id)}
# Create a new PushAPI instance with different settings than self.push
self.push_report = SalesforcePushApi(
self.sf,
self.logger,
lazy=["subscribers", "jobs"],
default_where=default_where,
)
# Get the push request
self.push_request = self.push_report.get_push_request_objs(
"Id = '{}'".format(request_id), limit=1
)
if not self.push_request:
raise PushApiObjectNotFound(
"Push Request {} was not found".format(self.push_request)
)
self.push_request = self.push_request[0]
def _get_orgs(self):
subscriber_where = self.options.get('subscriber_where')
default_where = {
'PackageSubscriber':
("OrgStatus = 'Active' AND InstalledStatus = 'i'")
}
if subscriber_where:
default_where['PackageSubscriber'] += ' AND ({})'.format(
subscriber_where)
push_api = SalesforcePushApi(
self.sf,
self.logger,
default_where=default_where.copy(),
)
package = self._get_package(self.options.get('namespace'))
version = self._get_version(package, self.options.get('version'))
min_version = self.options.get('min_version')
if min_version:
min_version = self._get_version(
package,
self.options.get('min_version'),
)
orgs = []
if min_version:
# If working with a range of versions, use an inclusive search
versions = version.get_older_released_version_objs(
greater_than_version=min_version)
included_versions = []
for include_version in versions:
included_versions.append(str(include_version.sf_id))
if not included_versions:
raise ValueError(
'No versions found between version id {} and {}'.format(
version.version_number, min_version.version_number))
# Query orgs for each version in the range individually to avoid
# query timeout errors with querying multiple versions
for included_version in included_versions:
# Clear the get_subscribers method cache before each call
push_api.get_subscribers.cache.clear()
push_api.default_where['PackageSubscriber'] = (
"{} AND MetadataPackageVersionId = '{}'".format(
default_where['PackageSubscriber'],
included_version,
))
for subscriber in push_api.get_subscribers():
orgs.append(subscriber['OrgKey'])
else:
# If working with a specific version rather than a range, use an
# exclusive search.
# Add exclusion of all orgs running on newer releases
newer_versions = version.get_newer_released_version_objs()
excluded_versions = [str(version.sf_id)]
for newer in newer_versions:
excluded_versions.append(str(newer.sf_id))
if len(excluded_versions) == 1:
push_api.default_where['PackageSubscriber'] += (
" AND MetadataPackageVersionId != '{}'".format(
excluded_versions[0], ))
else:
push_api.default_where['PackageSubscriber'] += (
" AND MetadataPackageVersionId NOT IN {}".format(
"('" + "','".join(excluded_versions) + "')"))
for subscriber in push_api.get_subscribers():
orgs.append(subscriber['OrgKey'])
return orgs
def _init_task(self):
super(BaseSalesforcePushTask, self)._init_task()
self.push = SalesforcePushApi(self.sf, self.logger)
def _report_push_status(self, request_id):
default_where = {'PackagePushRequest': "Id = '{}'".format(request_id)}
# Create a new PushAPI instance with different settings than self.push
self.push_report = SalesforcePushApi(
self.sf,
self.logger,
lazy=['subscribers', 'jobs'],
default_where=default_where,
)
# Get the push request
push_request = self.push_report.get_push_request_objs(
"Id = '{}'".format(request_id),
limit=1,
)
if not push_request:
raise PushApiObjectNotFound(
'Push Request {} was not found'.format(push_request))
push_request = push_request[0]
# Check if the request is complete
interval = 10
if push_request.status not in self.completed_statuses:
self.logger.info(
'Push request is not yet complete.' +
' Polling for status every {} seconds until completion'.format(
interval))
# Loop waiting for request completion
i = 0
while push_request.status not in self.completed_statuses:
if i == 10:
self.logger.info(
'This is taking a while! Polling every 60 seconds')
interval = 60
time.sleep(interval)
# Clear the method level cache on get_push_requests and
# get_push_request_objs
self.push_report.get_push_requests.cache.clear()
self.push_report.get_push_request_objs.cache.clear()
# Get the push_request again
push_request = self.push_report.get_push_request_objs(
"Id = '{}'".format(request_id),
limit=1,
)[0]
self.logger.info(push_request.status)
i += 1
failed_jobs = []
success_jobs = []
canceled_jobs = []
jobs = push_request.get_push_job_objs()
for job in jobs:
if job.status == 'Failed':
failed_jobs.append(job)
elif job.status == 'Succeeded':
success_jobs.append(job)
elif job.status == 'Canceled':
canceled_jobs.append(job)
self.logger.info(
"Push complete: {} succeeded, {} failed, {} canceled".format(
len(success_jobs),
len(failed_jobs),
len(canceled_jobs),
))
failed_by_error = {}
for job in failed_jobs:
errors = job.get_push_error_objs()
for error in errors:
error_key = (
error.error_type,
error.title,
error.message,
error.details,
)
if error_key not in failed_by_error:
failed_by_error[error_key] = []
failed_by_error[error_key].append(error)
if failed_jobs:
self.logger.info("-----------------------------------")
self.logger.info("Failures by error type")
self.logger.info("-----------------------------------")
for key, errors in failed_by_error.items():
self.logger.info(" ")
self.logger.info("{} failed with...".format(len(errors)))
self.logger.info(" Error Type = {}".format(key[0]))
self.logger.info(" Title = {}".format(key[1]))
self.logger.info(" Message = {}".format(key[2]))
self.logger.info(" Details = {}".format(key[3]))
def sf_push_api(self):
return SalesforcePushApi(mock.Mock(), mock.Mock()) # sf # logger
def sf_push_api():
return SalesforcePushApi(sf=mock.Mock(), logger=mock.Mock())