def handle(self, *filenames, **kwargs):
System.init()
# parse command arguments
self.verbosity = int(kwargs.get("verbosity", 1))
traceback = kwargs.get("traceback", False)
self.set_up_logging(["ngeo_browse_server"], self.verbosity, traceback)
logger.info("Starting browse layer configuration from command line.")
if not filenames:
raise CommandError("No input files provided.")
on_error = kwargs["on_error"]
config = get_ngeo_config()
no_files_handled_success = 0
no_files_handled_error = 0
# handle each file separately
for filename in filenames:
try:
# handle each browse layer xml
self._handle_file(filename, config)
no_files_handled_success += 1
except Exception, e:
# handle exceptions
no_files_handled_error += 1
logger.error("%s: %s" % (type(e).__name__, str(e)))
if on_error == "continue":
# continue the execution with the next file
continue
elif on_error == "stop":
# re-raise the exception to stop the execution
raise CommandError(e)
def handle(self, *args, **kwargs):
System.init()
# parse command arguments
self.verbosity = int(kwargs.get("verbosity", 1))
traceback = kwargs.get("traceback", False)
self.set_up_logging(["ngeo_browse_server"], self.verbosity, traceback)
logger.info("Starting browse deletion from command line.")
browse_layer_id = kwargs.get("browse_layer_id")
browse_type = kwargs.get("browse_type")
if not browse_layer_id and not browse_type:
logger.error("No browse layer or browse type was specified.")
raise CommandError("No browse layer or browse type was specified.")
elif browse_layer_id and browse_type:
logger.error("Both browse layer and browse type were specified.")
raise CommandError(
"Both browse layer and browse type were specified."
)
start = kwargs.get("start")
end = kwargs.get("end")
# parse start/end if given
if start:
start = getDateTime(start)
if end:
end = getDateTime(end)
self._handle(start, end, browse_layer_id, browse_type)
logger.info("Successfully finished browse deletion from command line.")
def handle(self, *args, **kwargs):
System.init()
# parse command arguments
self.verbosity = int(kwargs.get("verbosity", 1))
traceback = kwargs.get("traceback", False)
self.set_up_logging(["ngeo_browse_server"], self.verbosity, traceback)
logger.info("Starting browse deletion from command line.")
browse_layer_id = kwargs.get("browse_layer_id")
browse_type = kwargs.get("browse_type")
if not browse_layer_id and not browse_type:
logger.error("No browse layer or browse type was specified.")
raise CommandError("No browse layer or browse type was specified.")
elif browse_layer_id and browse_type:
logger.error("Both browse layer and browse type were specified.")
raise CommandError(
"Both browse layer and browse type were specified.")
start = kwargs.get("start")
end = kwargs.get("end")
# parse start/end if given
if start:
start = getDateTime(start)
if end:
end = getDateTime(end)
self._handle(start, end, browse_layer_id, browse_type)
logger.info("Successfully finished browse deletion from command line.")
def handle(self, *filenames, **kwargs):
System.init()
# parse command arguments
self.verbosity = int(kwargs.get("verbosity", 1))
traceback = kwargs.get("traceback", False)
self.set_up_logging(["ngeo_browse_server"], self.verbosity, traceback)
logger.info("Starting browse layer configuration from command line.")
if not filenames:
raise CommandError("No input files provided.")
on_error = kwargs["on_error"]
config = get_ngeo_config()
no_files_handled_success = 0
no_files_handled_error = 0
# handle each file separately
for filename in filenames:
try:
# handle each browse layer xml
self._handle_file(filename, config)
no_files_handled_success += 1
except Exception, e:
# handle exceptions
no_files_handled_error += 1
logger.error("%s: %s" % (type(e).__name__, str(e)))
if on_error == "continue":
# continue the execution with the next file
continue
elif on_error == "stop":
# re-raise the exception to stop the execution
raise CommandError(e)
def handle(self, *args, **kwargs):
System.init()
# parse command arguments
self.verbosity = int(kwargs.get("verbosity", 1))
traceback = kwargs.get("traceback", False)
self.set_up_logging(["ngeo_browse_server"], self.verbosity, traceback)
logger.info("Starting browse layer purging from command line.")
browse_layer_id = kwargs.get("browse_layer_id")
browse_type = kwargs.get("browse_type")
if not browse_layer_id and not browse_type:
logger.error("No browse layer or browse type was specified.")
raise CommandError("No browse layer or browse type was specified.")
elif browse_layer_id and browse_type:
logger.error("Both browse layer and browse type were specified.")
raise CommandError(
"Both browse layer and browse type were specified.")
self._handle(browse_layer_id, browse_type)
logger.info(
"Successfully finished browse layer purging from command line.")
def handle(self, *args, **kwargs):
System.init()
# parse command arguments
self.verbosity = int(kwargs.get("verbosity", 1))
traceback = kwargs.get("traceback", False)
self.set_up_logging(["ngeo_browse_server"], self.verbosity, traceback)
logger.info("Starting browse layer purging from command line.")
browse_layer_id = kwargs.get("browse_layer_id")
browse_type = kwargs.get("browse_type")
if not browse_layer_id and not browse_type:
logger.error("No browse layer or browse type was specified.")
raise CommandError("No browse layer or browse type was specified.")
elif browse_layer_id and browse_type:
logger.error("Both browse layer and browse type were specified.")
raise CommandError(
"Both browse layer and browse type were specified."
)
self._handle(browse_layer_id, browse_type)
logger.info("Successfully finished browse layer purging from command line.")
def handle(self, *args, **kwargs):
System.init()
# parse command arguments
self.verbosity = int(kwargs.get("verbosity", 1))
traceback = kwargs.get("traceback", False)
self.set_up_logging(["ngeo_browse_server"], self.verbosity, traceback)
logger.info("Starting browse import from command line.")
package_paths = args
if not len(package_paths):
logger.error("No packages given.")
raise CommandError("No packages given.")
ignore_cache = kwargs["ignore_cache"]
config = get_ngeo_config()
for package_path in package_paths:
result = import_package(package_path, ignore_cache, config)
logger.info("Successfully finished browse import from command line.")
# django settings module
os.environ["DJANGO_SETTINGS_MODULE"] = DJANGO_SETTINGS
info("'%s' ... is set as the Django settings module " % DJANGO_SETTINGS )
info("'%s' ... is set as the Django database " % DJANGO_DB )
#usingDB = DJANGO_DB # ???
# once the search path is set -> load the required modules
from eoxserver.core.system import System
from eoxserver.resources.processes.tracker import TaskStatus, QueueEmpty, \
dequeueTask, startTask, reenqueueTask, stopTaskSuccessIfNotFinished, \
reenqueueZombieTasks, deleteRetiredTasks, dbLocker
# initialize the system
System.init()
#-------------------------------------------------------------------
info( "ATPD Asynchronous Task Processing Daemon has just been started!")
info( "ATPD: id=%s (%i)" % ( SERVER_ID_STR , SERVER_ID ) )
info( "ATPD: hostname=%s" % socket.getfqdn() )
info( "ATPD: pid=%i " % os.getpid() )
#-------------------------------------------------------------------
# start the worker pool
GWP = WorkerPool( NTHREAD )
# use the GWP terminating hadlers
signal.signal( signal.SIGINT, signal_handler_sigint )
signal.signal( signal.SIGTERM, signal_handler_sigterm )
def handle(self, *args, **kwargs):
System.init()
# parse command arguments
self.verbosity = int(kwargs.get("verbosity", 1))
traceback = kwargs.get("traceback", False)
self.set_up_logging(["ngeo_browse_server"], self.verbosity, traceback)
logger.info("Starting browse export from command line.")
browse_layer_id = kwargs.get("browse_layer_id")
browse_type = kwargs.get("browse_type")
if not browse_layer_id and not browse_type:
logger.error("No browse layer or browse type was specified.")
raise CommandError("No browse layer or browse type was specified.")
elif browse_layer_id and browse_type:
logger.error("Both browse layer and browse type were specified.")
raise CommandError("Both browse layer and browse type were specified.")
start = kwargs.get("start")
end = kwargs.get("end")
compression = kwargs.get("compression")
export_cache = kwargs["export_cache"]
output_path = kwargs.get("output_path")
# parse start/end if given
if start:
start = getDateTime(start)
if end:
end = getDateTime(end)
if not output_path:
output_path = package.generate_filename(compression)
with package.create(output_path, compression) as p:
# query the browse layer
if browse_layer_id:
try:
browse_layer_model = BrowseLayer.objects.get(id=browse_layer_id)
except BrowseLayer.DoesNotExist:
logger.error("Browse layer '%s' does not exist"
% browse_layer_id)
raise CommandError("Browse layer '%s' does not exist"
% browse_layer_id)
else:
try:
browse_layer_model = BrowseLayer.objects.get(browse_type=browse_type)
except BrowseLayer.DoesNotExist:
logger.error("Browse layer with browse type '%s' does "
"not exist" % browse_type)
raise CommandError("Browse layer with browse type '%s' does "
"not exist" % browse_type)
browse_layer = browselayer_data.BrowseLayer.from_model(browse_layer_model)
p.set_browse_layer(
serialize_browse_layers((browse_layer,), pretty_print=True)
)
# query browse reports; optionally filter for start/end time
browse_reports_qs = BrowseReport.objects.all()
# apply start/end filter
if start and not end:
browse_reports_qs = browse_reports_qs.filter(browses__start_time__gte=start)
elif end and not start:
browse_reports_qs = browse_reports_qs.filter(browses__end_time__lte=end)
elif start and end:
browse_reports_qs = browse_reports_qs.filter(browses__start_time__gte=start,
browses__end_time__lte=end)
# use count annotation to exclude all browse reports with no browses
browse_reports_qs = browse_reports_qs.annotate(
browse_count=Count('browses')
).filter(browse_layer=browse_layer_model, browse_count__gt=0)
# iterate over all browse reports
for browse_report_model in browse_reports_qs:
browses_qs = Browse.objects.filter(
browse_report=browse_report_model
)
if start:
browses_qs = browses_qs.filter(start_time__gte=start)
if end:
browses_qs = browses_qs.filter(end_time__lte=end)
browse_report = browsereport_data.BrowseReport.from_model(
browse_report_model, browses_qs
)
# iterate over all browses in the query
for browse, browse_model in izip(browse_report, browses_qs):
coverage_wrapper = System.getRegistry().getFromFactory(
"resources.coverages.wrappers.EOCoverageFactory",
{"obj_id": browse_model.coverage_id}
)
# set the
base_filename = browse_model.coverage_id
data_filename = base_filename + ".tif"
md_filename = base_filename + ".xml"
footprint_filename = base_filename + ".wkb"
browse._file_name = data_filename
# add optimized browse image to package
data_package = coverage_wrapper.getData()
data_package.prepareAccess()
browse_file_path = data_package.getGDALDatasetIdentifier()
with open(browse_file_path) as f:
p.add_browse(f, data_filename)
wkb = coverage_wrapper.getFootprint().wkb
p.add_footprint(footprint_filename, wkb)
if export_cache:
time_model = mapcache_models.Time.objects.get(
start_time__lte=browse_model.start_time,
end_time__gte=browse_model.end_time,
source__name=browse_layer_model.id
)
# get "dim" parameter
dim = (isotime(time_model.start_time) + "/" +
isotime(time_model.end_time))
# exit if a merged browse is found
if dim != (isotime(browse_model.start_time) + "/" +
isotime(browse_model.end_time)):
logger.error("Browse layer '%s' contains "
"merged browses and exporting "
"of cache is requested. Try "
"without exporting the cache."
% browse_layer_model.id)
raise CommandError("Browse layer '%s' contains "
"merged browses and exporting "
"of cache is requested. Try "
"without exporting the cache."
% browse_layer_model.id)
# get path to sqlite tileset and open it
ts = tileset.open(
get_tileset_path(browse_layer.browse_type)
)
for tile_desc in ts.get_tiles(
browse_layer.id,
URN_TO_GRID[browse_layer.grid], dim=dim,
minzoom=browse_layer.highest_map_level,
maxzoom=browse_layer.lowest_map_level
):
p.add_cache_file(*tile_desc)
# save browse report xml and add it to the package
p.add_browse_report(
serialize_browse_report(browse_report, pretty_print=True),
name="%s_%s_%s_%s.xml" % (
browse_report.browse_type,
browse_report.responsible_org_name,
browse_report.date_time.strftime("%Y%m%d%H%M%S%f"),
uuid.uuid4().hex
)
)
logger.info("Successfully finished browse export from command line.")
def ingest_browse_report(parsed_browse_report, do_preprocessing=True, config=None):
""" Ingests a browse report. reraise_exceptions if errors shall be handled
externally
"""
# initialize the EOxServer system/registry/configuration
System.init()
try:
# get the according browse layer
browse_type = parsed_browse_report.browse_type
browse_layer = models.BrowseLayer.objects.get(browse_type=browse_type)
except models.BrowseLayer.DoesNotExist:
logger.warn("Browse layer with browse type '%s' does not " "exist." % parsed_browse_report.browse_type)
raise IngestionException(
"Browse layer with browse type '%s' does not " "exist." % parsed_browse_report.browse_type
)
# generate a browse report model
browse_report = create_browse_report(parsed_browse_report, browse_layer)
# initialize the preprocessor with configuration values
crs = None
if browse_layer.grid == "urn:ogc:def:wkss:OGC:1.0:GoogleMapsCompatible":
crs = "EPSG:3857"
elif browse_layer.grid == "urn:ogc:def:wkss:OGC:1.0:GoogleCRS84Quad":
crs = "EPSG:4326"
logger.debug("Using CRS '%s' ('%s')." % (crs, browse_layer.grid))
# create the required preprocessor/format selection
format_selection = get_format_selection("GTiff", **get_format_config(config))
if do_preprocessing:
# add config parameters and custom params
params = get_optimization_config(config)
# add radiometric interval
rad_min = browse_layer.radiometric_interval_min
if rad_min is not None:
params["radiometric_interval_min"] = rad_min
else:
rad_min = "min"
rad_max = browse_layer.radiometric_interval_max
if rad_max is not None:
params["radiometric_interval_max"] = rad_max
else:
rad_max = "max"
# add band selection
if browse_layer.r_band is not None and browse_layer.g_band is not None and browse_layer.b_band is not None:
bands = [
(browse_layer.r_band, rad_min, rad_max),
(browse_layer.g_band, rad_min, rad_max),
(browse_layer.b_band, rad_min, rad_max),
]
if params["bandmode"] == RGBA:
# RGBA
bands.append((0, 0, 0))
params["bands"] = bands
preprocessor = NGEOPreProcessor(format_selection, crs=crs, **params)
else:
preprocessor = None # TODO: CopyPreprocessor
report_result = IngestBrowseReportResult()
succeded = []
failed = []
timestamp = datetime.utcnow().strftime("%Y%m%d%H%M%S%f")
browse_dirname = _valid_path(
"%s_%s_%s_%s"
% (
browse_type,
browse_report.responsible_org_name,
browse_report.date_time.strftime("%Y%m%d%H%M%S%f"),
timestamp,
)
)
success_dir = join(get_success_dir(config), browse_dirname)
failure_dir = join(get_failure_dir(config), browse_dirname)
if exists(success_dir):
logger.warn("Success directory '%s' already exists.")
else:
makedirs(success_dir)
if exists(failure_dir):
logger.warn("Failure directory '%s' already exists.")
else:
makedirs(failure_dir)
# iterate over all browses in the browse report
for parsed_browse in parsed_browse_report:
# transaction management per browse
with transaction.commit_manually():
with transaction.commit_manually(using="mapcache"):
try:
seed_areas = []
# try ingest a single browse and log success
result = ingest_browse(
parsed_browse,
browse_report,
browse_layer,
preprocessor,
crs,
success_dir,
failure_dir,
seed_areas,
config=config,
)
report_result.add(result)
succeded.append(parsed_browse)
# commit here to allow seeding
transaction.commit()
transaction.commit(using="mapcache")
logger.info("Committed changes to database.")
for minx, miny, maxx, maxy, start_time, end_time in seed_areas:
try:
# seed MapCache synchronously
# TODO: maybe replace this with an async solution
seed_mapcache(
tileset=browse_layer.id,
grid=browse_layer.grid,
minx=minx,
miny=miny,
maxx=maxx,
maxy=maxy,
minzoom=browse_layer.lowest_map_level,
maxzoom=browse_layer.highest_map_level,
start_time=start_time,
end_time=end_time,
delete=False,
**get_mapcache_seed_config(config)
)
logger.info("Successfully finished seeding.")
except Exception, e:
logger.warn("Seeding failed: %s" % str(e))
# log ingestions for report generation
# date/browseType/browseLayerId/start/end
report_logger.info(
"/\\/\\".join(
(
datetime.utcnow().isoformat("T") + "Z",
parsed_browse_report.browse_type,
browse_layer.id,
(
parsed_browse.start_time.replace(tzinfo=None) - parsed_browse.start_time.utcoffset()
).isoformat("T")
+ "Z",
(
parsed_browse.end_time.replace(tzinfo=None) - parsed_browse.end_time.utcoffset()
).isoformat("T")
+ "Z",
)
)
)
except Exception, e:
# report error
logger.error("Failure during ingestion of browse '%s'." % parsed_browse.browse_identifier)
logger.error("Exception was '%s': %s" % (type(e).__name__, str(e)))
logger.debug(traceback.format_exc() + "\n")
# undo latest changes, append the failure and continue
report_result.add(
IngestBrowseFailureResult(
parsed_browse.browse_identifier, getattr(e, "code", None) or type(e).__name__, str(e)
)
)
failed.append(parsed_browse)
transaction.rollback()
transaction.rollback(using="mapcache")
# enqueue task for execution
enqueueTask(PROCESS_CLASS, tid, param)
print "ENQUEUE: %s" % tid, param
break
except QueueFull: # retry if queue full
print " --- QueueFull #%i - sleep: %g s" % (cnt + 1,
getWaitTime(cnt))
time.sleep(getWaitTime(cnt))
cnt += 1
continue
if __name__ == "__main__":
from eoxserver.core.system import System
# initialize the system
System.init()
for i in xrange(N):
testEnqueue("%6.6u" % i)
#time.sleep(0.1)
def handle(self, *args, **options):
# set up
System.init()
self.verbosity = int(options.get('verbosity', 1))
#----------------------------------------------------------------------
# prepare managers
dsMngr = {
"RectifiedStitchedMosaic" : getRectifiedStitchedMosaicManager(),
"DatasetSeries" : getDatasetSeriesManager() }
cidMngr = CoverageIdManager()
#----------------------------------------------------------------------
# parse arguments
ids = []
if options.get("synchronise_all", False):
# synchronise all container entities
for mngr in dsMngr.values() :
ids.extend( mngr.get_all_ids() )
else:
# read ids from the commandline
ids.extend( args )
#----------------------------------------------------------------------
# synchronise objects
success_count = 0 # success counter - counts finished syncs
for id in ids :
# get type of the entity
dsType = cidMngr.getType( id )
# check the entity type
if not dsMngr.has_key( dsType ) :
self.print_msg( "'%s' is neither mosaic nor series!"%id,2)
self._error( id , "Invalid identifier." )
continue # continue by next entity
self.print_msg( "Synchronising %s: '%s'" % ( dsType, id ) )
try:
with transaction.commit_on_success():
dsMngr[dsType].synchronize(id)
except Exception as e :
# print stack trace if required
if options.get("traceback", False):
self.print_msg(traceback.format_exc())
self._error( dsType, id, "%s: %s"%(type(e).__name__, str(e)) )
continue # continue by next dataset
success_count += 1 #increment the success counter
self.print_msg( "%s successfully synchronised."%dsType,2)
#----------------------------------------------------------------------
# print the final info
count = len(ids)
error_count = count - success_count
if ( error_count > 0 ) :
self.print_msg( "Failed to synchronise %d objects." % (
error_count ) , 1 )
if ( success_count > 0 ) :
self.print_msg( "Successfully synchronised %d of %s objects." % (
success_count , count ) , 1 )
else :
self.print_msg( "No object synchronised." )
if ( error_count > 0 ) :
raise CommandError("Not all objects could be synchronised.")
def ingest_browse_report(parsed_browse_report, do_preprocessing=True, config=None):
""" Ingests a browse report. reraise_exceptions if errors shall be handled
externally
"""
# initialize the EOxServer system/registry/configuration
System.init()
try:
# get the according browse layer
browse_type = parsed_browse_report.browse_type
browse_layer = models.BrowseLayer.objects.get(browse_type=browse_type)
except models.BrowseLayer.DoesNotExist:
logger.warn("Browse layer with browse type '%s' does not "
"exist." % parsed_browse_report.browse_type)
raise IngestionException("Browse layer with browse type '%s' does not "
"exist." % parsed_browse_report.browse_type)
# generate a browse report model
browse_report = create_browse_report(parsed_browse_report, browse_layer)
# initialize the preprocessor with configuration values
crs = None
if browse_layer.grid == "urn:ogc:def:wkss:OGC:1.0:GoogleMapsCompatible":
crs = "EPSG:3857"
elif browse_layer.grid == "urn:ogc:def:wkss:OGC:1.0:GoogleCRS84Quad":
crs = "EPSG:4326"
logger.debug("Using CRS '%s' ('%s')." % (crs, browse_layer.grid))
# create the required preprocessor/format selection
format_selection = get_format_selection("GTiff",
**get_format_config(config))
if do_preprocessing:
# add config parameters and custom params
params = get_optimization_config(config)
# add radiometric interval
rad_min = browse_layer.radiometric_interval_min
if rad_min is not None:
params["radiometric_interval_min"] = rad_min
else:
rad_min = "min"
rad_max = browse_layer.radiometric_interval_max
if rad_max is not None:
params["radiometric_interval_max"] = rad_max
else:
rad_max = "max"
# add band selection
if (browse_layer.r_band is not None and
browse_layer.g_band is not None and
browse_layer.b_band is not None):
bands = [(browse_layer.r_band, rad_min, rad_max),
(browse_layer.g_band, rad_min, rad_max),
(browse_layer.b_band, rad_min, rad_max)]
if params["bandmode"] == RGBA:
# RGBA
bands.append((0, 0, 0))
params["bands"] = bands
preprocessor = NGEOPreProcessor(format_selection, crs=crs, **params)
else:
preprocessor = None # TODO: CopyPreprocessor
report_result = IngestBrowseReportResult()
succeded = []
failed = []
timestamp = datetime.utcnow().strftime("%Y%m%d%H%M%S%f")
browse_dirname = _valid_path("%s_%s_%s_%s" % (
browse_type, browse_report.responsible_org_name,
browse_report.date_time.strftime("%Y%m%d%H%M%S%f"),
timestamp
))
success_dir = join(get_success_dir(config), browse_dirname)
failure_dir = join(get_failure_dir(config), browse_dirname)
if exists(success_dir):
logger.warn("Success directory '%s' already exists.")
else:
makedirs(success_dir)
if exists(failure_dir):
logger.warn("Failure directory '%s' already exists.")
else:
makedirs(failure_dir)
# iterate over all browses in the browse report
for parsed_browse in parsed_browse_report:
# transaction management per browse
with transaction.commit_manually():
with transaction.commit_manually(using="mapcache"):
try:
seed_areas = []
# try ingest a single browse and log success
result = ingest_browse(parsed_browse, browse_report,
browse_layer, preprocessor, crs,
success_dir, failure_dir,
seed_areas, config=config)
report_result.add(result)
succeded.append(parsed_browse)
# commit here to allow seeding
transaction.commit()
transaction.commit(using="mapcache")
logger.info("Committed changes to database.")
for minx, miny, maxx, maxy, start_time, end_time in seed_areas:
try:
# seed MapCache synchronously
# TODO: maybe replace this with an async solution
seed_mapcache(tileset=browse_layer.id,
grid=browse_layer.grid,
minx=minx, miny=miny,
maxx=maxx, maxy=maxy,
minzoom=browse_layer.lowest_map_level,
maxzoom=browse_layer.highest_map_level,
start_time=start_time,
end_time=end_time,
delete=False,
**get_mapcache_seed_config(config))
logger.info("Successfully finished seeding.")
except Exception, e:
logger.warn("Seeding failed: %s" % str(e))
# log ingestions for report generation
# date/browseType/browseLayerId/start/end
report_logger.info("/\\/\\".join((
datetime.utcnow().isoformat("T") + "Z",
parsed_browse_report.browse_type,
browse_layer.id,
(parsed_browse.start_time.replace(tzinfo=None)-parsed_browse.start_time.utcoffset()).isoformat("T") + "Z",
(parsed_browse.end_time.replace(tzinfo=None)-parsed_browse.end_time.utcoffset()).isoformat("T") + "Z"
)))
except Exception, e:
# report error
logger.error("Failure during ingestion of browse '%s'." %
parsed_browse.browse_identifier)
logger.error("Exception was '%s': %s" % (type(e).__name__, str(e)))
logger.debug(traceback.format_exc() + "\n")
# undo latest changes, append the failure and continue
report_result.add(IngestBrowseFailureResult(
parsed_browse.browse_identifier,
getattr(e, "code", None) or type(e).__name__, str(e))
)
failed.append(parsed_browse)
transaction.rollback()
transaction.rollback(using="mapcache")
def setUp(self):
System.init()