Example usage for io.vertx.core MultiMap get

List of usage examples for io.vertx.core MultiMap get

Introduction

In this page you can find the example usage for io.vertx.core MultiMap get.

Prototype

@Nullable
String get(String name);

Source Link

Document

Returns the value of with the specified name.

Usage

From source file:org.sfs.nodes.compute.container.ImportContainer.java

License:Apache License

@Override
public void handle(final SfsRequest httpServerRequest) {

    VertxContext<Server> vertxContext = httpServerRequest.vertxContext();

    aVoid().flatMap(new Authenticate(httpServerRequest)).flatMap(new ValidateActionAdmin(httpServerRequest))
            .map(aVoid -> httpServerRequest).map(new ValidateHeaderExists(X_SFS_SRC_DIRECTORY))
            .map(new ValidateHeaderBetweenLong(X_SFS_KEEP_ALIVE_TIMEOUT, 10000, 300000))
            .map(aVoid -> fromSfsRequest(httpServerRequest)).map(new ValidateContainerPath())
            .flatMap(new LoadAccountAndContainer(vertxContext))
            .flatMap(new ValidateContainerIsEmpty(vertxContext)).flatMap(targetPersistentContainer -> {

                MultiMap headers = httpServerRequest.headers();
                String importDirectory = headers.get(X_SFS_SRC_DIRECTORY);
                String unparsedSkipPositions = headers.get(X_SFS_IMPORT_SKIP_POSITIONS);
                Set<Long> skipPositions;
                if (!isNullOrEmpty(unparsedSkipPositions)) {
                    skipPositions = from(on(',').trimResults().split(unparsedSkipPositions))
                            .transform(input -> tryParse(input)).filter(notNull()).toSet();
                } else {
                    skipPositions = new HashSet<>(0);
                }/*w ww .  j  a va2 s.  c o m*/

                return aVoid().flatMap(aVoid -> {
                    ObservableFuture<Boolean> handler = RxHelper.observableFuture();
                    vertxContext.vertx().fileSystem().exists(importDirectory, handler.toHandler());
                    return handler.map(destDirectoryExists -> {
                        if (!TRUE.equals(destDirectoryExists)) {
                            JsonObject jsonObject = new JsonObject().put("message",
                                    format("%s does not exist", importDirectory));

                            throw new HttpRequestValidationException(HTTP_BAD_REQUEST, jsonObject);
                        } else {
                            return (Void) null;
                        }
                    });
                }).flatMap(oVoid -> {
                    ObservableFuture<List<String>> handler = RxHelper.observableFuture();
                    vertxContext.vertx().fileSystem().readDir(importDirectory, handler.toHandler());
                    return handler.map(listing -> {
                        if (listing.size() <= 0) {
                            JsonObject jsonObject = new JsonObject().put("message",
                                    format("%s is empty", importDirectory));

                            throw new HttpRequestValidationException(HTTP_BAD_REQUEST, jsonObject);
                        } else {
                            return (Void) null;
                        }
                    });
                }).flatMap(aVoid -> {

                    LOGGER.info("Importing into container " + targetPersistentContainer.getId() + " from "
                            + importDirectory);

                    JournalFile journalFile = new JournalFile(get(importDirectory).resolve(DUMP_FILE_NAME));
                    return journalFile.open(vertxContext.vertx()).map(aVoid1 -> journalFile);
                }).flatMap(journalFile -> {
                    SfsVertx sfsVertx = vertxContext.vertx();
                    return journalFile.getFirstEntry(sfsVertx).map(entryOptional -> {
                        checkState(entryOptional.isPresent(), "First dump file entry is corrupt");
                        return entryOptional.get();
                    }).flatMap(entry -> entry.getMetadata(sfsVertx).map(buffer -> {
                        try {
                            return parseFrom(buffer.getBytes());
                        } catch (InvalidProtocolBufferException e) {
                            throw new RuntimeException(e);
                        }
                    }).flatMap(firstHeader -> {
                        if (firstHeader.getEncrypted()) {
                            return just(httpServerRequest).map(new ValidateHeaderExists(X_SFS_SECRET))
                                    .map(new ValidateHeaderIsBase64Encoded(X_SFS_SECRET)).map(new ToVoid<>())
                                    .map(aVoid -> {
                                        String cipherName = firstHeader.getCipherName();
                                        checkState(!isNullOrEmpty(cipherName),
                                                "Encryption is enabled by cipher name is not specified");
                                        AlgorithmDef algorithmDef = fromNameIfExists(cipherName);
                                        checkState(algorithmDef != null, "Algorithm %s not found", cipherName);
                                        return new ImportStartState(journalFile, entry.getNextHeaderPosition(),
                                                algorithmDef, base64().decode(headers.get(X_SFS_SECRET)));
                                    });
                        } else {
                            return just(new ImportStartState(journalFile, entry.getNextHeaderPosition(), null,
                                    null));
                        }
                    }));
                }).flatMap(importStartState -> {

                    JournalFile journalFile = importStartState.getJournalFile();

                    long startPosition = importStartState.getStartPosition();
                    boolean encrypted = importStartState.getAlgorithmDef() != null;
                    byte[] secret = importStartState.getSecret();
                    AlgorithmDef algorithmDef = importStartState.getAlgorithmDef();

                    httpServerRequest.startProxyKeepAlive();
                    SfsVertx sfsVertx = vertxContext.vertx();

                    return journalFile.scan(sfsVertx, startPosition, entry -> {
                        // skip over any positions that should be skipped
                        if (skipPositions.contains(entry.getHeaderPosition())) {
                            return just(true);
                        }
                        return entry.getMetadata(sfsVertx).flatMap(buffer -> {
                            try {
                                Header header = Header.parseFrom(buffer.getBytes());
                                Type type = header.getType();
                                checkState(VERSION_01.equals(type), "Type was %s, expected %s", type,
                                        VERSION_01);

                                byte[] cipherDataSalt = header.getCipherDataSalt() != null
                                        ? header.getCipherDataSalt().toByteArray()
                                        : null;
                                byte[] cipherMetadataSalt = header.getCipherMetadataSalt() != null
                                        ? header.getCipherMetadataSalt().toByteArray()
                                        : null;

                                CompressionType metadataCompressionType = header.getMetadataCompressionType();
                                checkState(
                                        NONE.equals(metadataCompressionType)
                                                || DEFLATE.equals(metadataCompressionType),
                                        "Metadata compression type was %s, expected %s",
                                        metadataCompressionType, DEFLATE);

                                CompressionType dataCompressionType = header.getDataCompressionType();
                                checkState(
                                        NONE.equals(dataCompressionType) || DEFLATE.equals(dataCompressionType),
                                        "Data compression type was %s, expected %s", dataCompressionType,
                                        DEFLATE);

                                byte[] marshaledExportObject = header.getData().toByteArray();

                                if (encrypted) {
                                    checkState(cipherMetadataSalt != null && cipherMetadataSalt.length > 0);
                                    Algorithm algorithm = algorithmDef.create(secret, cipherMetadataSalt);
                                    marshaledExportObject = algorithm.decrypt(marshaledExportObject);
                                }

                                if (DEFLATE.equals(metadataCompressionType)) {
                                    ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
                                    try (InflaterOutputStream inflaterOutputStream = new InflaterOutputStream(
                                            byteArrayOutputStream)) {
                                        inflaterOutputStream.write(marshaledExportObject);
                                    } catch (IOException e) {
                                        throw new RuntimeException(e);
                                    }
                                    marshaledExportObject = byteArrayOutputStream.toByteArray();
                                }

                                Version01 exportObject = Version01.parseFrom(marshaledExportObject);
                                ObjectPath originalObjectPath = fromPaths(exportObject.getObjectId());
                                String originalAccountName = originalObjectPath.accountName().get();
                                String originalContainerName = originalObjectPath.containerName().get();
                                String originalObjectName = originalObjectPath.objectName().get();
                                ObjectPath targetObjectPath = fromPaths(targetPersistentContainer.getId(),
                                        originalObjectName);
                                ValidatePath validatePath = new ValidateObjectPath();
                                validatePath.call(targetObjectPath);
                                String targetObjectId = targetObjectPath.objectPath().get();
                                String targetAccountName = targetObjectPath.accountName().get();
                                String targetContainerName = targetObjectPath.containerName().get();

                                return just(targetObjectId)
                                        .flatMap(new LoadObject(vertxContext, targetPersistentContainer))
                                        .map(oPersistentObject -> {
                                            if (oPersistentObject.isPresent()) {
                                                PersistentObject persistentObject = oPersistentObject.get();
                                                return persistentObject.newVersion().merge(exportObject);
                                            } else {
                                                final TransientObject transientObject = new TransientObject(
                                                        targetPersistentContainer, targetObjectId)
                                                                .setOwnerGuid(exportObject.getOwnerGuid());
                                                return transientObject.newVersion().merge(exportObject);
                                            }
                                        }).flatMap(transientVersion -> {
                                            long length = transientVersion.getContentLength().get();
                                            if (length > 0 && !transientVersion.isDeleted()) {
                                                return aVoid().flatMap(aVoid -> {

                                                    PipedReadStream pipedReadStream = new PipedReadStream();
                                                    BufferEndableWriteStream bufferStreamConsumer = new PipedEndableWriteStream(
                                                            pipedReadStream);
                                                    if (DEFLATE.equals(dataCompressionType)) {
                                                        bufferStreamConsumer = new InflaterEndableWriteStream(
                                                                bufferStreamConsumer);
                                                    }
                                                    if (encrypted) {
                                                        checkState(cipherDataSalt != null
                                                                && cipherDataSalt.length > 0);
                                                        Algorithm algorithm = algorithmDef.create(secret,
                                                                cipherDataSalt);
                                                        bufferStreamConsumer = algorithm
                                                                .decrypt(bufferStreamConsumer);
                                                    }
                                                    Observable<Void> oProducer = entry.produceData(sfsVertx,
                                                            bufferStreamConsumer);
                                                    Observable<TransientSegment> oConsumer = just(
                                                            transientVersion)
                                                                    .flatMap(new WriteNewSegment(vertxContext,
                                                                            pipedReadStream));
                                                    return combineSinglesDelayError(oProducer, oConsumer,
                                                            (aVoid1, transientSegment) -> transientSegment);
                                                }).map(transientSegment -> transientSegment.getParent());
                                            } else {
                                                return just(transientVersion);
                                            }
                                        }).doOnNext(transientVersion -> {
                                            Optional<String> oObjectManifest = transientVersion
                                                    .getObjectManifest();
                                            if (oObjectManifest.isPresent()) {
                                                String objectManifest = oObjectManifest.get();
                                                int indexOfObjectName = objectManifest.indexOf(DELIMITER);
                                                if (indexOfObjectName > 0) {
                                                    String containerName = objectManifest.substring(0,
                                                            indexOfObjectName);
                                                    // only adjust the object manifest if the manifest references objects
                                                    // in the container that was exported
                                                    if (Objects.equals(containerName, originalContainerName)) {
                                                        objectManifest = targetContainerName + DELIMITER
                                                                + objectManifest
                                                                        .substring(indexOfObjectName + 1);
                                                        transientVersion.setObjectManifest(objectManifest);
                                                    }
                                                }
                                            }
                                        }).flatMap(new PersistOrUpdateVersion(vertxContext))
                                        .flatMap(transientVersion -> {
                                            long length = transientVersion.getContentLength().get();
                                            if (length > 0 && !transientVersion.getSegments().isEmpty()) {
                                                TransientSegment latestSegment = transientVersion
                                                        .getNewestSegment().get();
                                                return just(latestSegment)
                                                        .flatMap(new AcknowledgeSegment(
                                                                httpServerRequest.vertxContext()))
                                                        .map(modified -> latestSegment.getParent());
                                            } else {
                                                return just(transientVersion);
                                            }
                                        }).flatMap(transientVersion -> {
                                            final long versionId = transientVersion.getId();
                                            XObject xObject = transientVersion.getParent();
                                            return just((PersistentObject) xObject)
                                                    .map(persistentObject -> persistentObject
                                                            .setUpdateTs(getInstance()))
                                                    .flatMap(new UpdateObject(httpServerRequest.vertxContext()))
                                                    .map(new ValidateOptimisticObjectLock())
                                                    .map(persistentObject -> persistentObject
                                                            .getVersion(versionId).get());
                                        }).map(version -> TRUE);
                            } catch (InvalidProtocolBufferException e) {
                                throw new RuntimeException(e);
                            }
                        }).onErrorResumeNext(throwable -> error(
                                new IgnorePositionRuntimeException(throwable, entry.getHeaderPosition())));
                    });
                }).doOnNext(aVoid -> LOGGER.info("Done importing into container "
                        + targetPersistentContainer.getId() + " from " + importDirectory)).map(new ToVoid<>())
                        .map(aVoid -> {
                            JsonObject jsonResponse = new JsonObject();
                            jsonResponse.put("code", HTTP_OK);
                            return jsonResponse;
                        }).onErrorResumeNext(throwable -> {
                            LOGGER.info("Failed importing into container " + targetPersistentContainer.getId()
                                    + " from " + importDirectory, throwable);
                            Optional<IgnorePositionRuntimeException> oIgnorePosition = unwrapCause(
                                    IgnorePositionRuntimeException.class, throwable);
                            if (oIgnorePosition.isPresent()) {
                                IgnorePositionRuntimeException ignorePositionRuntimeException = oIgnorePosition
                                        .get();
                                LOGGER.error("Handling Exception", ignorePositionRuntimeException);
                                long positionToIgnore = ignorePositionRuntimeException.getPosition();
                                JsonObject jsonResponse = new JsonObject();
                                skipPositions.add(positionToIgnore);
                                String joined = Joiner.on(',').join(skipPositions);
                                jsonResponse.put("code", HTTP_INTERNAL_ERROR);
                                jsonResponse.put("message", format(
                                        "If you would like to ignore this position set the %s header with the value %s",
                                        X_SFS_IMPORT_SKIP_POSITIONS, joined));
                                jsonResponse.put(X_SFS_IMPORT_SKIP_POSITIONS, joined);
                                return just(jsonResponse);
                            } else {
                                return error(throwable);
                            }
                        });

            }).single().subscribe(new ConnectionCloseTerminus<JsonObject>(httpServerRequest) {
                @Override
                public void onNext(JsonObject jsonResponse) {
                    HttpServerResponse httpResponse = httpServerRequest.response();
                    httpResponse.write(jsonResponse.encode(), UTF_8.toString()).write(DELIMITER_BUFFER);
                }
            });
}

