def __init__(self, configSpec: Union[str, Dict[str, Dict]], **kwargs):
self._workers: Dict[str, TaskManager] = {}
self._flower = None
self.baseDir = os.path.dirname(__file__)
StratusCore.__init__(self,
configSpec,
internal_clients=False,
**kwargs)
self.parms.update(type="celery")
self.logger = StratusLogger.getLogger()
self.logger.info(f"Starting CeleryCore with parms: {self.parms}")
if self.parm('flower', False): self._startFlower()
def getCeleryCore(self, core: StratusCore, **kwargs) -> StratusCore:
for key, core_celery_params in core.config.items():
if core_celery_params.get('type') == 'celery':
celery_settings = core_celery_params.get("settings")
if celery_settings is not None:
return StratusCore(celery_settings)
return core
def initHandler(self, clientSpec: Dict[str, Dict]):
if self._handlers is None:
hspec: Dict[str, Dict] = {
clientSpec['name']: clientSpec,
"stratus": {
'type': "celery",
'name': "stratus"
}
}
self.core = StratusCore(hspec)
self._handlers = Handlers(self.core, hspec)
self._name, handlerSpec = list(hspec.items())[0]
self._handler: Handler = self._handlers.available[self._name]
request_parms = dict(request='getCapabilities',
service='WPS',
identifier='epas')
return self.execJsonRequest(self.host_address, request_parms)
return {op.name: str(op) for op in self.wpsRequest.operations}
def log(self, msg: str):
self.logger.info("[RP] " + msg)
if __name__ == "__main__":
from stratus.util.test import TestDataManager as mgr
HERE = os.path.dirname(os.path.abspath(__file__))
SETTINGS_FILE = os.path.join(HERE, "client_test_settings.ini")
core = StratusCore(SETTINGS_FILE)
client = core.getClient()
local_request = dict(domain=[{
"name": "d0",
"lat": {
"start": 50,
"end": 55,
"system": "values"
},
"lon": {
"start": 40,
"end": 42,
"system": "values"
},
"time": {
f"COMPLETED TASK: taskID: {wtask.id}, outputID: {output_id}, nodes: {list(self.ids)}, exception: {wtask.taskHandle.exception()}, status: {wtask.taskHandle.status()}"
)
if wtask.id == output_id:
self.result = wtask.taskHandle
except Exception as err:
self._status = Status.ERROR
self.result = FailedTask(err)
return completed
if __name__ == "__main__":
from stratus.app.core import StratusCore
from stratus.util.test import TestDataManager as mgr
settings = dict(stratus=dict(type="endpoint"))
core = StratusCore(settings)
client = core.getClient()
client.init()
request = dict(domain=[{
"name": "d0",
"lat": {
"start": 50,
"end": 55,
"system": "values"
},
"lon": {
"start": 40,
"end": 42,
"system": "values"
},
"time": {
import time
from stratus.app.core import StratusCore
import MODIS_Aggregation.cloud_fraction_aggregate as modis
if __name__ == "__main__":
start = time.time()
# Startup a Stratus zmq client and connect to a server on localhost
settings = dict(stratus=dict(type="rest",
client_address="127.0.0.1",
host="127.0.0.1",
port="5000",
api="core"))
stratus = StratusCore(settings)
client = stratus.getClient()
# M03_dir = "/Users/lakshmipriyanka/Project/MODIS_Aggregation/resources/data/input_data_sample/MYD03/"
# M06_dir = "/Users/lakshmipriyanka/Project/MODIS_Aggregation/resources/data/input_data_sample/MYD06/"
# requestSpec = dict(
# input=dict(path1=M03_dir, path2=M06_dir, name1=["Latitude", "Longitude"], name2=["Cloud_Mask_1km"]),
# operation=[dict(name="xop:cloudFraction")]
# )
requestSpec = dict(input=dict(area=["Latitude", "Longitude"],
cloud_mask=["Cloud_Mask_1km"]),
operation=[dict(name="xop:cloudFraction")])
# Submit the request to the server and wait for the result
def __init__(self, core: StratusCore, type: str, **kwargs):
StratusClient.__init__(self, type, **kwargs)
self.app: StratusAppBase = core.getApplication()
from stratus.handlers.zeromq.app import StratusApp from stratus.app.core import StratusCore import os HERE: str = os.path.dirname(os.path.abspath(__file__)) SETTINGS_FILE: str = os.path.join( HERE, "server_settings.ini" ) if __name__ == '__main__': # Start up a STRATUS server as configured in the settings file core: StratusCore = StratusCore(SETTINGS_FILE) app: StratusApp = core.getApplication() app.run()
from stratus_endpoint.handler.base import TaskHandle, TaskResult
from typing import Sequence, List, Dict, Mapping, Optional, Any
from edas.process.test import TestDataManager as mgr
import os, xarray as xa
from stratus.app.core import StratusCore
HERE: str = os.path.dirname(os.path.abspath(__file__))
SETTINGS_FILE: str = os.path.join(HERE, "edas_endpoint_settings.ini")
if __name__ == "__main__":
stratus = StratusCore(SETTINGS_FILE)
client = stratus.getClient()
time_range = {
"start": "1980-01-01",
"end": "2001-12-31",
"crs": "timestamps"
}
uri = mgr.getAddress("merra2", "tas")
domains = [f"d{i}" for i in range(4)]
requestSpec = dict(domain=[
dict(name="d0",
lat=dict(start=20, end=30, system="values"),
lon=dict(start=0, end=10, system="values"),
time=time_range),
dict(name="d1",
lat=dict(start=30, end=40, system="values"),
lon=dict(start=10, end=20, system="values"),
time=time_range),
dict(name="d2",
lat=dict(start=50, end=60, system="values"),
tb = traceback.format_exc()
self.logger.error("@@STRATUS-APP: Execution error: " + str(ex))
self.logger.error(tb)
response = {"status": "error", "error": str(ex), "traceback": tb}
self.sendResponseMessage(StratusResponse(rid, response))
def updateInteractions(self):
self.processRequests()
self.processResults()
def term(self, msg):
self.logger.info("@@STRATUS-APP: !!EDAS Shutdown: " + msg)
self.active = False
self.auth.stop()
self.logger.info("@@STRATUS-APP: QUIT PythonWorkerPortal")
try:
self.request_socket.close()
except Exception:
pass
self.logger.info("@@STRATUS-APP: CLOSE request_socket")
self.responder.close_connection()
self.logger.info("@@STRATUS-APP: TERM responder")
self.shutdown()
self.logger.info("@@STRATUS-APP: shutdown complete")
if __name__ == "__main__":
core = StratusCore("test_settings1.ini")
app = core.getApplication()
app.start()
from stratus_endpoint.handler.base import TaskHandle, TaskResult
from typing import Sequence, List, Dict, Mapping, Optional, Any
from edas.process.test import TestDataManager as mgr
import xarray as xa
from stratus.app.core import StratusCore
from stratus.app.operations import ClientOpSet
settings = dict( stratus=dict(type="zeromq", request_port="4556", response_port="4557" ),
edas=dict( type="endpoint", module="edas.stratus.endpoint", object="EDASEndpoint" ) )
core = StratusCore(settings)
app = core.getApplication()
request = { "edas:domain": [ { "name": "d0", "time": {"start": "1980-01-01", "end": "2001-12-31", "crs": "timestamps"} } ],
"edas:input": [ { "uri": "collection:merra2", "name": "tas:v1", "domain": "d1" } ],
"operation": [ { "name": "edas:ave", "input": "v1", "axis": "yt", "result": "v1ave" },
{ "name": "edas:diff", "input": ["v1", "v1ave"] } ] }
clientOpsets: Dict[str, ClientOpSet] = app.geClientOpsets(request)
distributed_opSets = app.distributeOps(clientOpsets)
from stratus.app.core import StratusCore
import os
HERE = os.path.dirname(os.path.abspath(__file__))
SETTINGS_FILE = os.path.join(HERE, "edas_rest_zmq_settings.ini")
if __name__ == '__main__':
core = StratusCore(SETTINGS_FILE)
app = core.getApplication()
app.run()
from stratus.app.core import StratusCore
from typing import List, Dict, Any, Sequence, BinaryIO, TextIO, ValuesView, Optional
from stratus_endpoint.handler.base import TaskHandle
import os
testEndpoint = dict(type="endpoint",
module="stratus.handlers.endpoint.test",
object="TestEndpoint1")
if __name__ == "__main__":
settings = dict(stratus=dict(type="test"),
test1=testEndpoint,
test2=testEndpoint,
test3=testEndpoint)
stratus = StratusCore(settings)
app = stratus.getApplication()
operation = [
dict(name='test1:op', result="r1", cid="C0", workTime="3.0"),
dict(name='test2:op', result="r2", cid="C1", workTime="6.0"),
dict(name='test3:op',
input=["r1", "r2"],
result="r3",
cid="C2",
workTime="1.0")
]
request = dict(operation=operation, rid="R0", cid="C0")
app.submitWorkflow(request)
for taskHandle in taskHandles.values():
from stratus.app.core import StratusCore
import os
HERE = os.path.dirname(os.path.abspath(__file__))
SETTINGS_FILE = os.path.join(HERE, "settings.ini")
if __name__ == "__main__":
stratus = StratusCore(SETTINGS_FILE)
server = stratus.getClient()
variables = [dict(name='tas:v0', uri='collection://merra2')]
bounds = [dict(axis='lat', start=-50, end=50, crs='values')]
domains = [dict(name='d0', bounds=bounds)]
operations = [dict(name='hpda.test1', axis='t', input='v0', domain='d0')]
request = dict(variables=variables, domains=domains, operations=operations)
response = server.request("exe", request=request)
print(response)
response = server.request("stat", id=response['id'])
print(response)
response = server.request("kill", id=response['id'])
print(response)
