com.netflix.hystrix.HystrixInvokableInfo Java Examples

@Test
public void shouldSetInoutOutputShapesToAnyIfMetadataCallFails() {
    @SuppressWarnings({"unchecked", "rawtypes"})
    final Class<Entity<Map<String, Object>>> entityType = (Class) Entity.class;
    ArgumentCaptor.forClass(entityType);

    // simulates fallback return
    final DynamicActionMetadata fallback = new DynamicActionMetadata.Builder().build();
    when(metadataCommand.execute()).thenReturn(fallback);
    when(((HystrixInvokableInfo<?>) metadataCommand).isSuccessfulExecution()).thenReturn(false);

    final Response response = handler.enrichWithMetadata(SALESFORCE_CREATE_OR_UPDATE, Collections.emptyMap());

    @SuppressWarnings("unchecked")
    final Meta<ConnectorDescriptor> meta = (Meta<ConnectorDescriptor>) response.getEntity();

    final ConnectorDescriptor descriptor = meta.getValue();
    assertThat(descriptor.getInputDataShape()).contains(ConnectionActionHandler.ANY_SHAPE);
    assertThat(descriptor.getOutputDataShape()).contains(salesforceOutputShape);
}
 

@Test
public void shouldConvertParameterFromIterableWithStringsToCommaDelimitedString() {
    final DynamicActionMetadata suggestions = new DynamicActionMetadata.Builder()
        .putProperty("sObjectName", Arrays.asList(DynamicActionMetadata.ActionPropertySuggestion.Builder.of("Account", "Account"),
            DynamicActionMetadata.ActionPropertySuggestion.Builder.of("Contact", "Contact")))
        .build();
    when(metadataCommand.execute()).thenReturn(suggestions);
    when(((HystrixInvokableInfo<?>) metadataCommand).isSuccessfulExecution()).thenReturn(true);


    final Map<String, Object> parameters = new HashMap<>();
    parameters.put("sObjectName", Arrays.asList("Contact", "Account"));

    final Response response = handler.enrichWithMetadata(SALESFORCE_CREATE_OR_UPDATE, parameters);

    assertThat(response.getStatus()).isEqualTo(Status.OK.getStatusCode());
    assertThat(metadataCommandParameters).containsEntry("sObjectName", "Contact,Account");
}
 

@Test
public void shouldConvertParameterFromArrayOfStringsToCommaDelimitedString() {
    final DynamicActionMetadata suggestions = new DynamicActionMetadata.Builder()
        .putProperty("sObjectName", Arrays.asList(DynamicActionMetadata.ActionPropertySuggestion.Builder.of("Account", "Account"),
            DynamicActionMetadata.ActionPropertySuggestion.Builder.of("Contact", "Contact")))
        .build();
    when(metadataCommand.execute()).thenReturn(suggestions);
    when(((HystrixInvokableInfo<?>) metadataCommand).isSuccessfulExecution()).thenReturn(true);


    final Map<String, Object> parameters = new HashMap<>();
    parameters.put("sObjectName", new String[] { "Contact", "Account" });

    final Response response = handler.enrichWithMetadata(SALESFORCE_CREATE_OR_UPDATE, parameters);

    assertThat(response.getStatus()).isEqualTo(Status.OK.getStatusCode());
    assertThat(metadataCommandParameters).containsEntry("sObjectName", "Contact,Account");
}
 

@Test
public void shouldSupportOtherParameterTypes() {
    final DynamicActionMetadata suggestions = new DynamicActionMetadata.Builder()
        .putProperty("sObjectName", Arrays.asList(DynamicActionMetadata.ActionPropertySuggestion.Builder.of("1", "1"),
            DynamicActionMetadata.ActionPropertySuggestion.Builder.of("2", "2")))
        .build();
    when(metadataCommand.execute()).thenReturn(suggestions);
    when(((HystrixInvokableInfo<?>) metadataCommand).isSuccessfulExecution()).thenReturn(true);


    final Map<String, Object> parameters = new HashMap<>();
    parameters.put("sObjectName", 1);

    handler.enrichWithMetadata(SALESFORCE_CREATE_OR_UPDATE, parameters);
    assertThat(metadataCommandParameters).containsEntry("sObjectName", "1");
}
 