From source file:org.sfs.nodes.compute.container.PutContainer.java

License:Apache License

@Override
public void handle(final SfsRequest httpServerRequest) {
    VertxContext<Server> vertxContext = httpServerRequest.vertxContext();
    aVoid().flatMap(new Authenticate(httpServerRequest))
            .flatMap(new ValidateActionAuthenticated(httpServerRequest)).map(aVoid -> httpServerRequest)
            .map(new ValidateHeaderBetweenInteger(X_SFS_OBJECT_INDEX_SHARDS, 1, 1024))
            .map(new ValidateHeaderBetweenInteger(X_SFS_OBJECT_INDEX_REPLICAS, 1, 6))
            .map(new ValidateHeaderBetweenInteger(X_SFS_OBJECT_REPLICAS, 1, 6))
            .map(aVoid -> fromSfsRequest(httpServerRequest)).map(new ValidateContainerPath())
            .flatMap(objectPath -> {/*w ww . ja  va2 s . c  om*/
                String accountId = objectPath.accountPath().get();
                String containerId = objectPath.containerPath().get();
                return just(accountId).flatMap(new LoadAccount(vertxContext))
                        .map(new ValidatePersistentAccountExists()).flatMap(persistentAccount -> {
                            TransientContainer transientContainer = TransientContainer
                                    .fromSfsRequest(persistentAccount, httpServerRequest)
                                    .setOwnerGuid(httpServerRequest.getUserAndRole().getUser().getId());
                            return Defer.just(transientContainer)
                                    .flatMap(new ValidateActionContainerCreate(httpServerRequest))
                                    .map(new ToVoid<>()).map(aVoid -> containerId)
                                    .flatMap(new LoadContainer(vertxContext, persistentAccount))
                                    .map(new ValidatePersistentContainerNotExists())
                                    .map(aVoid -> transientContainer)
                                    .flatMap(new PersistContainer(vertxContext))
                                    .map(new ValidateOptimisticContainerLock()).flatMap(persistentContainer -> {
                                        MultiMap headers = httpServerRequest.headers();
                                        CreateObjectIndex createObjectIndex = new CreateObjectIndex(
                                                vertxContext);
                                        if (headers.contains(X_SFS_OBJECT_INDEX_SHARDS)) {
                                            int shards = parseInt(headers.get(X_SFS_OBJECT_INDEX_SHARDS));
                                            createObjectIndex = createObjectIndex.setNumberOfShards(shards);
                                        }
                                        if (headers.contains(X_SFS_OBJECT_INDEX_REPLICAS)) {
                                            int replicas = parseInt(headers.get(X_SFS_OBJECT_INDEX_REPLICAS));
                                            createObjectIndex = createObjectIndex.setNumberOfReplicas(replicas);
                                        }
                                        return createObjectIndex.call(persistentContainer);
                                    });

                        });
            }).single().subscribe(new ConnectionCloseTerminus<PersistentContainer>(httpServerRequest) {
                @Override
                public void onNext(PersistentContainer persistentContainer) {
                    httpServerRequest.response().setStatusCode(HTTP_CREATED);
                }
            });

}

