def _initialize_database(repository_url, table_name, data_dir, test_dir,
export_dir):
"""Initialize database for tests.
This function will create the database and load any test data that
the suite may require.
Parameters
----------
repository_url: str
URL for the repository, as used by SQLAlchemy engines
table_name: str
Name of the table that is to be used to store pycsw records
data_dir: str
Path to a directory that contains sample data records to be loaded
into the database
test_dir: str
Directory where the database is to be created, in case of sqlite.
export_dir: str
Diretory where the exported records are to be saved, if any
"""
print("Setting up {0!r} repository...".format(repository_url))
if repository_url.startswith("postgresql"):
extra_kwargs = {
"create_sfsql_tables": True,
"create_plpythonu_functions": False
}
else:
extra_kwargs = {}
admin.setup_db(database=repository_url,
table=table_name,
home=test_dir,
**extra_kwargs)
if len(os.listdir(data_dir)) > 0:
print("Loading database data...")
loaded = admin.load_records(context=StaticContext(),
database=repository_url,
table=table_name,
xml_dirpath=data_dir,
recursive=True)
admin.optimize_db(context=StaticContext(),
database=repository_url,
table=table_name)
if export_dir is not None:
# Attempt to export files
exported = admin.export_records(context=StaticContext(),
database=repository_url,
table=table_name,
xml_dirpath=export_dir)
if len(loaded) != len(exported):
raise ValueError(
"Loaded records (%s) is different from exported records (%s)"
% (len(loaded), len(exported)))
# Remove the files that were exported since this was just a test
for toremove in exported:
os.remove(toremove)
def handle(self, *args, **options):
log_level = {
0: logging.ERROR,
1: logging.WARNING,
2: logging.INFO,
3: logging.DEBUG
}.get(options["verbosity"])
logger.setLevel(log_level)
pycsw_logger = logging.getLogger("pycsw")
pycsw_logger.setLevel(log_level)
pycsw_config = build_pycsw_settings()
context = StaticContext()
self.pycsw_admin_handler.parse_configuration(pycsw_config, context)
ArgsObject = namedtuple("ArgsObject", options.keys())
the_args = ArgsObject(**options)
result = the_args.func(the_args)
if result is not None:
self.stdout.write(result)
self.stdout.write("Done!")
def _initialize_database(repository_url, table_name, data_dir, test_dir):
"""Initialize database for tests.
This function will create the database and load any test data that
the suite may require.
Parameters
----------
repository_url: str
URL for the repository, as used by SQLAlchemy engines
table_name: str
Name of the table that is to be used to store pycsw records
data_dir: str
Path to a directory that contains sample data records to be loaded
into the database
test_dir: str
Directory where the database is to be created, in case of sqlite.
"""
print("Setting up {0!r} repository...".format(repository_url))
if repository_url.startswith("postgresql"):
extra_kwargs = {
"create_sfsql_tables": True,
"create_plpythonu_functions": False
}
else:
extra_kwargs = {}
admin.setup_db(database=repository_url,
table=table_name,
home=test_dir,
**extra_kwargs)
if len(os.listdir(data_dir)) > 0:
print("Loading database data...")
admin.load_records(context=StaticContext(),
database=repository_url,
table=table_name,
xml_dirpath=data_dir)
def __init__(self, config: ConfigParser):
"""
constructor
:param config: ConfigParser pycsw configuration dict
:returns: `pycsw.ogc.api.API` instance
"""
self.config = config
log.setup_logger(self.config)
if self.config['server']['url'].startswith('${'):
LOGGER.debug(
f"Server URL is an environment variable: {self.config['server']['url']}"
)
url_ = match_env_var(self.config['server']['url'])
else:
url_ = self.config['server']['url']
LOGGER.debug(f'Server URL: {url_}')
self.config['server']['url'] = url_.rstrip('/')
self.context = StaticContext()
LOGGER.debug('Setting maxrecords')
try:
self.maxrecords = int(self.config['server']['maxrecords'])
except KeyError:
self.maxrecords = 10
LOGGER.debug(f'maxrecords: {self.maxrecords}')
repo_filter = None
if self.config.has_option('repository', 'filter'):
repo_filter = self.config.get('repository', 'filter')
self.orm = 'sqlalchemy'
from pycsw.core import repository
try:
LOGGER.info('Loading default repository')
self.repository = repository.Repository(
self.config.get('repository', 'database'),
self.context,
# self.environ.get('local.app_root', None),
None,
self.config.get('repository', 'table'),
repo_filter)
LOGGER.debug(f'Repository loaded {self.repository.dbtype}')
except Exception as err:
msg = f'Could not load repository {err}'
LOGGER.exception(msg)
raise
self.query_mappings = {
'type': self.repository.dataset.type,
'recordUpdated': self.repository.dataset.insert_date,
'title': self.repository.dataset.title,
'description': self.repository.dataset.abstract,
'keywords': self.repository.dataset.keywords,
'anytext': self.repository.dataset.anytext,
'bbox': self.repository.dataset.wkt_geometry
}
def __init__(self, config: ConfigParser):
"""
constructor
:param config: ConfigParser pycsw configuration dict
:returns: `pycsw.ogc.api.API` instance
"""
self.config = config
log.setup_logger(self.config)
if self.config['server']['url'].startswith('${'):
LOGGER.debug(f"Server URL is an environment variable: {self.config['server']['url']}")
url_ = match_env_var(self.config['server']['url'])
else:
url_ = self.config['server']['url']
LOGGER.debug(f'Server URL: {url_}')
self.config['server']['url'] = url_.rstrip('/')
self.context = StaticContext()
LOGGER.debug('Setting maxrecords')
try:
self.maxrecords = int(self.config['server']['maxrecords'])
except KeyError:
self.maxrecords = 10
LOGGER.debug(f'maxrecords: {self.maxrecords}')
repo_filter = None
if self.config.has_option('repository', 'filter'):
repo_filter = self.config.get('repository', 'filter')
custom_mappings_path = self.config.get('repository', 'mappings', fallback=None)
if custom_mappings_path is not None:
md_core_model = load_custom_repo_mappings(custom_mappings_path)
if md_core_model is not None:
self.context.md_core_model = md_core_model
else:
LOGGER.exception(
'Could not load custom mappings: %s', custom_mappings_path)
self.orm = 'sqlalchemy'
from pycsw.core import repository
try:
LOGGER.info('Loading default repository')
self.repository = repository.Repository(
self.config.get('repository', 'database'),
self.context,
# self.environ.get('local.app_root', None),
None,
self.config.get('repository', 'table'),
repo_filter
)
LOGGER.debug(f'Repository loaded {self.repository.dbtype}')
except Exception as err:
msg = f'Could not load repository {err}'
LOGGER.exception(msg)
raise
self.query_mappings = {
'type': self.repository.dataset.type,
'parentidentifier': self.repository.dataset.parentidentifier,
'collections': self.repository.dataset.parentidentifier,
'recordUpdated': self.repository.dataset.insert_date,
'title': self.repository.dataset.title,
'description': self.repository.dataset.abstract,
'keywords': self.repository.dataset.keywords,
'anytext': self.repository.dataset.anytext,
'bbox': self.repository.dataset.wkt_geometry,
'date': self.repository.dataset.date,
'time_begin': self.repository.dataset.time_begin,
'time_end': self.repository.dataset.time_end,
'platform': self.repository.dataset.platform,
'instrument': self.repository.dataset.instrument,
'sensortype': self.repository.dataset.sensortype
}
if self.repository.dbtype == 'postgresql+postgis+native':
self.query_mappings['bbox'] = self.repository.dataset.wkb_geometry