@Test
public void test() {
    HystrixRequestContext context = HystrixRequestContext.initializeContext();
    try {
        assertEquals(null, new CommandWithFallbackViaNetwork(1).execute());

        HystrixInvokableInfo<?> command1 = HystrixRequestLog.getCurrentRequest().getAllExecutedCommands().toArray(new HystrixInvokableInfo<?>[2])[0];
        assertEquals("GetValueCommand", command1.getCommandKey().name());
        assertTrue(command1.getExecutionEvents().contains(HystrixEventType.FAILURE));

        HystrixInvokableInfo<?> command2 = HystrixRequestLog.getCurrentRequest().getAllExecutedCommands().toArray(new HystrixInvokableInfo<?>[2])[1];
        assertEquals("GetValueFallbackCommand", command2.getCommandKey().name());
        assertTrue(command2.getExecutionEvents().contains(HystrixEventType.FAILURE));
    } finally {
        context.shutdown();
    }
}
 

private static void commandWithFallbackViaNetworkTest() {
    HystrixRequestContext context = HystrixRequestContext.initializeContext();
    try {
         log.info(new CommandWithFallbackViaNetwork(1).execute());

        HystrixInvokableInfo<?> command1 = HystrixRequestLog.getCurrentRequest().getAllExecutedCommands().toArray(new HystrixInvokableInfo<?>[2])[0];
        log.info(command1.getCommandKey().name());
        log.info(""+command1.getExecutionEvents().contains(HystrixEventType.FAILURE));

        HystrixInvokableInfo<?> command2 = HystrixRequestLog.getCurrentRequest().getAllExecutedCommands().toArray(new HystrixInvokableInfo<?>[2])[1];
        log.info(command2.getCommandKey().name());
        log.info(""+command2.getExecutionEvents().contains(HystrixEventType.FAILURE));
    } finally {
        context.shutdown();
    }
}
 

@SuppressWarnings("ThrowableResultOfMethodCallIgnored")
@Override
protected <T> void logException(DBIException exception, HystrixInvokableInfo<T> command) {
    DBI_ERRORS.mark();
    final Throwable cause = Throwables.getRootCause(exception);
    if (cause instanceof SQLException) {
        sqlExceptionLogger.logSQLException((SQLException) cause, command);
    } else {
        logger.error("DBI problem running command: {}:{}", command.getCommandKey(), command.getClass().getSimpleName(), exception);
    }
}
 

@Override
public Observable<ByteBuf> getFallback(HystrixInvokableInfo<?> hystrixInfo, Map<String, Object> requestProperties) {
    byte[] bytes = Movie.ORANGE_IS_THE_NEW_BLACK.toString().getBytes(Charset.defaultCharset());
    ByteBuf byteBuf = UnpooledByteBufAllocator.DEFAULT.buffer(bytes.length);
    byteBuf.writeBytes(bytes);
    return Observable.just(byteBuf);
}
 

@SuppressWarnings("unchecked")
@Override
public <T> Exception onExecutionError(HystrixInvokable<T> commandInstance, Exception exception) {
    for (ExceptionLogger<? extends Exception> logger: exceptionLoggers) {
        if (logger.canHandleException(exception) && isHystrixInvokableInfo(commandInstance)) {
            logger.log(exception, (HystrixInvokableInfo<T>)commandInstance);
            return exception;
        }
    }

    return exception;
}
 

@SuppressWarnings("unchecked")
/**
 * Actually log the exception
 * @throws IllegalStateException it relieves an exception that it can't log
 */
public <T> void log(Exception exception, HystrixInvokableInfo<T> commandInstance) {
    checkState(canHandleException(exception));

    logException((E) exception, commandInstance);
}
 

@Override
protected <T> void logException(Exception exception, HystrixInvokableInfo<T> commandInstance) {
    logger.warn("An exception occurred while executing {}:{}",
            commandInstance.getCommandKey().name(),
            commandInstance.getClass().getSimpleName(),
            exception);
}
 