From source file:org.sfs.nodes.compute.container.VerifyRepairAllContainersExecute.java

License:Apache License

@Override
public void handle(final SfsRequest httpServerRequest) {

    VertxContext<Server> vertxContext = httpServerRequest.vertxContext();

    Defer.aVoid().flatMap(new Authenticate(httpServerRequest))
            .flatMap(new ValidateActionAdminOrSystem(httpServerRequest)).map(aVoid -> httpServerRequest)
            .map(new ToVoid<>()).flatMap(aVoid -> {
                ClusterInfo clusterInfo = vertxContext.verticle().getClusterInfo();
                Nodes nodes = vertxContext.verticle().nodes();
                MultiMap headers = httpServerRequest.headers();

                long timeout = headers.contains(Jobs.Parameters.TIMEOUT)
                        ? Long.parseLong(headers.get(Jobs.Parameters.TIMEOUT))
                        : 100;/*from  w  w  w. j a  v  a2 s . c  om*/

                String unparsedForceRemoveVolumes = headers.contains(Jobs.Parameters.FORCE_REMOVE_VOLUMES)
                        ? headers.get(Jobs.Parameters.FORCE_REMOVE_VOLUMES)
                        : null;

                MultiMap params = MultiMap.caseInsensitiveMultiMap();
                if (unparsedForceRemoveVolumes != null) {
                    params.add(Jobs.Parameters.FORCE_REMOVE_VOLUMES, unparsedForceRemoveVolumes);
                }

                TransientServiceDef transientServiceDef = clusterInfo.getCurrentMasterNode();
                MasterNode masterNode = nodes.remoteMasterNode(vertxContext, transientServiceDef);

                httpServerRequest.startProxyKeepAlive();

                return masterNode.executeJob(Jobs.ID.VERIFY_REPAIR_ALL_CONTAINERS_OBJECTS, params, timeout,
                        TimeUnit.MILLISECONDS);
            }).single().subscribe(new ConnectionCloseTerminus<Void>(httpServerRequest) {
                @Override
                public void onNext(Void aVoid) {
                    JsonObject responseJson = new JsonObject().put("code", HTTP_OK).put("message", "Success");
                    httpServerRequest.response().write(responseJson.encode(), StandardCharsets.UTF_8.toString())
                            .write(DELIMITER_BUFFER);
                }
            });
}

