knowledgepixels/nanopub-query | Build 17795838363 | com/knowledgepixels/query/MainVerticle.java | Coveralls

1

package com.knowledgepixels.query;

2

3

import java.io.InputStream;

4

import java.net.URLEncoder;

5

import java.util.ArrayList;

6

import java.util.Collections;

7

import java.util.List;

8

import java.util.Map.Entry;

9

import java.util.Scanner;

10

import java.util.concurrent.Executors;

11

import java.util.concurrent.TimeUnit;

12

13

import org.eclipse.rdf4j.model.Value;

14

15

import com.github.jsonldjava.shaded.com.google.common.base.Charsets;

16

import com.knowledgepixels.query.GrlcSpec.InvalidGrlcSpecException;

17

18

import io.micrometer.prometheus.PrometheusMeterRegistry;

19

import io.vertx.core.AbstractVerticle;

20

import io.vertx.core.Future;

21

import io.vertx.core.MultiMap;

22

import io.vertx.core.Promise;

23

import io.vertx.core.buffer.Buffer;

24

import io.vertx.core.http.HttpClient;

25

import io.vertx.core.http.HttpClientOptions;

26

import io.vertx.core.http.HttpMethod;

27

import io.vertx.core.http.HttpServer;

28

import io.vertx.core.http.HttpServerResponse;

29

import io.vertx.core.http.PoolOptions;

30

import io.vertx.ext.web.Router;

31

import io.vertx.ext.web.RoutingContext;

32

import io.vertx.ext.web.handler.CorsHandler;

33

import io.vertx.ext.web.handler.StaticHandler;

34

import io.vertx.ext.web.proxy.handler.ProxyHandler;

35

import io.vertx.httpproxy.Body;

36

import io.vertx.httpproxy.HttpProxy;

37

import io.vertx.httpproxy.ProxyContext;

38

import io.vertx.httpproxy.ProxyInterceptor;

39

import io.vertx.httpproxy.ProxyRequest;

40

import io.vertx.httpproxy.ProxyResponse;

41

import io.vertx.micrometer.PrometheusScrapingHandler;

42

import io.vertx.micrometer.backends.BackendRegistries;

43

import org.slf4j.Logger;

44

import org.slf4j.LoggerFactory;

45

46

47

// TODO merge this class with GrlcQuery of Nanodash and move to a library like nanopub-java

48

/**

49

 * Main verticle that coordinates the incoming HTTP requests.

50

*/

51

@GeneratedFlagForDependentElements

52

public class MainVerticle extends AbstractVerticle {

53

54

    private static String css = null;

55

56

    private static final Logger log = LoggerFactory.getLogger(MainVerticle.class);

57

58

/**

59

     * Start the main verticle.

60

61

     * @param startPromise the promise to complete when the verticle is started

62

     * @throws Exception if an error occurs during startup

63

*/

64

    @Override

65

