Java Code Examples for reactor.core.publisher.Flux#concatWith()

/**
 * Apply {@link #beforeCommit(Supplier) beforeCommit} actions, apply the
 * response status and headers/cookies, and write the response body.
 * @param writeAction the action to write the response body (may be {@code null})
 * @return a completion publisher
 */
protected Mono<Void> doCommit(@Nullable Supplier<? extends Mono<Void>> writeAction) {
	if (!this.state.compareAndSet(State.NEW, State.COMMITTING)) {
		return Mono.empty();
	}
	this.commitActions.add(() ->
			Mono.fromRunnable(() -> {
				applyStatusCode();
				applyHeaders();
				applyCookies();
				this.state.set(State.COMMITTED);
			}));
	if (writeAction != null) {
		this.commitActions.add(writeAction);
	}
	Flux<Void> commit = Flux.empty();
	for (Supplier<? extends Mono<Void>> action : this.commitActions) {
		commit = commit.concatWith(action.get());
	}
	return commit.then();
}
 

private Flux<ApiCallRc> resumeResourceInTransaction(ResourceName rscName, SnapshotName snapshotName)
{
    SnapshotDefinition snapshotDfn = ctrlApiDataLoader.loadSnapshotDfn(rscName, snapshotName, true);

    for (Snapshot snapshot : getAllSnapshotsPrivileged(snapshotDfn))
    {
        unsetSuspendResourcePrivileged(snapshot);
    }

    ResourceDefinition rscDfn = ctrlApiDataLoader.loadRscDfn(rscName, true);
    resumeIoPrivileged(rscDfn);

    ctrlTransactionHelper.commit();

    Flux<ApiCallRc> satelliteUpdateResponses =
        ctrlSatelliteUpdateCaller.updateSatellites(snapshotDfn, notConnectedError())
            .concatWith(ctrlSatelliteUpdateCaller.updateSatellites(rscDfn, notConnectedError(), Flux.empty()))
            .transform(responses -> CtrlResponseUtils.combineResponses(
                responses,
                rscName,
                "Resumed IO of {1} on {0} after snapshot"
            ));

    return satelliteUpdateResponses
        .concatWith(removeInProgressSnapshots(rscName, snapshotName));
}
 

public Flux<Tuple2<String, Long>> byService() {
	String sqlup = "select type, count(type) as cnt from service_instance_detail where type = 'user_provided_service_instance' group by type";
	Flux<Tuple2<String, Long>> ups = client.execute(sqlup)
				.map((row, metadata)
						-> Tuples.of("user-provided", Defaults.getColumnValueOrDefault(row, "cnt", Long.class, 0L)))
				.all()
				.defaultIfEmpty(Tuples.of("user-provided", 0L));
	String sqlms = "select service, count(service) as cnt from service_instance_detail where type = 'managed_service_instance' group by service";
	Flux<Tuple2<String, Long>> ms = client.execute(sqlms)
				.map((row, metadata)
						-> Tuples.of(Defaults.getColumnValueOrDefault(row, "service", String.class, "managed"), Defaults.getColumnValueOrDefault(row, "cnt", Long.class, 0L)))
				.all()
				.defaultIfEmpty(Tuples.of("managed", 0L));
	return ups.concatWith(ms);
}
 

@POST
@Consumes(MediaType.APPLICATION_JSON)
@Path("{nodeName}")
public void createDevicePool(
    @Context Request request,
    @Suspended AsyncResponse asyncResponse,
    @PathParam("nodeName") String nodeName,
    String jsonData
)
{
    try
    {
        JsonGenTypes.PhysicalStorageCreate createData = objectMapper
            .readValue(jsonData, JsonGenTypes.PhysicalStorageCreate.class);

        // check if with_storage_pool is given and if storage pool name is valid, before we do unneeded create/del
        if (createData.with_storage_pool != null)
        {
            LinstorParsingUtils.asStorPoolName(createData.with_storage_pool.name);
        }

        final String poolName = CtrlPhysicalStorageApiCallHandler.getDevicePoolName(
            createData.pool_name,
            createData.device_paths
        );

        final DeviceProviderKind deviceProviderKind = LinstorParsingUtils.asProviderKind(createData.provider_kind);
        Flux<ApiCallRc> responses = physicalStorageApiCallHandler.createDevicePool(
            nodeName,
            createData.device_paths,
            deviceProviderKind,
            LinstorParsingUtils.asRaidLevel(createData.raid_level),
            poolName,
            createData.vdo_enable,
            createData.vdo_logical_size_kib,
            createData.vdo_slab_size_kib
        ).subscriberContext(requestHelper.createContext(ApiConsts.API_CREATE_DEVICE_POOL, request));

        if (createData.with_storage_pool != null)
        {
            Map<String, String> storPoolProps = deviceProviderToStorPoolProperty(deviceProviderKind, poolName);
            storPoolProps.putAll(createData.with_storage_pool.props);
            responses = responses.concatWith(
                storPoolCrtApiCallHandler.createStorPool(
                    nodeName,
                    createData.with_storage_pool.name,
                    deviceProviderKind,
                    null,
                    storPoolProps,
                    physicalStorageApiCallHandler.deleteDevicePool(
                        nodeName,
                        createData.device_paths,
                        deviceProviderKind,
                        poolName
                    )
                ).subscriberContext(requestHelper.createContext(ApiConsts.API_CRT_STOR_POOL, request))
            );
        }

        requestHelper.doFlux(
            asyncResponse,
            ApiCallRcRestUtils.mapToMonoResponse(responses, Response.Status.CREATED)
        );
    }
    catch (IOException ioExc)
    {
        ApiCallRcRestUtils.handleJsonParseException(ioExc, asyncResponse);
    }
}
 