From source file:org.sfs.nodes.compute.container.VerifyRepairAllContainersStop.java

License:Apache License

@Override
public void handle(final SfsRequest httpServerRequest) {

    VertxContext<Server> vertxContext = httpServerRequest.vertxContext();

    Defer.aVoid().flatMap(new Authenticate(httpServerRequest))
            .flatMap(new ValidateActionAdminOrSystem(httpServerRequest)).map(aVoid -> httpServerRequest)
            .map(new ValidateHeaderExists(Jobs.Parameters.TIMEOUT))
            .map(new ValidateHeaderBetweenLong(Jobs.Parameters.TIMEOUT, 100, Long.MAX_VALUE))
            .map(new ToVoid<>()).flatMap(aVoid -> {
                ClusterInfo clusterInfo = vertxContext.verticle().getClusterInfo();
                Nodes nodes = vertxContext.verticle().nodes();
                MultiMap headers = httpServerRequest.headers();

                long timeout = headers.contains(Jobs.Parameters.TIMEOUT)
                        ? Long.parseLong(headers.get(Jobs.Parameters.TIMEOUT))
                        : 100;//from  ww w  .  ja  v a 2s .  c o m

                TransientServiceDef transientServiceDef = clusterInfo.getCurrentMasterNode();
                MasterNode masterNode = nodes.remoteMasterNode(vertxContext, transientServiceDef);

                httpServerRequest.startProxyKeepAlive();

                return masterNode.stopJob(Jobs.ID.VERIFY_REPAIR_ALL_CONTAINERS_OBJECTS, timeout,
                        TimeUnit.MILLISECONDS);
            }).single().subscribe(new ConnectionCloseTerminus<Void>(httpServerRequest) {
                @Override
                public void onNext(Void aVoid) {
                    JsonObject responseJson = new JsonObject().put("code", HTTP_OK).put("message", "Success");
                    httpServerRequest.response().write(responseJson.encode(), StandardCharsets.UTF_8.toString())
                            .write(DELIMITER_BUFFER);
                }
            });
}

From source file:org.sfs.nodes.compute.container.VerifyRepairAllContainersWait.java

License:Apache License

@Override
public void handle(final SfsRequest httpServerRequest) {

    VertxContext<Server> vertxContext = httpServerRequest.vertxContext();

    Defer.aVoid().flatMap(new Authenticate(httpServerRequest))
            .flatMap(new ValidateActionAdminOrSystem(httpServerRequest)).map(aVoid -> httpServerRequest)
            .map(new ValidateHeaderExists(Jobs.Parameters.TIMEOUT))
            .map(new ValidateHeaderBetweenLong(Jobs.Parameters.TIMEOUT, 100, Long.MAX_VALUE))
            .map(new ToVoid<>()).flatMap(aVoid -> {
                ClusterInfo clusterInfo = vertxContext.verticle().getClusterInfo();
                Nodes nodes = vertxContext.verticle().nodes();
                MultiMap headers = httpServerRequest.headers();

                long timeout = headers.contains(Jobs.Parameters.TIMEOUT)
                        ? Long.parseLong(headers.get(Jobs.Parameters.TIMEOUT))
                        : 100;//from  w w  w  . j  a v  a 2 s .c o  m

                TransientServiceDef transientServiceDef = clusterInfo.getCurrentMasterNode();
                MasterNode masterNode = nodes.remoteMasterNode(vertxContext, transientServiceDef);

                httpServerRequest.startProxyKeepAlive();

                return masterNode.waitForJob(Jobs.ID.VERIFY_REPAIR_ALL_CONTAINERS_OBJECTS, timeout,
                        TimeUnit.MILLISECONDS);
            }).single().subscribe(new ConnectionCloseTerminus<Void>(httpServerRequest) {
                @Override
                public void onNext(Void aVoid) {
                    JsonObject responseJson = new JsonObject().put("code", HTTP_OK).put("message", "Success");
                    httpServerRequest.response().write(responseJson.encode(), StandardCharsets.UTF_8.toString())
                            .write(DELIMITER_BUFFER);
                }
            });
}

