software.amazon.awssdk.services.sns.model.PublishResponse Java Examples

public static void pubTopic(SnsClient snsClient, String message, String topicArn) {

        try {
            PublishRequest request = PublishRequest.builder()
                .message(message)
                .topicArn(topicArn)
                .build();

            PublishResponse result = snsClient.publish(request);
            System.out.println(result.messageId() + " Message sent. Status was " + result.sdkHttpResponse().statusCode());

         } catch (SnsException e) {
            System.err.println(e.awsErrorDetails().errorMessage());
              System.exit(1);
         }
        //snippet-end:[sns.java2.PublishTopic.main]
    }
 

public static void pubTextSMS(SnsClient snsClient, String message, String phoneNumber) {
    try {
        PublishRequest request = PublishRequest.builder()
            .message(message)
            .phoneNumber(phoneNumber)
            .build();

        PublishResponse result = snsClient.publish(request);

        System.out.println(result.messageId() + " Message sent. Status was " + result.sdkHttpResponse().statusCode());

    } catch (SnsException e) {

    System.err.println(e.awsErrorDetails().errorMessage());
    System.exit(1);
    }

    //snippet-end:[sns.java2.PublishTextSMS.main]
}
 

public void sendMessage(String id) {

        Region region = Region.US_EAST_1;
        SnsClient snsClient = SnsClient.builder()
                .region(region)
                .credentialsProvider(EnvironmentVariableCredentialsProvider.create())
                .build();
        String message = "A new item with ID value "+ id +" was added to the DynamoDB table";
        String phoneNumber="ENTER MOBILE NUMBER"; //Replace with a mobile phone number

        try {
            PublishRequest request = PublishRequest.builder()
                    .message(message)
                    .phoneNumber(phoneNumber)
                    .build();

            PublishResponse result = snsClient.publish(request);

        } catch (SnsException e) {

            System.err.println(e.awsErrorDetails().errorMessage());
            System.exit(1);
        }
    }
 

@Test
public void testDataWritesToSNS() {
  ImmutableList<String> input = ImmutableList.of("message1", "message2");

  final PCollection<PublishResponse> results =
      p.apply(Create.of(input))
          .apply(
              SnsIO.<String>write()
                  .withPublishRequestFn(SnsIOTest::createSampleMessage)
                  .withTopicArn(topicArn)
                  .withRetryConfiguration(
                      SnsIO.RetryConfiguration.create(
                          5, org.joda.time.Duration.standardMinutes(1)))
                  .withSnsClientProvider(SnsClientMockSuccess::new));

  final PCollection<Long> publishedResultsSize = results.apply(Count.globally());
  PAssert.that(publishedResultsSize).containsInAnyOrder(ImmutableList.of(2L));
  p.run().waitUntilFinish();
}
 

@POST
@Path("/shoot")
@Consumes(MediaType.APPLICATION_JSON)
public Response publish(Quark quark) throws Exception {
    String message = QUARK_WRITER.writeValueAsString(quark);
    PublishResponse response = sns.publish(p -> p.topicArn(topicArn).message(message));
    LOGGER.infov("Fired Quark[{0}, {1}}]", quark.getFlavor(), quark.getSpin());
    return Response.ok().entity(response.messageId()).build();
}
 

@POST
@Path("/shoot")
@Consumes(MediaType.APPLICATION_JSON)
public Uni<Response> publish(Quark quark) throws Exception {
    String message = QUARK_WRITER.writeValueAsString(quark);
    return Uni.createFrom()
        .completionStage(sns.publish(p -> p.topicArn(topicArn).message(message)))
        .onItem().invoke(item -> LOGGER.infov("Fired Quark[{0}, {1}}]", quark.getFlavor(), quark.getSpin()))
        .onItem().apply(PublishResponse::messageId)
        .onItem().apply(id -> Response.ok().entity(id).build());
}
 

@Override
public PCollection<PublishResponse> expand(PCollection<T> input) {
  checkArgument(getTopicArn() != null, "withTopicArn() is required");
  checkArgument(getPublishRequestFn() != null, "withPublishRequestFn() is required");
  checkArgument(getSnsClientProvider() != null, "withSnsClientProvider() is required");
  checkArgument(
      isTopicExists(getSnsClientProvider().getSnsClient(), getTopicArn()),
      "Topic arn %s does not exist",
      getTopicArn());

  return input.apply(ParDo.of(new SnsWriterFn<>(this)));
}
 

