pddl-planning-service-client
Version:
PDDL Planning Service clients
143 lines • 6.21 kB
JavaScript
/* --------------------------------------------------------------------------------------------
* Copyright (c) Jan Dolejsi. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
* ------------------------------------------------------------------------------------------ */
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.PlannerPackagePreviewService = void 0;
const PlannerService_1 = require("./PlannerService");
const url_1 = require("url");
const httpUtils_1 = require("./httpUtils");
/** Wraps the `/package/xyz/solve` planning-as-a-service web service interface. */
class PlannerPackagePreviewService extends PlannerService_1.PlannerService {
constructor(plannerUrl, plannerConfiguration, providerConfiguration) {
super(plannerUrl, plannerConfiguration, providerConfiguration);
}
createUrl() {
let url = this.plannerPath;
if (this.plannerConfiguration.options) {
url = `${url}?${this.plannerConfiguration.options}`;
}
return url;
}
getTimeout() {
return 20;
}
createRequestBody(domainFileInfo, problemFileInfo) {
let body = {
domain: domainFileInfo.getText(),
problem: problemFileInfo.getText()
};
body = Object.assign(body, this.plannerConfiguration);
return Promise.resolve(body);
}
async processServerResponseBody(origUrl, responseBody, planParser, callbacks) {
const status = responseBody.status;
const result = responseBody.result;
if (result && isInstanceOfSyncServerResponseResult(result)) {
const res = result;
!isEmpty(res.output) && typeof (res.output) === "string" && callbacks.handleOutput(res.output + '\n');
res.stdout && callbacks.handleOutput(res.stdout + '\n');
res.stderr && callbacks.handleOutput("Error: " + res.stderr + '\n');
}
if (status === "PENDING") {
await sleep(500);
return await this.checkForResults(origUrl, planParser, callbacks);
}
else if (status === "error" || responseBody.Error) {
if (result) {
const res = result;
const resultError = res.error;
if (resultError) {
callbacks.handleOutput(resultError);
}
return [];
}
else if (responseBody.Error) {
throw new Error(responseBody.Error);
}
else {
throw new Error("An error occurred while solving the planning problem: " + JSON.stringify(result));
}
}
else if (status === undefined) {
if (result !== undefined) {
const urlQuery = result;
if (typeof urlQuery === "string") {
const resultUrl = new url_1.URL(urlQuery, origUrl).toString();
return await this.checkForResults(resultUrl, planParser, callbacks);
}
else {
throw new Error("Element 'result should be a /check... url.");
}
}
else if (Object.keys(responseBody).some(key => key.includes('plan'))) {
const responseBody1 = responseBody;
responseBody1.stdout && callbacks.handleOutput(responseBody1.stdout + '\n');
responseBody1.stderr && callbacks.handleOutput("Error: " + responseBody1.stderr + '\n');
Object.keys(responseBody)
.filter(key => key.includes('plan'))
.forEach(key => {
const planText = responseBody1[key];
planParser.appendBuffer(planText);
planParser.onPlanFinished();
});
const plans = planParser.getPlans();
if (plans.length > 0) {
callbacks.handlePlan(plans[0]);
}
else {
callbacks.handleOutput('No plan found in the planner output.\n');
}
return plans;
}
else {
const responseBody1 = responseBody;
responseBody1.stdout && callbacks.handleOutput(responseBody1.stdout + '\n');
responseBody1.stderr && callbacks.handleOutput("Error: " + responseBody1.stderr + '\n');
throw new Error("Missing 'result' or '*plan*' elements.");
}
}
else if (status === "ok" && result) {
const res = result;
if (res.output) {
Object.keys(res.output).forEach(key => {
const planText = res.output[key];
planParser.appendBuffer(planText);
planParser.onPlanFinished();
});
}
const plans = planParser.getPlans();
if (plans.length > 0) {
callbacks.handlePlan(plans[0]);
}
else {
callbacks.handleOutput(`Planner output: ${JSON.stringify(res.output)}`);
callbacks.handleOutput('No plan found in the planner output.\n');
}
return plans;
}
else {
throw new Error(`Planner service failed with status ${status}.`);
}
}
async checkForResults(origUrl, planParser, callbacks) {
console.log(`Checking for results at ${origUrl} ...`);
const response = await (0, httpUtils_1.getJson)(new url_1.URL(origUrl));
return await this.processServerResponseBody(origUrl, response, planParser, callbacks);
}
}
exports.PlannerPackagePreviewService = PlannerPackagePreviewService;
function sleep(ms) {
return new Promise(resolve => {
setTimeout(resolve, ms);
});
}
function isInstanceOfSyncServerResponseResult(object) {
return typeof (object) !== "string";
}
// eslint-disable-next-line @typescript-eslint/no-explicit-any
function isEmpty(obj) {
return !obj || Object.keys(obj).length === 0;
}
//# sourceMappingURL=PlannerPackagePreviewService.js.map