From source file:org.sfs.nodes.compute.container.VerifyRepairContainerExecute.java

License:Apache License

@Override
public void handle(final SfsRequest httpServerRequest) {

    VertxContext<Server> vertxContext = httpServerRequest.vertxContext();

    Defer.aVoid().flatMap(new Authenticate(httpServerRequest))
            .flatMap(new ValidateActionAdminOrSystem(httpServerRequest)).map(aVoid -> httpServerRequest)
            .map(new ValidateHeaderBetweenLong(Jobs.Parameters.TIMEOUT, 100, Long.MAX_VALUE))
            .map(new ToVoid<>()).map(aVoid -> ObjectPath.fromSfsRequest(httpServerRequest))
            .map(new ValidateContainerPath()).flatMap(objectPath -> {
                ClusterInfo clusterInfo = vertxContext.verticle().getClusterInfo();
                Nodes nodes = vertxContext.verticle().nodes();
                MultiMap headers = httpServerRequest.headers();

                long timeout = headers.contains(Jobs.Parameters.TIMEOUT)
                        ? Long.parseLong(headers.get(Jobs.Parameters.TIMEOUT))
                        : 100;/*w  w  w  .  j  a  v a 2 s.c  o m*/

                String unparsedForceRemoveVolumes = headers.contains(Jobs.Parameters.FORCE_REMOVE_VOLUMES)
                        ? headers.get(Jobs.Parameters.FORCE_REMOVE_VOLUMES)
                        : null;

                MultiMap params = MultiMap.caseInsensitiveMultiMap();
                if (unparsedForceRemoveVolumes != null) {
                    params.add(Jobs.Parameters.FORCE_REMOVE_VOLUMES, unparsedForceRemoveVolumes);
                }
                params.set(Jobs.Parameters.CONTAINER_ID, objectPath.containerPath().get());

                TransientServiceDef transientServiceDef = clusterInfo.getCurrentMasterNode();
                MasterNode masterNode = nodes.remoteMasterNode(vertxContext, transientServiceDef);

                httpServerRequest.startProxyKeepAlive();

                return masterNode.executeJob(Jobs.ID.VERIFY_REPAIR_CONTAINER_OBJECTS, params, timeout,
                        TimeUnit.MILLISECONDS);
            }).single().subscribe(new ConnectionCloseTerminus<Void>(httpServerRequest) {
                @Override
                public void onNext(Void aVoid) {
                    JsonObject responseJson = new JsonObject().put("code", HTTP_OK).put("message", "Success");
                    httpServerRequest.response().write(responseJson.encode(), StandardCharsets.UTF_8.toString())
                            .write(DELIMITER_BUFFER);
                }
            });
}