    public void start(Promise<Void> startPromise) throws Exception {

66

        HttpClient httpClient = vertx.createHttpClient(

67

                new HttpClientOptions()

68

                        .setConnectTimeout(Utils.getEnvInt("NANOPUB_QUERY_VERTX_CONNECT_TIMEOUT", 1000))

69

                        .setIdleTimeoutUnit(TimeUnit.SECONDS)

70

                        .setIdleTimeout(Utils.getEnvInt("NANOPUB_QUERY_VERTX_IDLE_TIMEOUT", 60))

71

                        .setReadIdleTimeout(Utils.getEnvInt("NANOPUB_QUERY_VERTX_IDLE_TIMEOUT", 60))

72

                        .setWriteIdleTimeout(Utils.getEnvInt("NANOPUB_QUERY_VERTX_IDLE_TIMEOUT", 60)),

73

                new PoolOptions().setHttp1MaxSize(200).setHttp2MaxSize(200)

74

);

75

76

        HttpServer proxyServer = vertx.createHttpServer();

77

        Router proxyRouter = Router.router(vertx);

78

        proxyRouter.route().handler(CorsHandler.create().addRelativeOrigin(".*"));

79

80

        // Metrics

81

        final var metricsHttpServer = vertx.createHttpServer();

82

        final var metricsRouter = Router.router(vertx);

83

        metricsHttpServer.requestHandler(metricsRouter).listen(9394);

84

85

        final var metricsRegistry = (PrometheusMeterRegistry) BackendRegistries.getDefaultNow();

86

        final var collector = new MetricsCollector(metricsRegistry);

87

        metricsRouter.route("/metrics").handler(PrometheusScrapingHandler.create(metricsRegistry));

88

        // ----------

89

        // This part is only used if the redirection is not done through Nginx.

90

        // See nginx.conf and this bug report: https://github.com/eclipse-rdf4j/rdf4j/discussions/5120

91

        HttpProxy rdf4jProxy = HttpProxy.reverseProxy(httpClient);

92

        String proxy = Utils.getEnvString("RDF4J_PROXY_HOST", "rdf4j");

93

        int proxyPort = Utils.getEnvInt("RDF4J_PROXY_PORT", 8080);

94

        rdf4jProxy.origin(proxyPort, proxy);

95

97

98

            @Override

99

            @GeneratedFlagForDependentElements

100

            public Future<ProxyResponse> handleProxyRequest(ProxyContext context) {

101

                ProxyRequest request = context.request();

102

                request.setURI(request.getURI().replaceAll("/", "_").replaceFirst("^_repo_", "/rdf4j-server/repositories/"));

103

                // For later to try to get HTML tables out:

104

//                                if (request.headers().get("Accept") == null) {

105

//                                        request.putHeader("Accept", "text/html");

106

//                                }

107

//                                request.putHeader("Accept", "application/json");

108

                return ProxyInterceptor.super.handleProxyRequest(context);

109

110

111

            @Override

112

            @GeneratedFlagForDependentElements

113

            public Future<Void> handleProxyResponse(ProxyContext context) {

114

                ProxyResponse resp = context.response();

115

                resp.putHeader("Access-Control-Allow-Origin", "*");

116

                resp.putHeader("Access-Control-Allow-Methods", "POST, GET, OPTIONS");

117

                // For later to try to get HTML tables out:

118

//                                String acceptHeader = context.request().headers().get("Accept");

119

//                                if (acceptHeader != null && acceptHeader.contains("text/html")) {

120

//                                        resp.putHeader("Content-Type", "text/html");

121

//                                        resp.setBody(Body.body(Buffer.buffer("<html><body><strong>test</strong></body></html>")));

122

//                                }

123

                return ProxyInterceptor.super.handleProxyResponse(context);

124

125

126

});

127

        // ----------

128

129

        proxyRouter.route(HttpMethod.GET, "/repo").handler(req -> handleRedirect(req, "/repo"));

130

        proxyRouter.route(HttpMethod.GET, "/repo/*").handler(ProxyHandler.create(rdf4jProxy));

131

        proxyRouter.route(HttpMethod.POST, "/repo/*").handler(ProxyHandler.create(rdf4jProxy));

132

        proxyRouter.route(HttpMethod.HEAD, "/repo/*").handler(ProxyHandler.create(rdf4jProxy));

133

        proxyRouter.route(HttpMethod.OPTIONS, "/repo/*").handler(ProxyHandler.create(rdf4jProxy));

134

        proxyRouter.route(HttpMethod.GET, "/tools/*").handler(req -> {

135

            final String yasguiPattern = "^/tools/([a-zA-Z0-9-_]+)(/([a-zA-Z0-9-_]+))?/yasgui\\.html$";

136

            if (req.normalizedPath().matches(yasguiPattern)) {

137

                String repo = req.normalizedPath().replaceFirst(yasguiPattern, "$1$2");

138

                req.response()

139

                        .putHeader("content-type", "text/html")

140

                        .end("<!DOCTYPE html>\n"

141

                                + "<html lang=\"en\">\n"

142

                                + "<head>\n"

143

                                + "<meta charset=\"utf-8\">\n"

144

                                + "<meta http-equiv=\"X-UA-Compatible\" content=\"IE=edge\">\n"

145

                                + "<meta name=\"viewport\" content=\"width=device-width, initial-scale=1\">\n"

146

                                + "<title>Nanopub Query SPARQL Editor for repository: " + repo + "</title>\n"

147

                                + "<link rel=\"stylesheet\" href=\"/style.css\">\n"

148

                                + "<link href='https://cdn.jsdelivr.net/yasgui/2.6.1/yasgui.min.css' rel='stylesheet' type='text/css'/>\n"

149

                                + "<style>.yasgui .endpointText {display:none !important;}</style>\n"

150

                                + "<script type=\"text/javascript\">localStorage.clear();</script>\n"

151

                                + "</head>\n"

152

                                + "<body>\n"

153

                                + "<h3>Nanopub Query SPARQL Editor for repository: " + repo + "</h3>\n"

154

                                + "<div id='yasgui'></div>\n"

155

                                + "<script src='https://cdn.jsdelivr.net/yasgui/2.6.1/yasgui.min.js'></script>\n"

156

                                + "<script type=\"text/javascript\">\n"

157

                                + "var yasgui = YASGUI(document.getElementById(\"yasgui\"), {\n"

158

                                + "  yasqe:{sparql:{endpoint:'/repo/" + repo + "'},value:'" + Utils.defaultQuery.replaceAll("\n", "\\\\n") + "'}\n"

159

                                + "});\n"

160

                                + "</script>\n"

161

                                + "</body>\n"

162

                                + "</html>");

163

            } else {

164

                req.response()

165

                        .putHeader("content-type", "text/plain")

166

                        .setStatusCode(404)

167

                        .end("not found");

168

169

});

170

        proxyRouter.route(HttpMethod.GET, "/page").handler(req -> handleRedirect(req, "/page"));

171

        proxyRouter.route(HttpMethod.GET, "/page/*").handler(req -> {

172

            final String pagePattern = "^/page/([a-zA-Z0-9-_]+)(/([a-zA-Z0-9-_]+))?$";

173

            if (req.normalizedPath().matches(pagePattern)) {

174

                String repo = req.normalizedPath().replaceFirst(pagePattern, "$1$2");

175

                req.response()

176

                        .putHeader("content-type", "text/html")

177

                        .end("<!DOCTYPE html>\n"

178

                                + "<html lang=\"en\">\n"

179

                                + "<head>\n"

180

                                + "<meta charset=\"utf-8\">\n"

181

                                + "<meta http-equiv=\"X-UA-Compatible\" content=\"IE=edge\">\n"

182

                                + "<meta name=\"viewport\" content=\"width=device-width, initial-scale=1\">\n"

183

                                + "<title>Nanopub Query repo: " + repo + "</title>\n"

184

                                + "<link rel=\"stylesheet\" href=\"/style.css\">\n"

185

                                + "</head>\n"

186

                                + "<body>\n"

187

                                + "<h3>Nanopub Query repo: " + repo + "</h3>\n"

188

                                + "<p>Endpoint: <a href=\"/repo/" + repo + "\">/repo/" + repo + "</a></p>"

189

                                + "<p>YASGUI: <a href=\"/tools/" + repo + "/yasgui.html\">/tools/" + repo + "/yasgui.hml</a></p>"

190

                                + "</body>\n"

191

                                + "</html>");

192

            } else {

193

                req.response()

194

                        .putHeader("content-type", "text/plain")

195

                        .setStatusCode(404)

196

                        .end("not found");

197

198

});

199

        proxyRouter.route(HttpMethod.GET, "/").handler(req -> {

200

            String repos = "";

201

            List<String> repoList = new ArrayList<>(TripleStore.get().getRepositoryNames());

202

            Collections.sort(repoList);

203

            for (String s : repoList) {

204

                if (s.startsWith("pubkey_") || s.startsWith("type_")) continue;

205

                repos += "<li><code><a href=\"/page/" + s + "\">" + s + "</a></code></li>";

206

207

            String pinnedApisValue = Utils.getEnvString("NANOPUB_QUERY_PINNED_APIS", "");

208

            String[] pinnedApis = pinnedApisValue.split(" ");

209

            String pinnedApiLinks = "";

210

            if (!pinnedApisValue.isEmpty()) {

211

                for (String s : pinnedApis) {

212

                    pinnedApiLinks = pinnedApiLinks + "<li><a href=\"openapi/?url=spec/" + s + "%3Fapi-version=latest\">" + s.replaceFirst("^.*/", "") + "</a></li>";

213

214

                pinnedApiLinks = "<p>Pinned APIs:</p>\n" +

215

                        "<ul>\n" +

216

                        pinnedApiLinks +

217

                        "</ul>\n";

218

219

            req.response()

220

                    .putHeader("content-type", "text/html")

221

                    .end("<!DOCTYPE html>\n"

222

                            + "<html lang='en'>\n"

223

                            + "<head>\n"

224

                            + "<title>Nanopub Query</title>\n"

225

                            + "<meta charset='utf-8'>\n"

226

                            + "<link rel=\"stylesheet\" href=\"/style.css\">\n"

227

                            + "</head>\n"

228

                            + "<body>\n"

229

                            + "<h1>Nanopub Query</h1>"

230

                            + "<p>General repos:</p>"

231

                            + "<ul>" + repos + "</ul>"

232

                            + "<p>Specific repos:</p>"

233

                            + "<ul>"

234

                            + "<li><a href=\"/pubkeys\">Pubkey Repos</a></li>"

235

                            + "<li><a href=\"/types\">Type Repos</a></li>"

236

                            + "</ul>"

237

                            + pinnedApiLinks

238

                            + "</body>\n"

239

                            + "</html>");

240

});

241

        proxyRouter.route(HttpMethod.GET, "/pubkeys").handler(req -> {

242

            String repos = "";

243

            List<String> repoList = new ArrayList<>(TripleStore.get().getRepositoryNames());

244

            Collections.sort(repoList);

245

            for (String s : repoList) {

246

                if (!s.startsWith("pubkey_")) continue;

247

                String hash = s.replaceFirst("^([a-zA-Z0-9-]+)_([a-zA-Z0-9-_]+)$", "$2");

248

                Value hashObj = Utils.getObjectForHash(hash);

249

                String label;

250

                if (hashObj == null) {

251

                    label = "";

252

                } else {

253

                    label = " (" + Utils.getShortPubkeyName(hashObj.stringValue()) + ")";

254

255

                s = s.replaceFirst("^([a-zA-Z0-9-]+)_([a-zA-Z0-9-_]+)$", "$1/$2");

256

                repos += "<li><code><a href=\"/page/" + s + "\">" + s + "</a>" + label + "</code></li>";

257

258

            req.response()

259

                    .putHeader("content-type", "text/html")

260

                    .end("<!DOCTYPE html>\n"

261

                            + "<html lang='en'>\n"

262

                            + "<head>\n"

263

                            + "<title>Nanopub Query: Pubkey Repos</title>\n"

264

                            + "<meta charset='utf-8'>\n"

265

                            + "<link rel=\"stylesheet\" href=\"/style.css\">\n"

266

                            + "</head>\n"

267

                            + "<body>\n"

268

                            + "<h3>Pubkey Repos</h3>"

269

                            + "<p>Repos:</p>"

270

                            + "<ul>" + repos + "</ul>"

271

                            + "</body>\n"

272

                            + "</html>");

273

});

274

        proxyRouter.route(HttpMethod.GET, "/types").handler(req -> {

275

            String repos = "";

276

            List<String> repoList = new ArrayList<>(TripleStore.get().getRepositoryNames());

277

            Collections.sort(repoList);

278

            for (String s : repoList) {

279

                if (!s.startsWith("type_")) continue;

280

                String hash = s.replaceFirst("^([a-zA-Z0-9-]+)_([a-zA-Z0-9-_]+)$", "$2");

281

                Value hashObj = Utils.getObjectForHash(hash);

282

                String label;

283

                if (hashObj == null) {

284

                    label = "";

285

                } else {

286

                    label = " (" + hashObj.stringValue() + ")";

287

288

                s = s.replaceFirst("^([a-zA-Z0-9-]+)_([a-zA-Z0-9-_]+)$", "$1/$2");

289

                repos += "<li><code><a href=\"/page/" + s + "\">" + s + "</a>" + label + "</code></li>";

290

291

            req.response()

292

                    .putHeader("content-type", "text/html")

293

                    .end("<!DOCTYPE html>\n"

294

                            + "<html lang='en'>\n"

295

                            + "<head>\n"

296

                            + "<title>Nanopub Query: Type Repos</title>\n"

297

                            + "<meta charset='utf-8'>\n"

298

                            + "<link rel=\"stylesheet\" href=\"/style.css\">\n"

299

                            + "</head>\n"

300

                            + "<body>\n"

301

                            + "<h3>Type Repos</h3>"

302

                            + "<p>Repos:</p>"

303

                            + "<ul>" + repos + "</ul>"

304

                            + "</body>\n"

305

                            + "</html>");

306

});

307

        proxyRouter.route(HttpMethod.GET, "/style.css").handler(req -> {

308

            if (css == null) {

309

                css = getResourceAsString("style.css");

310

311

            req.response().end(css);

312

});

313

314

        proxyRouter.route(HttpMethod.GET, "/grlc-spec/*").handler(req -> {

315

            try {

316

                GrlcSpec gsp = new GrlcSpec(req.normalizedPath(), req.queryParams());

317

                req.response().putHeader("content-type", "text/yaml").end(gsp.getSpec());

318

            } catch (InvalidGrlcSpecException ex) {

319

                req.response().setStatusCode(400).end(ex.getMessage());

320

            } catch (Exception ex) {

321

                req.response().setStatusCode(500).end("Unexpected error: " + ex.getMessage());

322

323

});

324

325

        proxyRouter.route(HttpMethod.GET, "/openapi/spec/*").handler(req -> {

326

            try {

327

                OpenApiSpecPage osp = new OpenApiSpecPage(req.normalizedPath(), req.queryParams());

328

                req.response().putHeader("content-type", "text/yaml").end(osp.getSpec());

329

            } catch (InvalidGrlcSpecException ex) {

330

                req.response().setStatusCode(400).end("Invlid grlc API definition: " + ex.getMessage());

331

            } catch (Exception ex) {

332

                req.response().setStatusCode(500).end("Unexpected error: " + ex.getMessage());

333

334

});

335

336

        proxyRouter.route("/openapi/*").handler(StaticHandler.create("com/knowledgepixels/query/swagger"));

337

338

        HttpProxy grlcProxy = HttpProxy.reverseProxy(httpClient);

339

        grlcProxy.origin(80, "grlc");

341

342

            @Override

343

            @GeneratedFlagForDependentElements

344

            public Future<ProxyResponse> handleProxyRequest(ProxyContext context) {

345

                final String apiPattern = "^/api/(RA[a-zA-Z0-9-_]{43})/([a-zA-Z0-9-_]+)([?].*)?$";

346

                if (context.request().getURI().matches(apiPattern)) {

347

                    String artifactCode = context.request().getURI().replaceFirst(apiPattern, "$1");

348

                    String queryName = context.request().getURI().replaceFirst(apiPattern, "$2");

349

                    String grlcUrlParams = "";

350

                    String grlcSpecUrlParams = "";

351

                    MultiMap pm = context.request().proxiedRequest().params();

352

                    for (Entry<String, String> e : pm) {

353

                        if (e.getKey().equals("api-version")) {

354

                            grlcSpecUrlParams += "&" + e.getKey() + "=" + URLEncoder.encode(e.getValue(), Charsets.UTF_8);

355

                        } else {

356

                            grlcUrlParams += "&" + e.getKey() + "=" + URLEncoder.encode(e.getValue(), Charsets.UTF_8);

357

358

359

                    String url = "/api-url/" + queryName +

360

                            "?specUrl=" + URLEncoder.encode(GrlcSpec.nanopubQueryUrl + "grlc-spec/" + artifactCode + "/?" +

361

                            grlcSpecUrlParams, Charsets.UTF_8) + grlcUrlParams;

362

                    context.request().setURI(url);

363

364

                return context.sendRequest();

365

366

367

            @Override

368

            @GeneratedFlagForDependentElements

369

            public Future<Void> handleProxyResponse(ProxyContext context) {

370

                // To avoid double entries:

371

                context.response().headers().remove("Access-Control-Allow-Origin");

372

                return context.sendResponse();

373

374

375

});

376

377

        HttpProxy grlcxProxy = HttpProxy.reverseProxy(httpClient);

378

        grlcxProxy.origin(proxyPort, proxy);

379

381

382

            @Override

383

            @GeneratedFlagForDependentElements

384

            public Future<ProxyResponse> handleProxyRequest(ProxyContext context) {

385

                final ProxyRequest req = context.request();

386

                final String apiPattern = "^/apix/(RA[a-zA-Z0-9-_]{43})/([a-zA-Z0-9-_]+)([?].*)?$";

387

                if (req.getURI().matches(apiPattern)) {

388

                    try {

389

                        GrlcSpec grlcSpec = new GrlcSpec(req.getURI(), req.proxiedRequest().params());

390

                        req.setMethod(HttpMethod.POST);

391

392

                        // Variant 1:

393

                        req.putHeader("Content-Type", "application/sparql-query");

394

                        req.setBody(Body.body(Buffer.buffer(grlcSpec.expandQuery())));

395

                        // Variant 2:

396

                        //req.putHeader("Content-Type", "application/x-www-form-urlencoded");

397

                        //req.setBody(Body.body(Buffer.buffer("query=" + URLEncoder.encode(grlcSpec.getExpandedQueryContent(), Charsets.UTF_8))));

398

399

                        req.setURI("/rdf4j-server/repositories/" + grlcSpec.getRepoName());

400

                        log.info("Forwarding apix request to /rdf4j-server/repositories/", grlcSpec.getRepoName());

401

                    } catch (InvalidGrlcSpecException ex) {

402

                        return Future.succeededFuture(context.request()

403

                                .response()

404

                                .setStatusCode(400)

405

                                .putHeader("Content-Type", "text/plain")

406

                                .setBody(Body.body(Buffer.buffer("Bad request: " + ex.getMessage()))));

407

                    } catch (Exception ex) {

408

                        return Future.succeededFuture(context.request()

409

                                .response()

410

                                .setStatusCode(500)

411

                                .putHeader("Content-Type", "text/plain")

412

                                .setBody(Body.body(Buffer.buffer("Unexpected error: " + ex.getMessage()))));

413

414

415

                return ProxyInterceptor.super.handleProxyRequest(context);

416

417

418

            @Override

419

            @GeneratedFlagForDependentElements

420

            public Future<Void> handleProxyResponse(ProxyContext context) {

421

                log.info("Receiving apix response");

422

                ProxyResponse resp = context.response();

423

                resp.putHeader("Access-Control-Allow-Origin", "*");

424

                resp.putHeader("Access-Control-Allow-Methods", "POST, GET, OPTIONS");

425

                return ProxyInterceptor.super.handleProxyResponse(context);

426

427

428

});

429

        proxyRouter.route(HttpMethod.GET, "/apix/*").handler(ProxyHandler.create(grlcxProxy));

430

431

        proxyServer.requestHandler(req -> {

432

            applyGlobalHeaders(req.response());

433

            proxyRouter.handle(req);

434

});

435

        proxyServer.listen(9393);

436

437

        proxyRouter.route("/api/*").handler(ProxyHandler.create(grlcProxy));

438

        proxyRouter.route("/static/*").handler(ProxyHandler.create(grlcProxy));

439

440

        // Periodic metrics update

441

        vertx.setPeriodic(1000, id -> collector.updateMetrics());

442

443

444

        new Thread(() -> {

445

            try {

446

                var status = StatusController.get().initialize();

447

                log.info("Current state: {}, last committed counter: {}", status.state, status.loadCounter);

448

                if (status.state == StatusController.State.LAUNCHING || status.state == StatusController.State.LOADING_INITIAL) {

449

                    // Do the initial nanopublication loading

450

                    StatusController.get().setLoadingInitial(status.loadCounter);

451

                    // Fall back to local nanopub loading if the local files are present

452

                    if (!LocalNanopubLoader.init()) {

453

                        JellyNanopubLoader.loadInitial(status.loadCounter);

454

                    } else {

455

                        log.info("Local nanopublication loading finished");

456

457

                    StatusController.get().setReady();

458

                } else {

459

                    log.info("Initial load is already done");

460

                    StatusController.get().setReady();

461

462

            } catch (Exception ex) {

463

                log.info("Initial load failed, terminating...", ex);

464

                Runtime.getRuntime().exit(1);

465

466

467

            // Start periodic nanopub loading

468

            log.info("Starting periodic nanopub loading...");

469

            var executor = Executors.newSingleThreadScheduledExecutor();

470

            executor.scheduleWithFixedDelay(

471

                    JellyNanopubLoader::loadUpdates,

472

                    JellyNanopubLoader.UPDATES_POLL_INTERVAL,

473

                    JellyNanopubLoader.UPDATES_POLL_INTERVAL,

474

                    TimeUnit.MILLISECONDS

475

);

476

        }).start();

477

478

        Runtime.getRuntime().addShutdownHook(new Thread(() -> {

479

            try {

480

                log.info("Gracefully shutting down...");

481

                TripleStore.get().shutdownRepositories();

482

                vertx.close().toCompletionStage().toCompletableFuture().get(5, TimeUnit.SECONDS);

483

                log.info("Graceful shutdown completed");

484

            } catch (Exception ex) {

485

                log.info("Graceful shutdown failed", ex);

486

487

        }));

488

489

490

    private String getResourceAsString(String file) {

491

        InputStream is = getClass().getClassLoader().getResourceAsStream("com/knowledgepixels/query/" + file);

492

        try (Scanner s = new Scanner(is).useDelimiter("\\A")) {

493

            String fileContent = s.hasNext() ? s.next() : "";

494

            return fileContent;

495

496

497

498

    private static void handleRedirect(RoutingContext req, String path) {

499

        String queryString = "";

500

        if (!req.queryParam("query").isEmpty())

501

            queryString = "?query=" + URLEncoder.encode(req.queryParam("query").get(0), Charsets.UTF_8);

502

        if (req.queryParam("for-type").size() == 1) {

503

            String type = req.queryParam("for-type").get(0);

504

            req.response().putHeader("location", path + "/type/" + Utils.createHash(type) + queryString);

505

            req.response().setStatusCode(301).end();

506

        } else if (req.queryParam("for-pubkey").size() == 1) {

507

            String type = req.queryParam("for-pubkey").get(0);

508

            req.response().putHeader("location", path + "/pubkey/" + Utils.createHash(type) + queryString);

509

            req.response().setStatusCode(301).end();

510

        } else if (req.queryParam("for-user").size() == 1) {

511

            String type = req.queryParam("for-user").get(0);

512

            req.response().putHeader("location", path + "/user/" + Utils.createHash(type) + queryString);

513

            req.response().setStatusCode(301).end();

514

515

516

517

/**

518

     * Apply headers to the response that should be present for all requests.

519

520

     * @param response The response to which the headers should be applied.

521

*/

522

    private static void applyGlobalHeaders(HttpServerResponse response) {

523

        response.putHeader("Nanopub-Query-Status", StatusController.get().getState().state.toString());

524

525

knowledgepixels / nanopub-query / 17795838363

Source File
Press 'n' to go to next uncovered line, 'b' for previous

knowledgepixels / nanopub-query / 17795838363

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous