def serve_rpc(ctx, host, port, conf):
"""Serve EODAG functionalities through a RPC interface"""
setup_logging(verbose=ctx.obj["verbosity"])
from eodag.rpc.server import EODAGRPCServer
server = EODAGRPCServer(host, port, conf)
server.serve()
def serve_rest(ctx, daemon, world, port, config, locs, debug):
"""Serve EODAG functionalities through a WEB interface"""
setup_logging(verbose=ctx.obj["verbosity"])
# Set the settings of the app
# IMPORTANT: the order of imports counts here (first we override the settings,
# then we import the app so that the updated settings is taken into account in
# the app initialization)
if config:
os.environ["EODAG_CFG_FILE"] = config
if config:
os.environ["EODAG_CFG_FILE"] = config
if locs:
os.environ["EODAG_LOCS_CFG_FILE"] = locs
from eodag.rest.server import app
bind_host = "127.0.0.1"
if world:
bind_host = "0.0.0.0"
if daemon:
try:
pid = os.fork()
except OSError as e:
raise Exception("%s [%d]" % (e.strerror, e.errno))
if pid == 0:
os.setsid()
app.run(threaded=True, host=bind_host, port=port)
else:
sys.exit(0)
else:
app.run(debug=debug, host=bind_host, port=port)
def list_pt(ctx, **kwargs):
"""Print the list of supported product types"""
setup_logging(verbose=ctx.obj["verbosity"])
dag = EODataAccessGateway()
provider = kwargs.pop("provider")
text_wrapper = textwrap.TextWrapper()
guessed_product_types = []
try:
guessed_product_types = dag.guess_product_type(
platformSerialIdentifier=kwargs.get("platformserialidentifier"),
processingLevel=kwargs.get("processinglevel"),
sensorType=kwargs.get("sensortype"),
**kwargs
)
except NoMatchingProductType:
if any(
kwargs[arg]
for arg in [
"instrument",
"platform",
"platformserialidentifier",
"processinglevel",
"sensortype",
]
):
click.echo("No product type match the following criteria you provided:")
click.echo(
"\n".join(
"-{param}={value}".format(**locals())
for param, value in kwargs.items()
if value is not None
)
)
sys.exit(1)
try:
if guessed_product_types:
product_types = [
pt
for pt in dag.list_product_types(provider=provider)
if pt["ID"] in guessed_product_types
]
else:
product_types = dag.list_product_types(provider=provider)
click.echo("Listing available product types:")
for product_type in product_types:
click.echo("\n* {}: ".format(product_type["ID"]))
for prop, value in product_type.items():
if prop != "ID":
text_wrapper.initial_indent = " - {}: ".format(prop)
text_wrapper.subsequent_indent = " " * len(
text_wrapper.initial_indent
)
if value is not None:
click.echo(text_wrapper.fill(value))
except UnsupportedProvider:
click.echo("Unsupported provider. You may have a typo")
click.echo(
"Available providers: {}".format(", ".join(dag.available_providers()))
)
sys.exit(1)
def serve_rpc(ctx, host, port, conf):
"""Serve EODAG functionalities through a RPC interface"""
setup_logging(verbose=ctx.obj["verbosity"])
try:
from eodag_cube.rpc.server import EODAGRPCServer
except ImportError:
raise NotImplementedError(
"eodag-cube needed for this functionnality, install using `pip install eodag-cube`"
)
server = EODAGRPCServer(host, port, conf)
server.serve()
def download(ctx, **kwargs):
"""Download a bunch of products from a serialized search result"""
search_result_path = kwargs.pop("search_results")
if not search_result_path:
with click.Context(download) as ctx:
click.echo("Nothing to do (no search results file provided)")
click.echo(download.get_help(ctx))
sys.exit(1)
kwargs["verbose"] = ctx.obj["verbosity"]
setup_logging(**kwargs)
conf_file = kwargs.pop("conf")
if conf_file:
conf_file = click.format_filename(conf_file)
satim_api = EODataAccessGateway(user_conf_file_path=conf_file)
search_results = satim_api.deserialize(search_result_path)
# register downloader
for idx, product in enumerate(search_results):
if product.downloader is None:
auth = product.downloader_auth
if auth is None:
auth = satim_api._plugins_manager.get_auth_plugin(
product.provider)
search_results[idx].register_downloader(
satim_api._plugins_manager.get_download_plugin(product), auth)
downloaded_files = satim_api.download_all(search_results)
if downloaded_files and len(downloaded_files) > 0:
for downloaded_file in downloaded_files:
if downloaded_file is None:
click.echo(
"A file may have been downloaded but we cannot locate it")
else:
click.echo("Downloaded {}".format(downloaded_file))
else:
click.echo(
"Error during download, a file may have been downloaded but we cannot locate it"
)
def deploy_wsgi_app(
ctx,
root,
config,
webserver,
threads,
user,
group,
server_name,
wsgi_process_group,
wsgi_daemon_process,
name,
):
"""Deploy the WEB interface of eodag behind a web server"""
setup_logging(verbose=ctx.obj["verbosity"])
import eodag as eodag_package
server_config = {"EODAG_CFG_FILE": config}
eodag_package_path = eodag_package.__path__[0]
webapp_src_path = os.path.join(eodag_package_path, "rest")
webapp_dst_path = os.path.join(root, name)
if not os.path.exists(webapp_dst_path):
os.mkdir(webapp_dst_path)
wsgi_path = os.path.join(webapp_dst_path, "server.wsgi")
click.echo("Moving eodag HTTP web app from {} to {}".format(
webapp_src_path, webapp_dst_path))
shutil.copy(os.path.join(webapp_src_path, "server.wsgi"), wsgi_path)
shutil.copy(
os.path.join(webapp_src_path, "description.md"),
os.path.join(webapp_dst_path, "description.md"),
)
shutil.copytree(
os.path.join(webapp_src_path, "templates"),
os.path.join(webapp_dst_path, "templates"),
)
click.echo("Overriding eodag HTTP server config with values: {}".format(
server_config))
with open(os.path.join(webapp_dst_path, "eodag_server_settings.json"),
"w") as fd:
json.dump(server_config, fd)
click.echo("Finished ! The WSGI file is in {}".format(wsgi_path))
if webserver == "apache":
application_group = "%{GLOBAL}"
apache_config_sample = ("""
<VirtualHost *>
ServerName %(server_name)s
WSGIDaemonProcess %(wsgi_daemon_process)s user=%(user)s group=%(group)s \
threads=%(threads)s
WSGIScriptAlias / %(wsgi_path)s
<Directory %(webapp_dst_path)s>
WSGIProcessGroup %(wsgi_process_group)s
WSGIApplicationGroup %(application_group)s
<IfVersion < 2.4>
Order allow,deny
Allow from all
</IfVersion>
<IfVersion >= 2.4>
Require all granted
</IfVersion>
</Directory>
</VirtualHost>
""" % locals())
click.echo("Sample Apache2 config to add in a your virtual host:")
click.echo(apache_config_sample)
def search_crunch(ctx, **kwargs):
"""Search product types and optionnaly apply crunchers to search results"""
# Process inputs for search
product_type = kwargs.pop("producttype")
instrument = kwargs.pop("instrument")
platform = kwargs.pop("platform")
platform_identifier = kwargs.pop("platformserialidentifier")
processing_level = kwargs.pop("processinglevel")
sensor_type = kwargs.pop("sensortype")
id_ = kwargs.pop("id")
custom = kwargs.pop("query")
if not any([
product_type,
instrument,
platform,
platform_identifier,
processing_level,
sensor_type,
id_,
]):
with click.Context(search_crunch) as ctx:
print("Give me some work to do. See below for how to do that:",
end="\n\n")
click.echo(search_crunch.get_help(ctx))
sys.exit(-1)
kwargs["verbose"] = ctx.obj["verbosity"]
setup_logging(**kwargs)
if kwargs["box"] != (None, ) * 4:
rect = kwargs.pop("box")
footprint = {
"lonmin": rect[0],
"latmin": rect[1],
"lonmax": rect[2],
"latmax": rect[3],
}
else:
footprint = kwargs.pop("geom")
start_date = kwargs.pop("start")
stop_date = kwargs.pop("end")
criteria = {
"geometry": footprint,
"startTimeFromAscendingNode": None,
"completionTimeFromAscendingNode": None,
"cloudCover": kwargs.pop("cloudcover"),
"productType": product_type,
"instrument": instrument,
"platform": platform,
"platformSerialIdentifier": platform_identifier,
"processingLevel": processing_level,
"sensorType": sensor_type,
"id": id_,
}
if custom:
custom_dict = parse_qs(custom)
for k, v in custom_dict.items():
if isinstance(v, list) and len(v) == 1:
criteria[k] = v[0]
else:
criteria[k] = v
if start_date:
criteria["startTimeFromAscendingNode"] = start_date.isoformat()
if stop_date:
criteria["completionTimeFromAscendingNode"] = stop_date.isoformat()
conf_file = kwargs.pop("conf")
if conf_file:
conf_file = click.format_filename(conf_file)
locs_file = kwargs.pop("locs")
if locs_file:
locs_file = click.format_filename(locs_file)
# Process inputs for crunch
cruncher_names = set(kwargs.pop("cruncher") or [])
cruncher_args = kwargs.pop("cruncher_args")
cruncher_args_dict = {}
if cruncher_args:
for cruncher, argname, argval in cruncher_args:
cruncher_args_dict.setdefault(cruncher,
{}).setdefault(argname, argval)
items_per_page = kwargs.pop("items")
page = kwargs.pop("page") or 1
gateway = EODataAccessGateway(user_conf_file_path=conf_file,
locations_conf_path=locs_file)
# Search
results, total = gateway.search(page=page,
items_per_page=items_per_page,
**criteria)
click.echo("Found a total number of {} products".format(total))
click.echo("Returned {} products".format(len(results)))
# Crunch !
crunch_args = {
cruncher_name: cruncher_args_dict.get(cruncher_name, {})
for cruncher_name in cruncher_names
}
if crunch_args:
results = gateway.crunch(results,
search_criteria=criteria,
**crunch_args)
storage_filepath = kwargs.pop("storage")
if not storage_filepath.endswith(".geojson"):
storage_filepath += ".geojson"
result_storage = gateway.serialize(results, filename=storage_filepath)
click.echo("Results stored at '{}'".format(result_storage))
from eodag.api.core import EODataAccessGateway
from eodag.utils.logging import setup_logging
from eodag.utils import ProgressCallback
import os
import json
import pprint
import tqdm
setup_logging(verbose=1)
WORKSPACE="eodag_workspace"
DESCRIPTORS_PATH = r"products/stuttgart21.json"
PROVIDER = "sobloo"
dag = EODataAccessGateway('eodag.yml')
dag.set_preferred_provider(PROVIDER)
def loadDescriptorJson(path):
with open(path, "r") as json_file:
data = json.load(json_file)
return data
def createDescriptors(data):
descriptorDict = {}
for type in data["PRODUCT_TYPES"]:
descriptorDict[type] = {"productType": data["PRODUCT_TYPES"][type]}
for prop in data:
if prop != "PRODUCT_TYPES":
descriptorDict[type][prop] = data[prop]
return descriptorDict