From source file:org.sfs.nodes.compute.container.VerifyRepairContainerStop.java

License:Apache License

@Override
public void handle(final SfsRequest httpServerRequest) {

    VertxContext<Server> vertxContext = httpServerRequest.vertxContext();

    Defer.aVoid().flatMap(new Authenticate(httpServerRequest))
            .flatMap(new ValidateActionAdminOrSystem(httpServerRequest)).map(aVoid -> httpServerRequest)
            .map(new ValidateHeaderExists(Jobs.Parameters.TIMEOUT))
            .map(new ValidateHeaderBetweenLong(Jobs.Parameters.TIMEOUT, 100, Long.MAX_VALUE))
            .map(new ToVoid<>()).map(aVoid -> ObjectPath.fromSfsRequest(httpServerRequest))
            .map(new ValidateContainerPath()).flatMap(objectPath -> {
                ClusterInfo clusterInfo = vertxContext.verticle().getClusterInfo();
                Nodes nodes = vertxContext.verticle().nodes();
                MultiMap headers = httpServerRequest.headers();

                long timeout = headers.contains(Jobs.Parameters.TIMEOUT)
                        ? Long.parseLong(headers.get(Jobs.Parameters.TIMEOUT))
                        : 100;//from ww w  . jav  a2s  .c  om

                TransientServiceDef transientServiceDef = clusterInfo.getCurrentMasterNode();
                MasterNode masterNode = nodes.remoteMasterNode(vertxContext, transientServiceDef);

                httpServerRequest.startProxyKeepAlive();

                return masterNode.stopJob(Jobs.ID.VERIFY_REPAIR_CONTAINER_OBJECTS, timeout,
                        TimeUnit.MILLISECONDS);
            }).single().subscribe(new ConnectionCloseTerminus<Void>(httpServerRequest) {
                @Override
                public void onNext(Void aVoid) {
                    JsonObject responseJson = new JsonObject().put("code", HTTP_OK).put("message", "Success");
                    httpServerRequest.response().write(responseJson.encode(), StandardCharsets.UTF_8.toString())
                            .write(DELIMITER_BUFFER);
                }
            });
}

From source file:org.sfs.nodes.compute.container.VerifyRepairContainerWait.java

License:Apache License

@Override
public void handle(final SfsRequest httpServerRequest) {

    VertxContext<Server> vertxContext = httpServerRequest.vertxContext();

    Defer.aVoid().flatMap(new Authenticate(httpServerRequest))
            .flatMap(new ValidateActionAdminOrSystem(httpServerRequest)).map(aVoid -> httpServerRequest)
            .map(new ValidateHeaderExists(Jobs.Parameters.TIMEOUT))
            .map(new ValidateHeaderBetweenLong(Jobs.Parameters.TIMEOUT, 100, Long.MAX_VALUE))
            .map(new ToVoid<>()).map(aVoid -> ObjectPath.fromSfsRequest(httpServerRequest))
            .map(new ValidateContainerPath()).flatMap(objectPath -> {
                ClusterInfo clusterInfo = vertxContext.verticle().getClusterInfo();
                Nodes nodes = vertxContext.verticle().nodes();
                MultiMap headers = httpServerRequest.headers();

                long timeout = headers.contains(Jobs.Parameters.TIMEOUT)
                        ? Long.parseLong(headers.get(Jobs.Parameters.TIMEOUT))
                        : 100;// w w w .j a v  a  2s .c o m

                TransientServiceDef transientServiceDef = clusterInfo.getCurrentMasterNode();
                MasterNode masterNode = nodes.remoteMasterNode(vertxContext, transientServiceDef);

                httpServerRequest.startProxyKeepAlive();

                return masterNode.waitForJob(Jobs.ID.VERIFY_REPAIR_CONTAINER_OBJECTS, timeout,
                        TimeUnit.MILLISECONDS);
            }).single().subscribe(new ConnectionCloseTerminus<Void>(httpServerRequest) {
                @Override
                public void onNext(Void aVoid) {
                    JsonObject responseJson = new JsonObject().put("code", HTTP_OK).put("message", "Success");
                    httpServerRequest.response().write(responseJson.encode(), StandardCharsets.UTF_8.toString())
                            .write(DELIMITER_BUFFER);
                }
            });
}

