def test_construct_okay(self):
x = StoredConfig(
self.good_data_filename, schema_file=self.good_schema_filename)
self.assertEqual(x.datafile, self.good_data_filename,
'Configuration data is not correct.')
self.assertEqual(x.schema_file, self.good_schema_filename,
'Configuration schema is not correct.')
def test_construct_missing_data(self):
try:
x = StoredConfig(
self.bad_data_filename, schema_file=self.good_schema_filename)
self.fail('Expected failure when passing nonexistant filenames to '
+ 'constructor.')
except:
pass
def test_validation_schema_xml(self):
test_schema = self.make_simple_schema()
x = StoredConfig(self.good_data_filename, schema_file=test_schema.name)
is_valid = x.validate()
os.remove(test_schema.name)
self.assertTrue(is_valid, 'Configuration schema should be valid.')
def test_validation(self):
x = StoredConfig(
self.good_data_filename, schema_file=self.good_schema_filename)
is_valid = x.validate()
self.assertTrue(
is_valid,
'Configuration schema and data should be valid and should validate'
+ ' successfully.')
def test_validation_schema_xml_wellformed(self):
test_schema = tempfile.NamedTemporaryFile(delete=False)
test_schema.write('<?xml version="1.0" encoding="utf-8"?>\n')
test_schema.write('<DistrictBuilder><junk/></DistrictBuilder>\n')
test_schema.close()
x = StoredConfig(self.good_data_filename, schema_file=test_schema.name)
is_valid = x.validate()
os.remove(test_schema.name)
self.assertFalse(is_valid, 'Configuration schema was not valid.')
def test_validation_data_xml_parser(self):
test_schema = self.make_simple_schema()
test_data = tempfile.NamedTemporaryFile(delete=False)
test_data.write('<?xml version="1.0" encoding="utf-8"?>\n')
test_data.write('<DistrictBuilder><junk></DistrictBuilder>\n')
test_data.close()
x = StoredConfig(test_data.name, schema_file=test_schema.name)
is_valid = x.validate()
os.remove(test_data.name)
os.remove(test_schema.name)
self.assertFalse(is_valid, 'Configuration data was not valid.')
def setUp(self):
self.store = StoredConfig('./config/config.dist.xml')
self.store.validate()
self.cmd = Command()
def handle(self, *args, **options):
"""
Perform the command.
"""
self.setup_logging(int(options.get('verbosity')))
force = options.get('force')
translation.activate('en')
if options.get('config') is None:
logger.warning("""
ERROR:
This management command requires the -c or --config option. This option
specifies the main configuration file.
""")
sys.exit(1)
try:
store = StoredConfig(options.get('config'))
except Exception:
logger.info("""
ERROR:
The configuration file specified could not be parsed. Please check the
contents of the file and try again.
""")
# Indicate that an error has occurred
sys.exit(1)
if not store.validate():
logger.info("""
ERROR:
The configuration file was not valid. Please check the contents of the
file and try again.
""")
# Indicate that an error has occurred
sys.exit(1)
# Create an importer for use in importing the config objects
config = ConfigImporter(store)
# When the setup script is run, it re-computes the secret key
# used to secure session data. Blow away any old sessions that
# were in the DB.
success = Utils.purge_sessions()
if not success:
sys.exit(1)
# When configuring, we want to keep track of any failures so we can
# return the correct exit code. Since False evaluates to a 0, we can
# multiply values by all_ok so that a single False value means all_ok
# will remain false
all_ok = True
success = config.import_superuser(force)
all_ok = success
try:
all_ok = all_ok * self.import_prereq(config, force)
except:
all_ok = False
logger.info('Error importing configuration.')
logger.info(traceback.format_exc())
# Create the utilities for spatial operations (renesting and geoserver)
geoutil = SpatialUtils(store)
try:
updatefield = None
if options.get("updatefield") is not None:
updatefield = options.get("updatefield")[0]
optlevels = options.get("geolevels")
nestlevels = options.get("nesting")
if (not optlevels is None) or (not nestlevels is None):
# Begin the import process
geolevels = store.filter_geolevels()
for i, geolevel in enumerate(geolevels):
if optlevels is not None:
importme = len(optlevels) == 0 or (i in optlevels)
if importme:
self.import_geolevel(store, geolevel, updatefield)
if nestlevels is not None:
nestme = len(nestlevels) == 0
nestme = nestme or (i in nestlevels)
if nestme:
geoutil.renest_geolevel(geolevel)
except:
all_ok = False
logger.info('ERROR importing geolevels.')
logger.info(traceback.format_exc())
# Do this once after processing the geolevels
config.import_contiguity_overrides()
# Save any changes to the config locale files
config.save()
if options.get("views"):
# Create views based on the subjects and geolevels
try:
configure_views()
except:
logger.info(traceback.format_exc())
all_ok = False
if options.get("geoserver"):
try:
all_ok = all_ok * geoutil.purge_geoserver()
if all_ok:
logger.info("Geoserver configuration cleaned.")
all_ok = all_ok * geoutil.configure_geoserver()
else:
logger.info(
"Geoserver configuration could not be cleaned.")
except:
logger.info('ERROR configuring geoserver.')
logger.info(traceback.format_exc())
all_ok = False
if options.get("templates"):
try:
self.create_template(store.data)
except:
logger.info('ERROR creating templates.')
logger.info(traceback.format_exc())
all_ok = False
if options.get("static"):
call_command('collectstatic',
interactive=False,
verbosity=options.get('verbosity'))
call_command('compress',
interactive=False,
verbosity=options.get('verbosity'),
force=True)
if options.get("languages"):
call_command('makelanguagefiles',
interactive=False,
verbosity=options.get('verbosity'))
if options.get("adjacency"):
self.import_adjacency(store.data)
# For our return value, a 0 (False) means OK, any nonzero (i.e., True or 1)
# means that an error occurred - the opposite of the meaning of all_ok's bool
sys.exit(not all_ok)