Java StreamManager.createScope方法代码示例

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.
 *
 * @throws Exception on any errors.
 */
@Test
public void createTestStream()
        throws Exception {
    Assert.assertNotNull("Pravega not initialized", localPravega);
    String scope = "Scope";
    String streamName = "Stream";
    int numSegments = 10;

    @Cleanup
    StreamManager streamManager = StreamManager.create(URI.create(
            localPravega.getInProcPravegaCluster().getControllerURI()
    ));

    streamManager.createScope(scope);
    Assert.assertTrue("Stream creation is not successful ",
            streamManager.createStream(scope, streamName, StreamConfiguration.builder()
                               .scope(scope)
                               .streamName(streamName)
                               .scalingPolicy(ScalingPolicy.fixed(numSegments))
                               .build()));

    log.info("Created stream: " + streamName);
}
 

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 runTest(final Set<String> streamNames, final int numParallelReaders, final int numSegments)
        throws Exception {
    @Cleanup
    StreamManager streamManager = StreamManager.create(SETUP_UTILS.getControllerUri());
    streamManager.createScope(SETUP_UTILS.getScope());
    streamNames.stream().forEach(stream -> {
        streamManager.createStream(SETUP_UTILS.getScope(),
                                   stream,
                                   StreamConfiguration.builder()
                                           .scope(SETUP_UTILS.getScope())
                                           .streamName(stream)
                                           .scalingPolicy(ScalingPolicy.fixed(numSegments))
                                           .build());
        log.info("Created stream: {}", stream);
    });

    @Cleanup
    ClientFactory clientFactory = ClientFactory.withScope(SETUP_UTILS.getScope(), SETUP_UTILS.getControllerUri());
    streamNames.stream().forEach(stream -> {
        EventStreamWriter<Integer> eventWriter = clientFactory.createEventWriter(
                stream, new IntegerSerializer(), EventWriterConfig.builder().build());
        for (Integer i = 0; i < NUM_TEST_EVENTS; i++) {
            eventWriter.writeEvent(String.valueOf(i), i);
        }
        eventWriter.flush();
        log.info("Wrote {} events", NUM_TEST_EVENTS);
    });

    final String readerGroupName = "testreadergroup" + RandomStringUtils.randomAlphanumeric(10).toLowerCase();

    @Cleanup
    ReaderGroupManager readerGroupManager = ReaderGroupManager.withScope(SETUP_UTILS.getScope(),
                                                                         SETUP_UTILS.getControllerUri());
    readerGroupManager.createReaderGroup(readerGroupName,
                                         ReaderGroupConfig.builder().startingTime(0).build(),
                                         streamNames);

    Collection<Integer> read = readAllEvents(numParallelReaders, clientFactory, readerGroupName, numSegments);

    Assert.assertEquals(NUM_TEST_EVENTS * streamNames.size(), read.size());
    // Check unique events.
    Assert.assertEquals(NUM_TEST_EVENTS, new TreeSet<>(read).size());
    readerGroupManager.deleteReaderGroup(readerGroupName);
}
 

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();
    }