private Flux<ApiCallRc> abortSnapshotInTransaction(
    ResourceName rscName,
    SnapshotName snapshotName,
    Throwable exception
)
{
    SnapshotDefinition snapshotDfn = ctrlApiDataLoader.loadSnapshotDfn(rscName, snapshotName, true);

    SnapshotDefinition.Flags flag = exception instanceof CtrlResponseUtils.DelayedApiRcException &&
        isFailNotConnected((CtrlResponseUtils.DelayedApiRcException) exception) ?
            SnapshotDefinition.Flags.FAILED_DISCONNECT : SnapshotDefinition.Flags.FAILED_DEPLOYMENT;

    enableFlagPrivileged(snapshotDfn, flag);
    unsetInCreationPrivileged(snapshotDfn);
    ResourceDefinition rscDfn = snapshotDfn.getResourceDefinition();
    resumeIoPrivileged(rscDfn);

    ctrlTransactionHelper.commit();

    Flux<ApiCallRc> satelliteUpdateResponses =
        ctrlSatelliteUpdateCaller.updateSatellites(snapshotDfn, notConnectedCannotAbort())
            .transform(responses -> CtrlResponseUtils.combineResponses(
                responses,
                rscName,
                "Aborted snapshot of {1} on {0}"
            ))
            .concatWith(
                ctrlSatelliteUpdateCaller.updateSatellites(rscDfn, Flux.empty())
                    .transform(
                        responses -> CtrlResponseUtils.combineResponses(
                            responses,
                            rscName,
                            "Resumed IO of {1} on {0} after failed snapshot"
                        )
                    )
            )
            .onErrorResume(CtrlResponseUtils.DelayedApiRcException.class, ignored -> Flux.empty());

    return satelliteUpdateResponses
        .concatWith(Flux.error(exception));
}
 

private Flux<ApiCallRc> deleteResourceInTransaction(String nodeNameStr, String rscNameStr, ResponseContext context)
{
    Resource rsc = ctrlApiDataLoader.loadRsc(nodeNameStr, rscNameStr, false);

    if (rsc == null)
    {
        throw new ApiRcException(ApiCallRcImpl.simpleEntry(
            ApiConsts.WARN_NOT_FOUND,
            getRscDescription(nodeNameStr, rscNameStr) + " not found."
        ));
    }

    Set<NodeName> nodeNamesToDelete = new TreeSet<>();
    NodeName nodeName = rsc.getNode().getName();
    ResourceName rscName = rsc.getDefinition().getName();

    ctrlRscDeleteApiHelper.ensureNotInUse(rsc);

    ensureNotLastDisk(rscName, rsc);

    failIfDependentSnapshot(rsc);

    ctrlRscDeleteApiHelper.markDeletedWithVolumes(rsc);
    nodeNamesToDelete.add(nodeName);

    ApiCallRcImpl responses = new ApiCallRcImpl();
    AutoHelperResult autoResult = autoHelper.manage(
        responses,
        context,
        rsc.getDefinition()
    );

    ctrlTransactionHelper.commit();


    Flux<ApiCallRc> flux;
    if (!autoResult.isPreventUpdateSatellitesForResourceDelete())
    {
        String descriptionFirstLetterCaps = firstLetterCaps(getRscDescription(rsc));
        responses.addEntries(
            ApiCallRcImpl.singletonApiCallRc(
                ApiCallRcImpl
                    .entryBuilder(
                        ApiConsts.DELETED,
                        descriptionFirstLetterCaps + " marked for deletion."
                    )
                    .setDetails(descriptionFirstLetterCaps + " UUID is: " + rsc.getUuid())
                    .build()
            )
        );
        flux = Flux.just(responses);

        flux = flux.concatWith(
            ctrlRscDeleteApiHelper.updateSatellitesForResourceDelete(nodeNamesToDelete, rscName)
        );
    }
    else
    {
        flux = Flux.just(responses);
    }
    flux = flux.concatWith(autoResult.getFlux());

    return flux;
}
 

public <T> Flux<T> appendBoomError(Flux<T> source) {
	return source.concatWith(Mono.error(new IllegalArgumentException("boom")));
}