@ProcessElement
public void processElement(ProcessContext context) throws Exception {
  PublishRequest request =
      (PublishRequest) spec.getPublishRequestFn().apply(context.element());
  Sleeper sleeper = Sleeper.DEFAULT;
  BackOff backoff = retryBackoff.backoff();
  int attempt = 0;
  while (true) {
    attempt++;
    try {
      PublishResponse pr = producer.publish(request);
      context.output(pr);
      break;
    } catch (Exception ex) {
      // Fail right away if there is no retry configuration
      if (spec.getRetryConfiguration() == null
          || !spec.getRetryConfiguration().getRetryPredicate().test(ex)) {
        SNS_WRITE_FAILURES.inc();
        LOG.info("Unable to publish message {} due to {} ", request.message(), ex);
        throw new IOException("Error writing to SNS (no attempt made to retry)", ex);
      }

      if (!BackOffUtils.next(sleeper, backoff)) {
        throw new IOException(
            String.format(
                "Error writing to SNS after %d attempt(s). No more attempts allowed",
                attempt),
            ex);
      } else {
        // Note: this used in test cases to verify behavior
        LOG.warn(String.format(RETRY_ATTEMPT_LOG, attempt), ex);
      }
    }
  }
}
 

private BiConsumer<? super PublishResponse, ? super Throwable> getPublishResponse(
    DoFn<T, SnsResponse<T>>.ProcessContext context) {
  return (response, ex) -> {
    if (ex == null) {
      SnsResponse<T> snsResponse = SnsResponse.of(context.element(), response);
      context.output(snsResponse);
    } else {
      LOG.error("Error while publishing request to SNS", ex);
      throw new SnsWriteException("Error while publishing request to SNS", ex);
    }
  };
}
 

public static <T> SnsResponse<T> of(@NonNull T element, @Nullable PublishResponse response) {

    final Optional<PublishResponse> publishResponse = Optional.ofNullable(response);
    OptionalInt statusCode =
        publishResponse
            .map(r -> OptionalInt.of(r.sdkHttpResponse().statusCode()))
            .orElse(OptionalInt.empty());

    Optional<String> statusText = publishResponse.flatMap(r -> r.sdkHttpResponse().statusText());

    return create(element, statusCode, statusText);
  }
 

@Override
public PublishResponse publish(PublishRequest publishRequest) {
  PublishResponse response = Mockito.mock(PublishResponse.class);
  SdkHttpResponse metadata = Mockito.mock(SdkHttpResponse.class);

  Mockito.when(metadata.headers()).thenReturn(new HashMap<>());
  Mockito.when(metadata.statusCode()).thenReturn(200);
  Mockito.when(response.sdkHttpResponse()).thenReturn(metadata);
  Mockito.when(response.messageId()).thenReturn(UUID.randomUUID().toString());

  return response;
}
 

@Override
public CompletableFuture<PublishResponse> publish(PublishRequest publishRequest) {
  CompletableFuture<PublishResponse> completableFuture = new CompletableFuture<>();
  completableFuture.completeExceptionally(
      new RuntimeException("Error occurred during publish call"));
  return completableFuture;
}
 

@Override
public List<CoderProvider> getCoderProviders() {
  return ImmutableList.of(
      CoderProviders.forCoder(
          TypeDescriptor.of(PublishResponse.class), PublishResponseCoder.of()));
}
 

@Override
public void encode(PublishResponse value, OutputStream outStream) throws IOException {
  StringUtf8Coder.of().encode(value.messageId(), outStream);
}
 

@Override
public PublishResponse decode(InputStream inStream) throws IOException {
  final String messageId = StringUtf8Coder.of().decode(inStream);
  return PublishResponse.builder().messageId(messageId).build();
}
 

@Override
public PublishResponse publish(PublishRequest publishRequest) {
  throw InternalErrorException.builder().message("Service unavailable").build();
}