SpringCloud/spring-cloud-function
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

resolve code style issues

Browse Source 
Resolves #999
This commit is contained in:
Christian Tzolov
2023-02-02 16:45:15 +01:00
committed by Oleg Zhurakousky
parent bb066b9b3f
commit ba1094df63
2 changed files with 240 additions and 238 deletions
Download Patch File Download Diff File Expand all files Collapse all files

199
spring-cloud-function-adapters/spring-cloud-function-adapter-azure/src/main/java/org/springframework/cloud/function/adapter/azure/AzureFunctionUtil.java
View File

@@ -14,102 +14,105 @@
* limitations under the License. * limitations under the License.
*/ */
package org.springframework.cloud.function.adapter.azure; package org.springframework.cloud.function.adapter.azure;
import java.util.HashMap; import java.util.HashMap;
import java.util.Map; import java.util.Map;
import java.util.Optional; import java.util.Optional;
import com.microsoft.azure.functions.ExecutionContext; import com.microsoft.azure.functions.ExecutionContext;
import com.microsoft.azure.functions.HttpMethod; import com.microsoft.azure.functions.HttpMethod;
import com.microsoft.azure.functions.HttpRequestMessage; import com.microsoft.azure.functions.HttpRequestMessage;
import org.reactivestreams.Publisher; import org.reactivestreams.Publisher;
import reactor.core.publisher.Flux; import reactor.core.publisher.Flux;
import org.springframework.messaging.Message; import org.springframework.messaging.Message;
import org.springframework.messaging.MessageHeaders; import org.springframework.messaging.MessageHeaders;
import org.springframework.messaging.support.MessageBuilder; import org.springframework.messaging.support.MessageBuilder;
/** /**
* * @author Christian Tzolov
* @author Christian Tzolov * @author Oleg Zhurakousky
* @author Oleg Zhurakousky * @author Chris Bono
* @author Chris Bono * @since 4.0
* @since 4.0 */
* public final class AzureFunctionUtil {
*/
public class AzureFunctionUtil { /**
* Message header key name used to store and extract the ExecutionContext.
public static String EXECUTION_CONTEXT = "executionContext"; */
public static String EXECUTION_CONTEXT = "executionContext";
@SuppressWarnings({ "unchecked", "rawtypes" })
public static <I> Object enhanceInputIfNecessary(Object input, ExecutionContext executionContext) { private AzureFunctionUtil() {
if (input == null) { // Supplier };
return input;
} @SuppressWarnings({ "unchecked", "rawtypes" })
if (input instanceof Publisher) { public static <I> Object enhanceInputIfNecessary(Object input, ExecutionContext executionContext) {
return Flux.from((Publisher) input).map(item -> { if (input == null) { // Supplier
if (item instanceof Message) { return input;
return MessageBuilder.fromMessage((Message<I>) item) }
.setHeaderIfAbsent(EXECUTION_CONTEXT, executionContext).build(); if (input instanceof Publisher) {
} return Flux.from((Publisher) input).map(item -> {
else { if (item instanceof Message) {
return constructInputMessageFromItem(input, executionContext); return MessageBuilder.fromMessage((Message<I>) item)
} .setHeaderIfAbsent(EXECUTION_CONTEXT, executionContext).build();
}); }
} else {
else if (input instanceof Message) { return constructInputMessageFromItem(input, executionContext);
return MessageBuilder.fromMessage((Message<I>) input) }
.setHeaderIfAbsent(EXECUTION_CONTEXT, executionContext).build(); });
} }
else if (input instanceof Iterable) { else if (input instanceof Message) {
return Flux.fromIterable((Iterable) input).map(item -> { return MessageBuilder.fromMessage((Message<I>) input)
return constructInputMessageFromItem(item, executionContext); .setHeaderIfAbsent(EXECUTION_CONTEXT, executionContext).build();
}); }
} else if (input instanceof Iterable) {
return constructInputMessageFromItem(input, executionContext); return Flux.fromIterable((Iterable) input).map(item -> {
} return constructInputMessageFromItem(item, executionContext);
});
private static <I> Message<?> constructInputMessageFromItem(Object input, ExecutionContext executionContext) { }
MessageBuilder<?> messageBuilder = null; return constructInputMessageFromItem(input, executionContext);
if (input instanceof HttpRequestMessage) { }
HttpRequestMessage<I> requestMessage = (HttpRequestMessage<I>) input;
Object payload = requestMessage.getHttpMethod() != null private static <I> Message<?> constructInputMessageFromItem(Object input, ExecutionContext executionContext) {
&& requestMessage.getHttpMethod().equals(HttpMethod.GET) MessageBuilder<?> messageBuilder = null;
? requestMessage.getQueryParameters() if (input instanceof HttpRequestMessage) {
: requestMessage.getBody(); HttpRequestMessage<I> requestMessage = (HttpRequestMessage<I>) input;
Object payload = requestMessage.getHttpMethod() != null
if (payload == null) { && requestMessage.getHttpMethod().equals(HttpMethod.GET)
payload = Optional.empty(); ? requestMessage.getQueryParameters()
} : requestMessage.getBody();
messageBuilder = MessageBuilder.withPayload(payload).copyHeaders(getHeaders(requestMessage));
} if (payload == null) {
else { payload = Optional.empty();
messageBuilder = MessageBuilder.withPayload(input); }
} messageBuilder = MessageBuilder.withPayload(payload).copyHeaders(getHeaders(requestMessage));
return messageBuilder.setHeaderIfAbsent(EXECUTION_CONTEXT, executionContext).build(); }
} else {
messageBuilder = MessageBuilder.withPayload(input);
private static <I> MessageHeaders getHeaders(HttpRequestMessage<I> event) { }
Map<String, Object> headers = new HashMap<String, Object>(); return messageBuilder.setHeaderIfAbsent(EXECUTION_CONTEXT, executionContext).build();
}
if (event.getHeaders() != null) {
headers.putAll(event.getHeaders()); private static <I> MessageHeaders getHeaders(HttpRequestMessage<I> event) {
} Map<String, Object> headers = new HashMap<String, Object>();
if (event.getQueryParameters() != null) {
headers.putAll(event.getQueryParameters()); if (event.getHeaders() != null) {
} headers.putAll(event.getHeaders());
if (event.getUri() != null) { }
headers.put("path", event.getUri().getPath()); if (event.getQueryParameters() != null) {
} headers.putAll(event.getQueryParameters());
}
if (event.getHttpMethod() != null) { if (event.getUri() != null) {
headers.put("httpMethod", event.getHttpMethod().toString()); headers.put("path", event.getUri().getPath());
} }
headers.put("request", event.getBody()); if (event.getHttpMethod() != null) {
return new MessageHeaders(headers); headers.put("httpMethod", event.getHttpMethod().toString());
} }
} headers.put("request", event.getBody());
return new MessageHeaders(headers);
}
}

279
spring-cloud-function-adapters/spring-cloud-function-adapter-azure/src/test/java/org/springframework/cloud/function/adapter/azure/injector/AzureFunctionInstanceInjectorTest.java
View File

@@ -14,144 +14,143 @@
* limitations under the License. * limitations under the License.
*/ */
package org.springframework.cloud.function.adapter.azure.injector; package org.springframework.cloud.function.adapter.azure.injector;
import java.util.Iterator; import java.util.Iterator;
import java.util.Optional; import java.util.Optional;
import java.util.ServiceLoader; import java.util.ServiceLoader;
import java.util.function.Function; import java.util.function.Function;
import java.util.logging.Logger; import java.util.logging.Logger;
import com.microsoft.azure.functions.ExecutionContext; import com.microsoft.azure.functions.ExecutionContext;
import com.microsoft.azure.functions.HttpMethod; import com.microsoft.azure.functions.HttpMethod;
import com.microsoft.azure.functions.HttpRequestMessage; import com.microsoft.azure.functions.HttpRequestMessage;
import com.microsoft.azure.functions.annotation.AuthorizationLevel; import com.microsoft.azure.functions.annotation.AuthorizationLevel;
import com.microsoft.azure.functions.annotation.FunctionName; import com.microsoft.azure.functions.annotation.FunctionName;
import com.microsoft.azure.functions.annotation.HttpTrigger; import com.microsoft.azure.functions.annotation.HttpTrigger;
import com.microsoft.azure.functions.spi.inject.FunctionInstanceInjector; import com.microsoft.azure.functions.spi.inject.FunctionInstanceInjector;
import org.assertj.core.api.Assertions; import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.Test; import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.AutoConfigurationExcludeFilter; import org.springframework.boot.autoconfigure.AutoConfigurationExcludeFilter;
import org.springframework.boot.context.TypeExcludeFilter; import org.springframework.boot.context.TypeExcludeFilter;
import org.springframework.cloud.function.adapter.azure.AzureFunctionInstanceInjector; import org.springframework.cloud.function.adapter.azure.AzureFunctionInstanceInjector;
import org.springframework.cloud.function.adapter.azure.AzureFunctionUtil; import org.springframework.cloud.function.adapter.azure.AzureFunctionUtil;
import org.springframework.cloud.function.adapter.azure.HttpFunctionInvokerTests; import org.springframework.cloud.function.adapter.azure.HttpFunctionInvokerTests;
import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan; import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.ComponentScan.Filter; import org.springframework.context.annotation.ComponentScan.Filter;
import org.springframework.context.annotation.Configuration; import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.FilterType; import org.springframework.context.annotation.FilterType;
import org.springframework.messaging.Message; import org.springframework.messaging.Message;
/** /**
* @author Christian Tzolov * @author Christian Tzolov
*/ */
public class AzureFunctionInstanceInjectorTest { public class AzureFunctionInstanceInjectorTest {
static ExecutionContext executionContext = new ExecutionContext() { static ExecutionContext executionContext = new ExecutionContext() {
@Override @Override
public Logger getLogger() { public Logger getLogger() {
return Logger.getLogger(AzureFunctionInstanceInjectorTest.class.getName()); return Logger.getLogger(AzureFunctionInstanceInjectorTest.class.getName());
} }
@Override @Override
public String getInvocationId() { public String getInvocationId() {
return "id1"; return "id1";
} }
@Override @Override
public String getFunctionName() { public String getFunctionName() {
return "hello"; return "hello";
} }
}; };
@Test @Test
public void testFunctionInjector() throws Exception { public void testFunctionInjector() throws Exception {
FunctionInstanceInjector injector = initializeFunctionInstanceInjector(); FunctionInstanceInjector injector = initializeFunctionInstanceInjector();
Assertions.assertThat(injector).isNotNull(); Assertions.assertThat(injector).isNotNull();
Assertions.assertThat(injector).isInstanceOf(AzureFunctionInstanceInjector.class); Assertions.assertThat(injector).isInstanceOf(AzureFunctionInstanceInjector.class);
System.setProperty("MAIN_CLASS", MyMainConfig.class.getName()); System.setProperty("MAIN_CLASS", MyMainConfig.class.getName());
MyAzureTestFunction functionInstance = injector.getInstance(MyAzureTestFunction.class); MyAzureTestFunction functionInstance = injector.getInstance(MyAzureTestFunction.class);
HttpFunctionInvokerTests.HttpRequestMessageStub<Optional<String>> request = new HttpFunctionInvokerTests.HttpRequestMessageStub<Optional<String>>(); HttpFunctionInvokerTests.HttpRequestMessageStub<Optional<String>> request = new HttpFunctionInvokerTests.HttpRequestMessageStub<Optional<String>>();
request.setBody(Optional.of("test")); request.setBody(Optional.of("test"));
String result = functionInstance.execute(request, executionContext); String result = functionInstance.execute(request, executionContext);
Assertions.assertThat(result).isEqualTo("TEST"); Assertions.assertThat(result).isEqualTo("TEST");
Assertions.assertThat(functionInstance).isNotNull(); Assertions.assertThat(functionInstance).isNotNull();
Assertions.assertThat(functionInstance).isInstanceOf(MyAzureTestFunction.class); Assertions.assertThat(functionInstance).isInstanceOf(MyAzureTestFunction.class);
} }
private static FunctionInstanceInjector initializeFunctionInstanceInjector() { private static FunctionInstanceInjector initializeFunctionInstanceInjector() {
FunctionInstanceInjector functionInstanceInjector = null; FunctionInstanceInjector functionInstanceInjector = null;
ClassLoader prevContextClassLoader = Thread.currentThread().getContextClassLoader(); ClassLoader prevContextClassLoader = Thread.currentThread().getContextClassLoader();
try { try {
Iterator<FunctionInstanceInjector> iterator = ServiceLoader.load(FunctionInstanceInjector.class).iterator(); Iterator<FunctionInstanceInjector> iterator = ServiceLoader.load(FunctionInstanceInjector.class).iterator();
if (iterator.hasNext()) { if (iterator.hasNext()) {
functionInstanceInjector = iterator.next(); functionInstanceInjector = iterator.next();
if (iterator.hasNext()) { if (iterator.hasNext()) {
throw new RuntimeException( throw new RuntimeException(
"Customer function app has multiple FunctionInstanceInjector implementations"); "Customer function app has multiple FunctionInstanceInjector implementations");
} }
} }
else { else {
functionInstanceInjector = new FunctionInstanceInjector() { functionInstanceInjector = new FunctionInstanceInjector() {
@Override @Override
public <T> T getInstance(Class<T> functionClass) throws Exception { public <T> T getInstance(Class<T> functionClass) throws Exception {
return functionClass.getDeclaredConstructor().newInstance(); return functionClass.getDeclaredConstructor().newInstance();
} }
}; };
} }
} }
finally { finally {
Thread.currentThread().setContextClassLoader(prevContextClassLoader); Thread.currentThread().setContextClassLoader(prevContextClassLoader);
} }
return functionInstanceInjector; return functionInstanceInjector;
} }
@Configuration @Configuration
@ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class), @ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
@Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) }) @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
public static class MyMainConfig { public static class MyMainConfig {
@Bean @Bean
public Function<Message<String>, String> uppercase() { public Function<Message<String>, String> uppercase() {
return message -> { return message -> {
ExecutionContext context = (ExecutionContext) message.getHeaders() ExecutionContext context = (ExecutionContext) message.getHeaders()
.get(AzureFunctionUtil.EXECUTION_CONTEXT); .get(AzureFunctionUtil.EXECUTION_CONTEXT);
Assertions.assertThat(context).isNotNull(); Assertions.assertThat(context).isNotNull();
Assertions.assertThat(context.getFunctionName()).isEqualTo("hello"); Assertions.assertThat(context.getFunctionName()).isEqualTo("hello");
return message.getPayload().toUpperCase(); return message.getPayload().toUpperCase();
}; };
} }
} }
@Configuration @Configuration
public static class MyAzureTestFunction { public static class MyAzureTestFunction {
@Autowired @Autowired
private Function<Message<String>, String> uppercase; private Function<Message<String>, String> uppercase;
@FunctionName("ditest") @FunctionName("ditest")
public String execute( public String execute(
@HttpTrigger(name = "req", methods = { HttpMethod.GET, @HttpTrigger(name = "req", methods = { HttpMethod.GET,
HttpMethod.POST }, authLevel = AuthorizationLevel.ANONYMOUS) HttpRequestMessage<Optional<String>> request, HttpMethod.POST }, authLevel = AuthorizationLevel.ANONYMOUS) HttpRequestMessage<Optional<String>> request,
ExecutionContext context) { ExecutionContext context) {
Message<String> enhancedRequest = (Message<String>) AzureFunctionUtil.enhanceInputIfNecessary( Message<String> enhancedRequest = (Message<String>) AzureFunctionUtil.enhanceInputIfNecessary(
request.getBody().get(), request.getBody().get(),
context); context);
return uppercase.apply(enhancedRequest); return uppercase.apply(enhancedRequest);
} }
} }
} }