From source file:org.sfs.nodes.compute.containerkeys.ReEncryptContainerKeys.java

License:Apache License

@Override
public void handle(final SfsRequest httpServerRequest) {

    VertxContext<Server> vertxContext = httpServerRequest.vertxContext();

    Defer.aVoid().flatMap(new Authenticate(httpServerRequest))
            .flatMap(new ValidateActionAdminOrSystem(httpServerRequest)).map(aVoid -> httpServerRequest)
            .map(new ValidateHeaderBetweenLong(Jobs.Parameters.TIMEOUT, 100, Long.MAX_VALUE))
            .map(new ToVoid<>()).flatMap(aVoid -> {
                ClusterInfo clusterInfo = vertxContext.verticle().getClusterInfo();
                Nodes nodes = vertxContext.verticle().nodes();
                MultiMap headers = httpServerRequest.headers();

                long timeout = headers.contains(Jobs.Parameters.TIMEOUT)
                        ? Long.parseLong(headers.get(Jobs.Parameters.TIMEOUT))
                        : 100;/*from   w  ww .j  av a  2s  .  c  om*/

                MultiMap params = MultiMap.caseInsensitiveMultiMap();

                TransientServiceDef transientServiceDef = clusterInfo.getCurrentMasterNode();
                MasterNode masterNode = nodes.remoteMasterNode(vertxContext, transientServiceDef);

                httpServerRequest.startProxyKeepAlive();

                return masterNode.executeJob(Jobs.ID.RE_ENCRYPT_CONTAINER_KEYS, params, timeout,
                        TimeUnit.MILLISECONDS);
            }).single().subscribe(new ConnectionCloseTerminus<Void>(httpServerRequest) {
                @Override
                public void onNext(Void aVoid) {
                    JsonObject responseJson = new JsonObject().put("code", HTTP_OK).put("message", "Success");
                    httpServerRequest.response().write(responseJson.encode(), StandardCharsets.UTF_8.toString())
                            .write(DELIMITER_BUFFER);
                }
            });
}

From source file:org.sfs.nodes.compute.masterkey.ReEncryptMasterKeys.java

License:Apache License

@Override
public void handle(final SfsRequest httpServerRequest) {

    VertxContext<Server> vertxContext = httpServerRequest.vertxContext();

    Defer.aVoid().flatMap(new Authenticate(httpServerRequest))
            .flatMap(new ValidateActionAdminOrSystem(httpServerRequest)).map(aVoid -> httpServerRequest)
            .map(new ValidateHeaderBetweenLong(Jobs.Parameters.TIMEOUT, 100, Long.MAX_VALUE))
            .map(new ToVoid<>()).flatMap(aVoid -> {
                ClusterInfo clusterInfo = vertxContext.verticle().getClusterInfo();
                Nodes nodes = vertxContext.verticle().nodes();
                MultiMap headers = httpServerRequest.headers();

                long timeout = headers.contains(Jobs.Parameters.TIMEOUT)
                        ? Long.parseLong(headers.get(Jobs.Parameters.TIMEOUT))
                        : 100;/*from   w  w  w  . j  a va 2s .c o  m*/

                MultiMap params = MultiMap.caseInsensitiveMultiMap();

                TransientServiceDef transientServiceDef = clusterInfo.getCurrentMasterNode();
                MasterNode masterNode = nodes.remoteMasterNode(vertxContext, transientServiceDef);

                httpServerRequest.startProxyKeepAlive();

                return masterNode.executeJob(Jobs.ID.RE_ENCRYPT_MASTER_KEYS, params, timeout,
                        TimeUnit.MILLISECONDS);
            }).single().subscribe(new ConnectionCloseTerminus<Void>(httpServerRequest) {
                @Override
                public void onNext(Void aVoid) {
                    JsonObject responseJson = new JsonObject().put("code", HTTP_OK).put("message", "Success");
                    httpServerRequest.response().write(responseJson.encode(), StandardCharsets.UTF_8.toString())
                            .write(DELIMITER_BUFFER);
                }
            });
}