Examples with SchemaVersion org.apache.pulsar.common.schema.SchemaVersion used on opensource projects

Example 1 with SchemaVersion

use of org.apache.pulsar.common.schema.SchemaVersion in project incubator-pulsar by apache.

the class SchemaServiceTest method putSchema.

private void putSchema(String schemaId, SchemaData schema, SchemaVersion expectedVersion) throws Exception {
    CompletableFuture<SchemaVersion> put = schemaRegistryService.putSchemaIfAbsent(schemaId, schema);
    SchemaVersion newVersion = put.get();
    assertEquals(expectedVersion, newVersion);
}

Example 2 with SchemaVersion

use of org.apache.pulsar.common.schema.SchemaVersion in project incubator-pulsar by apache.

the class SchemaServiceTest method deleteSchema.

private void deleteSchema(String schemaId, SchemaVersion expectedVersion) throws Exception {
    SchemaVersion version = schemaRegistryService.deleteSchema(schemaId, userId).get();
    assertEquals(expectedVersion, version);
}

Example 3 with SchemaVersion

use of org.apache.pulsar.common.schema.SchemaVersion in project incubator-pulsar by apache.

the class ServerCnx method handleProducer.

@Override
protected void handleProducer(final CommandProducer cmdProducer) {
    checkArgument(state == State.Connected);
    final long producerId = cmdProducer.getProducerId();
    final long requestId = cmdProducer.getRequestId();
    // Use producer name provided by client if present
    final String producerName = cmdProducer.hasProducerName() ? cmdProducer.getProducerName() : service.generateUniqueProducerName();
    final boolean isEncrypted = cmdProducer.getEncrypted();
    final Map<String, String> metadata = CommandUtils.metadataFromCommand(cmdProducer);
    TopicName topicName = validateTopicName(cmdProducer.getTopic(), requestId, cmdProducer);
    if (topicName == null) {
        return;
    }
    if (invalidOriginalPrincipal(originalPrincipal)) {
        final String msg = "Valid Proxy Client role should be provided while creating producer ";
        log.warn("[{}] {} with role {} and proxyClientAuthRole {} on topic {}", remoteAddress, msg, authRole, originalPrincipal, topicName);
        ctx.writeAndFlush(Commands.newError(requestId, ServerError.AuthorizationError, msg));
        return;
    }
    CompletableFuture<Boolean> isProxyAuthorizedFuture;
    if (service.isAuthorizationEnabled() && originalPrincipal != null) {
        isProxyAuthorizedFuture = service.getAuthorizationService().canProduceAsync(topicName, authRole, authenticationData);
    } else {
        isProxyAuthorizedFuture = CompletableFuture.completedFuture(true);
    }
    isProxyAuthorizedFuture.thenApply(isProxyAuthorized -> {
        if (isProxyAuthorized) {
            CompletableFuture<Boolean> authorizationFuture;
            if (service.isAuthorizationEnabled()) {
                authorizationFuture = service.getAuthorizationService().canProduceAsync(topicName, originalPrincipal != null ? originalPrincipal : authRole, authenticationData);
            } else {
                authorizationFuture = CompletableFuture.completedFuture(true);
            }
            authorizationFuture.thenApply(isAuthorized -> {
                if (isAuthorized) {
                    if (log.isDebugEnabled()) {
                        log.debug("[{}] Client is authorized to Produce with role {}", remoteAddress, authRole);
                    }
                    CompletableFuture<Producer> producerFuture = new CompletableFuture<>();
                    CompletableFuture<Producer> existingProducerFuture = producers.putIfAbsent(producerId, producerFuture);
                    if (existingProducerFuture != null) {
                        if (existingProducerFuture.isDone() && !existingProducerFuture.isCompletedExceptionally()) {
                            Producer producer = existingProducerFuture.getNow(null);
                            log.info("[{}] Producer with the same id is already created: {}", remoteAddress, producer);
                            ctx.writeAndFlush(Commands.newProducerSuccess(requestId, producer.getProducerName(), producer.getSchemaVersion()));
                            return null;
                        } else {
                            // There was an early request to create a producer with
                            // same producerId. This can happen when
                            // client
                            // timeout is lower the broker timeouts. We need to wait
                            // until the previous producer creation
                            // request
                            // either complete or fails.
                            ServerError error = !existingProducerFuture.isDone() ? ServerError.ServiceNotReady : getErrorCode(existingProducerFuture);
                            log.warn("[{}][{}] Producer is already present on the connection", remoteAddress, topicName);
                            ctx.writeAndFlush(Commands.newError(requestId, error, "Producer is already present on the connection"));
                            return null;
                        }
                    }
                    log.info("[{}][{}] Creating producer. producerId={}", remoteAddress, topicName, producerId);
                    service.getTopic(topicName.toString()).thenAccept((Topic topic) -> {
                        // on topic
                        if (topic.isBacklogQuotaExceeded(producerName)) {
                            IllegalStateException illegalStateException = new IllegalStateException("Cannot create producer on topic with backlog quota exceeded");
                            BacklogQuota.RetentionPolicy retentionPolicy = topic.getBacklogQuota().getPolicy();
                            if (retentionPolicy == BacklogQuota.RetentionPolicy.producer_request_hold) {
                                ctx.writeAndFlush(Commands.newError(requestId, ServerError.ProducerBlockedQuotaExceededError, illegalStateException.getMessage()));
                            } else if (retentionPolicy == BacklogQuota.RetentionPolicy.producer_exception) {
                                ctx.writeAndFlush(Commands.newError(requestId, ServerError.ProducerBlockedQuotaExceededException, illegalStateException.getMessage()));
                            }
                            producerFuture.completeExceptionally(illegalStateException);
                            producers.remove(producerId, producerFuture);
                            return;
                        }
                        // Check whether the producer will publish encrypted messages or not
                        if (topic.isEncryptionRequired() && !isEncrypted) {
                            String msg = String.format("Encryption is required in %s", topicName);
                            log.warn("[{}] {}", remoteAddress, msg);
                            ctx.writeAndFlush(Commands.newError(requestId, ServerError.MetadataError, msg));
                            return;
                        }
                        disableTcpNoDelayIfNeeded(topicName.toString(), producerName);
                        CompletableFuture<SchemaVersion> schemaVersionFuture;
                        if (cmdProducer.hasSchema()) {
                            schemaVersionFuture = topic.addSchema(getSchema(cmdProducer.getSchema()));
                        } else {
                            schemaVersionFuture = CompletableFuture.completedFuture(SchemaVersion.Empty);
                        }
                        schemaVersionFuture.exceptionally(exception -> {
                            ctx.writeAndFlush(Commands.newError(requestId, ServerError.UnknownError, exception.getMessage()));
                            producers.remove(producerId, producerFuture);
                            return null;
                        });
                        schemaVersionFuture.thenAccept(schemaVersion -> {
                            Producer producer = new Producer(topic, ServerCnx.this, producerId, producerName, authRole, isEncrypted, metadata, schemaVersion);
                            try {
                                topic.addProducer(producer);
                                if (isActive()) {
                                    if (producerFuture.complete(producer)) {
                                        log.info("[{}] Created new producer: {}", remoteAddress, producer);
                                        ctx.writeAndFlush(Commands.newProducerSuccess(requestId, producerName, producer.getLastSequenceId(), producer.getSchemaVersion()));
                                        return;
                                    } else {
                                        // The producer's future was completed before by
                                        // a close command
                                        producer.closeNow();
                                        log.info("[{}] Cleared producer created after timeout on client side {}", remoteAddress, producer);
                                    }
                                } else {
                                    producer.closeNow();
                                    log.info("[{}] Cleared producer created after connection was closed: {}", remoteAddress, producer);
                                    producerFuture.completeExceptionally(new IllegalStateException("Producer created after connection was closed"));
                                }
                            } catch (BrokerServiceException ise) {
                                log.error("[{}] Failed to add producer to topic {}: {}", remoteAddress, topicName, ise.getMessage());
                                ctx.writeAndFlush(Commands.newError(requestId, BrokerServiceException.getClientErrorCode(ise), ise.getMessage()));
                                producerFuture.completeExceptionally(ise);
                            }
                            producers.remove(producerId, producerFuture);
                        });
                    }).exceptionally(exception -> {
                        Throwable cause = exception.getCause();
                        if (!(cause instanceof ServiceUnitNotReadyException)) {
                            // Do not print stack traces for expected exceptions
                            log.error("[{}] Failed to create topic {}", remoteAddress, topicName, exception);
                        }
                        // client, only if not completed already.
                        if (producerFuture.completeExceptionally(exception)) {
                            ctx.writeAndFlush(Commands.newError(requestId, BrokerServiceException.getClientErrorCode(cause), cause.getMessage()));
                        }
                        producers.remove(producerId, producerFuture);
                        return null;
                    });
                } else {
                    String msg = "Client is not authorized to Produce";
                    log.warn("[{}] {} with role {}", remoteAddress, msg, authRole);
                    ctx.writeAndFlush(Commands.newError(requestId, ServerError.AuthorizationError, msg));
                }
                return null;
            }).exceptionally(e -> {
                String msg = String.format("[%s] %s with role %s", remoteAddress, e.getMessage(), authRole);
                log.warn(msg);
                ctx.writeAndFlush(Commands.newError(requestId, ServerError.AuthorizationError, e.getMessage()));
                return null;
            });
        } else {
            final String msg = "Proxy Client is not authorized to Produce";
            log.warn("[{}] {} with role {} on topic {}", remoteAddress, msg, authRole, topicName);
            ctx.writeAndFlush(Commands.newError(requestId, ServerError.AuthorizationError, msg));
        }
        return null;
    }).exceptionally(ex -> {
        String msg = String.format("[%s] %s with role %s", remoteAddress, ex.getMessage(), authRole);
        log.warn(msg);
        ctx.writeAndFlush(Commands.newError(requestId, ServerError.AuthorizationError, ex.getMessage()));
        return null;
    });
}