Java StreamManager.createStream方法代码示例

import io.pravega.client.admin.StreamManager; //导入方法依赖的package包/类
/**
 * Create the test stream.
 *
 * @param streamName     Name of the test stream.
 * @param numSegments    Number of segments to be created for this stream.
 *
 * @throws Exception on any errors.
 */
public void createTestStream(final String streamName, final int numSegments)
        throws Exception {
    Preconditions.checkState(this.started.get(), "Services not yet started");
    Preconditions.checkNotNull(streamName);
    Preconditions.checkArgument(numSegments > 0);

    @Cleanup
    StreamManager streamManager = StreamManager.create(getControllerUri());
    streamManager.createScope(this.scope);
    streamManager.createStream(this.scope, streamName,
            StreamConfiguration.builder()
                    .scope(this.scope)
                    .streamName(streamName)
                    .scalingPolicy(ScalingPolicy.fixed(numSegments))
                    .build());
    log.info("Created stream: " + streamName);
}
 

import io.pravega.client.admin.StreamManager; //导入方法依赖的package包/类
public void run(String routingKey, String message) {
    StreamManager streamManager = StreamManager.create(controllerURI);
    final boolean scopeIsNew = streamManager.createScope(scope);

    StreamConfiguration streamConfig = StreamConfiguration.builder()
            .scalingPolicy(ScalingPolicy.fixed(1))
            .build();
    final boolean streamIsNew = streamManager.createStream(scope, streamName, streamConfig);

    try (ClientFactory clientFactory = ClientFactory.withScope(scope, controllerURI);
         EventStreamWriter<String> writer = clientFactory.createEventWriter(streamName,
                                                                             new JavaSerializer<String>(),
                                                                             EventWriterConfig.builder().build())) {
        
        System.out.format("Writing message: '%s' with routing-key: '%s' to stream '%s / %s'%n",
                message, routingKey, scope, streamName);
        final CompletableFuture writeFuture = writer.writeEvent(routingKey, message);
    }
}
 

import io.pravega.client.admin.StreamManager; //导入方法依赖的package包/类
/**
 * Creates the shared state using a synchronizer based on the given stream name.
 * 
 * @param clientFactory - the Pravega ClientFactory to use to create the StateSynchronizer.
 * @param streamManager - the Pravega StreamManager to use to create the Scope and the Stream used by the StateSynchronizer
 * @param scope - the Scope to use to create the Stream used by the StateSynchronizer.
 * @param name - the name of the Stream to be used by the StateSynchronizer.
 */
public SharedMap(ClientFactory clientFactory, StreamManager streamManager, String scope, String name){
    streamManager.createScope(scope);
    
    StreamConfiguration streamConfig = StreamConfiguration.builder()
            .scalingPolicy(ScalingPolicy.fixed(1))
            .build();
    
    streamManager.createStream(scope, name, streamConfig);
    
    this.stateSynchronizer = clientFactory.createStateSynchronizer(name,
                                            new JavaSerializer<StateUpdate<K,V>>(),
                                            new JavaSerializer<CreateState<K,V>>(),
                                            SynchronizerConfig.builder().build());
    
    stateSynchronizer.initialize(new CreateState<K,V>(new ConcurrentHashMap<K,V>()));
}
 

import io.pravega.client.admin.StreamManager; //导入方法依赖的package包/类
/**
 * Create the test stream.
 *
 * @param streamName     Name of the test stream.
 * @param numSegments    Number of segments to be created for this stream.
 *
 * @throws Exception on any errors.
 */
public void createTestStream(final String streamName, final int numSegments)
        throws Exception {
    Preconditions.checkState(this.started.get(), "Services not yet started");
    Preconditions.checkNotNull(streamName);
    Preconditions.checkArgument(numSegments > 0);

    @Cleanup
    StreamManager streamManager = StreamManager.create(this.controllerUri);
    streamManager.createScope(this.scope);
    streamManager.createStream(this.scope, streamName,
            StreamConfiguration.builder()
                    .scope(this.scope)
                    .streamName(streamName)
                    .scalingPolicy(ScalingPolicy.fixed(numSegments))
                    .build());
    log.info("Created stream: " + streamName);
}
 

import io.pravega.client.admin.StreamManager; //导入方法依赖的package包/类
public void createStream(final StreamId streamId, final ScalingPolicy scalingPolicy) {
    StreamManager streamManager = StreamManager.create(getControllerUri());
    streamManager.createScope(streamId.getScope());

    StreamConfiguration streamConfig = StreamConfiguration.builder().scalingPolicy(scalingPolicy).build();
    streamManager.createStream(streamId.getScope(), streamId.getName(), streamConfig);
}
 