public static <V> Meta<V> from(final V value, final HystrixInvokableInfo<V> metaInfo) {
    if (metaInfo.isFailedExecution()) {
        final Throwable executionException = metaInfo.getFailedExecutionException();
        return Meta.withError(value, executionException);
    } else if (metaInfo.isResponseTimedOut()) {
        final double timeout = metaInfo.getProperties().executionTimeoutInMilliseconds().get() / 1000.0;
        return Meta.withWarning(value, "The query could not be completed in " + timeout + " seconds.");
    } else if (metaInfo.isSuccessfulExecution()) {
        return Meta.verbatim(value);
    } else {
        return Meta.withWarning(value, "The query did not succeed");
    }
}
 

@Test
public void shouldProvideActionDefinition() {
    @SuppressWarnings({"unchecked", "rawtypes"})
    final Class<Entity<Map<String, Object>>> entityType = (Class) Entity.class;
    ArgumentCaptor.forClass(entityType);

    final DynamicActionMetadata suggestions = new DynamicActionMetadata.Builder()
        .putProperty("sObjectName", Arrays.asList(DynamicActionMetadata.ActionPropertySuggestion.Builder.of("Account", "Account"),
            DynamicActionMetadata.ActionPropertySuggestion.Builder.of("Contact", "Contact")))
        .build();
    when(metadataCommand.execute()).thenReturn(suggestions);
    when(((HystrixInvokableInfo<?>) metadataCommand).isSuccessfulExecution()).thenReturn(true);

    final Response response = handler.enrichWithMetadata(SALESFORCE_CREATE_OR_UPDATE, Collections.emptyMap());

    assertThat(response.getStatus()).isEqualTo(Status.OK.getStatusCode());

    @SuppressWarnings("unchecked")
    final Meta<ConnectorDescriptor> meta = (Meta<ConnectorDescriptor>) response.getEntity();

    final ConnectorDescriptor enrichedDefinitioin = new ConnectorDescriptor.Builder()
        .createFrom(createOrUpdateSalesforceObjectDescriptor)
        .replaceConfigurationProperty("sObjectName",
            c -> c.addAllEnum(Arrays.asList(
                    ConfigurationProperty.PropertyValue.Builder.of("Account", "Account"),
                    ConfigurationProperty.PropertyValue.Builder.of("Contact", "Contact"))))
        .inputDataShape(ConnectionActionHandler.ANY_SHAPE)//
        .build();

    assertThat(meta.getValue()).isEqualTo(enrichedDefinitioin);
}
 

@Test
public void shouldElicitActionPropertySuggestions() {
    final DynamicActionMetadata suggestions = new DynamicActionMetadata.Builder()
        .putProperty("sObjectName",
            Collections.singletonList(DynamicActionMetadata.ActionPropertySuggestion.Builder.of("Contact", "Contact")))
        .putProperty("sObjectIdName",
            Arrays.asList(DynamicActionMetadata.ActionPropertySuggestion.Builder.of("ID", "Contact ID"),
                DynamicActionMetadata.ActionPropertySuggestion.Builder.of("Email", "Email"),
                DynamicActionMetadata.ActionPropertySuggestion.Builder.of("TwitterScreenName__c", "Twitter Screen Name")))
        .inputShape(salesforceContactShape)//
        .build();
    when(metadataCommand.execute()).thenReturn(suggestions);
    when(((HystrixInvokableInfo<?>) metadataCommand).isSuccessfulExecution()).thenReturn(true);

    final ConnectorDescriptor enrichedDefinitioin = new ConnectorDescriptor.Builder()
        .createFrom(createOrUpdateSalesforceObjectDescriptor)
        .replaceConfigurationProperty("sObjectName",
            c -> c.addEnum(ConfigurationProperty.PropertyValue.Builder.of("Contact", "Contact")).defaultValue("Contact"))
        .replaceConfigurationProperty("sObjectIdName",
            c -> c.addEnum(ConfigurationProperty.PropertyValue.Builder.of("ID", "Contact ID")))
        .replaceConfigurationProperty("sObjectIdName",
            c -> c.addEnum(ConfigurationProperty.PropertyValue.Builder.of("Email", "Email")))
        .replaceConfigurationProperty("sObjectIdName",
            c -> c.addEnum(ConfigurationProperty.PropertyValue.Builder.of("TwitterScreenName__c", "Twitter Screen Name")))
        .inputDataShape(salesforceContactShape)//
        .build();

    final Map<String, Object> parameters = new HashMap<>();
    parameters.put("sObjectName", "Contact");

    final Response response = handler.enrichWithMetadata(SALESFORCE_CREATE_OR_UPDATE, parameters);

    assertThat(response.getStatus()).isEqualTo(Status.OK.getStatusCode());

    @SuppressWarnings("unchecked")
    final Meta<ConnectorDescriptor> meta = (Meta<ConnectorDescriptor>) response.getEntity();

    assertThat(meta.getValue()).isEqualTo(enrichedDefinitioin);
}
 