import io.pravega.client.admin.StreamManager; //导入方法依赖的package包/类
public void run() {
    StreamManager streamManager = StreamManager.create(controllerURI);
    
    final boolean scopeIsNew = streamManager.createScope(scope);
    StreamConfiguration streamConfig = StreamConfiguration.builder()
            .scalingPolicy(ScalingPolicy.fixed(1))
            .build();
    final boolean streamIsNew = streamManager.createStream(scope, streamName, streamConfig);

    final String readerGroup = UUID.randomUUID().toString().replace("-", "");
    final ReaderGroupConfig readerGroupConfig = ReaderGroupConfig.builder()
            .build();
    try (ReaderGroupManager readerGroupManager = ReaderGroupManager.withScope(scope, controllerURI)) {
        readerGroupManager.createReaderGroup(readerGroup, readerGroupConfig, Collections.singleton(streamName));
    }

    try (ClientFactory clientFactory = ClientFactory.withScope(scope, controllerURI);
         EventStreamReader<String> reader = clientFactory.createReader("reader",
                                                                       readerGroup,
                                                                       new JavaSerializer<String>(),
                                                                       ReaderConfig.builder().build())) {
        System.out.format("Reading all the events from %s/%s%n", scope, streamName);
        EventRead<String> event = null;
        do {
            try {
                event = reader.readNextEvent(READER_TIMEOUT_MS);
                if (event.getEvent() != null) {
                    System.out.format("Read event '%s'%n", event.getEvent());
                }
            } catch (ReinitializationRequiredException e) {
                //There are certain circumstances where the reader needs to be reinitialized
                e.printStackTrace();
            }
        } while (event.getEvent() != null);
        System.out.format("No more events from %s/%s%n", scope, streamName);
    }
}
 

import io.pravega.client.admin.StreamManager; //导入方法依赖的package包/类
public void run() {
    final String readerGroup = UUID.randomUUID().toString().replace("-", "");
    final ReaderGroupConfig readerGroupConfig = ReaderGroupConfig.builder().startingPosition(Sequence.MIN_VALUE)
            .build();
    StreamManager streamManager = StreamManager.create(controllerURI);
    streamManager.createScope(scope);

    StreamConfiguration streamConfig = StreamConfiguration.builder().scope(scope).streamName(streamName)
            .scalingPolicy(ScalingPolicy.fixed(1))
            .build();

    streamManager.createStream(scope, streamName, streamConfig);

    try (ReaderGroupManager readerGroupManager = ReaderGroupManager.withScope(scope, controllerURI)) {
        readerGroupManager.createReaderGroup(readerGroup, readerGroupConfig, Collections.singleton(streamName));
    }

    try (ClientFactory clientFactory = ClientFactory.withScope(scope, controllerURI);
         EventStreamReader<String> reader = clientFactory.createReader("reader",
                                                                       readerGroup,
                                                                       new JavaSerializer<String>(),
                                                                       ReaderConfig.builder().build())) {
        System.out.format("******** Reading events from %s/%s%n", scope, streamName);
        EventRead<String> event = null;
        do {
            try {
                event = reader.readNextEvent(READER_TIMEOUT_MS);
                if(event != null) {
                    System.out.format("'%s'%n", event.getEvent());
                }
            } catch (ReinitializationRequiredException e) {
                //There are certain circumstances where the reader needs to be reinitialized
                e.printStackTrace();
            }
        }while(true);
    }
}
 

import io.pravega.client.admin.StreamManager; //导入方法依赖的package包/类
void createScopeAndStream(String scope, String stream, StreamConfiguration config, StreamManager streamManager) {
    Boolean createScopeStatus = streamManager.createScope(scope);
    log.info("Creating scope with scope name {}", scope);
    log.debug("Create scope status {}", createScopeStatus);
    Boolean createStreamStatus = streamManager.createStream(scope, stream, config);
    log.debug("Create stream status {}", createStreamStatus);

}
 

import io.pravega.client.admin.StreamManager; //导入方法依赖的package包/类
private void testSessionExpiryTolerance(final ControllerWrapper controllerWrapper, final int controllerPort) throws Exception {

        controllerWrapper.awaitRunning();

        // Simulate ZK session timeout
        controllerWrapper.forceClientSessionExpiry();

        // Now, that session has expired, lets do some operations.
        controllerWrapper.awaitPaused();

        controllerWrapper.awaitRunning();

        URI controllerURI = URI.create("tcp://localhost:" + controllerPort);
        StreamManager streamManager = StreamManager.create(controllerURI);

        // Create scope
        streamManager.createScope(SCOPE);

        // Create stream
        StreamConfiguration streamConfiguration = StreamConfiguration.builder()
                .scope(SCOPE)
                .streamName(STREAM)
                .scalingPolicy(ScalingPolicy.fixed(1))
                .build();
        streamManager.createStream(SCOPE, STREAM, streamConfiguration);

        streamManager.sealStream(SCOPE, STREAM);

        streamManager.deleteStream(SCOPE, STREAM);

        streamManager.deleteScope(SCOPE);

        controllerWrapper.close();

        controllerWrapper.awaitTerminated();
    }