@Test
public void shouldAddMetaAndSetStatusToBadRequestIfMetaCallFails() {
    @SuppressWarnings({"unchecked", "rawtypes"})
    final Class<Entity<Map<String, Object>>> entityType = (Class) Entity.class;
    ArgumentCaptor.forClass(entityType);

    // simulates fallback return
    final DynamicActionMetadata fallback = new DynamicActionMetadata.Builder().build();
    when(metadataCommand.execute()).thenReturn(fallback);
    when(((HystrixInvokableInfo<?>) metadataCommand).isSuccessfulExecution()).thenReturn(false);

    final Response response = handler.enrichWithMetadata(SALESFORCE_CREATE_OR_UPDATE, Collections.emptyMap());

    assertThat(response.getStatus()).isEqualTo(Status.BAD_REQUEST.getStatusCode());

    @SuppressWarnings("unchecked")
    final Meta<ConnectorDescriptor> meta = (Meta<ConnectorDescriptor>) response.getEntity();

    final ConnectorDescriptor descriptor = new ConnectorDescriptor.Builder().createFrom(createOrUpdateSalesforceObjectDescriptor)
        .inputDataShape(ConnectionActionHandler.ANY_SHAPE)//
        .outputDataShape(salesforceOutputShape)//
        .build();
    assertThat(meta.getValue()).isEqualTo(descriptor);
    final MetaData metadata = meta.getData();
    assertThat(metadata).isNotNull();
    assertThat(metadata.getType()).contains(MetaData.Type.WARNING);
    assertThat(metadata.getMessage()).contains("The query did not succeed");
}
 

@Override
protected <T> void logException(RuntimeException exception, HystrixInvokableInfo<T> commandInstance) {
    loggedExceptions.add(exception);
}
 

private <T> boolean isHystrixInvokableInfo(HystrixInvokable<T> commandInstance) {
    return commandInstance instanceof HystrixInvokableInfo;
}
 

<T> void logSQLException(SQLException exception, HystrixInvokableInfo<T> command) {
    for (Throwable throwable : exception) {
        logger.error("SQL problem running command: {}:{}", command.getCommandKey(), command.getClass().getSimpleName(), throwable);
    }
}
 

@Override
protected <T> void logException(RuntimeException exception, HystrixInvokableInfo<T> commandInstance) {
    loggedExceptions.add(exception);
}
 

@Override
protected <T> void logException(SQLException exception, HystrixInvokableInfo<T> command) {
    SQL_ERROR.mark();
    logSQLException(exception, command);
}
 

@Override
public Observable<Movie> getFallback(HystrixInvokableInfo<?> hystrixInfo, Map<String, Object> requestProperties) {
    return null;
}
 

@Override
public HystrixInvokableInfo<?> getHystrixInfo() {
    return hystrixInfo;
}
 

public HttpMetaResponse(O content, HystrixInvokableInfo<?> hystrixInfo) {
    this.content = content;
    this.hystrixInfo = hystrixInfo;
}
 

@Override
public HystrixInvokableInfo<?> getHystrixInfo() {
    return info;
}
 

public ResponseWithSubject(Subject<T, T> subject,
                           HystrixInvokableInfo<?> info) {
    this.subject = subject;
    this.info = info;
}
 

/**
 * @param exception the exception that you should log
 * @param commandInstance you get access to the command that failed, so you can specify what kind it was
 */
protected abstract <T> void logException(E exception, HystrixInvokableInfo<T> commandInstance);
 

public abstract HystrixInvokableInfo<?> getHystrixInfo(); 

public Observable<T> getFallback(HystrixInvokableInfo<?> hystrixInfo, Map<String, Object> requestProperties);