{@code
21 | *
22 | * com.google.cloud.functions
23 | * function-maven-plugin
24 | * 1.0.0-alpha-2-rc3
25 | *
26 | * com.example.function.Echo
27 | *
28 | *
29 | * }
30 | *
31 | * ...and then run using {@code mvn function:run}. Or using properties on the command line, like
32 | * this...{@code
35 | * mvn com.google.cloud.functions:function:1.0.0-alpha-2-rc3:run \
36 | * -Drun.functionTarget=com.example.function.Echo
37 | * }
38 | */
39 | @Mojo(
40 | name = "run",
41 | defaultPhase = LifecyclePhase.GENERATE_RESOURCES,
42 | requiresDependencyResolution = ResolutionScope.RUNTIME,
43 | requiresDependencyCollection = ResolutionScope.RUNTIME)
44 | @Execute(phase = LifecyclePhase.COMPILE)
45 | public class RunFunction extends AbstractMojo {
46 |
47 | /**
48 | * The name of the function to run. This is the name of a class that implements one of the
49 | * interfaces in {@code com.google.cloud.functions}.
50 | */
51 | @Parameter(property = "run.functionTarget")
52 | private String functionTarget;
53 |
54 | /** The port on which the HTTP server wrapping the function should listen. */
55 | @Parameter(property = "run.port", defaultValue = "8080")
56 | private Integer port;
57 |
58 | /**
59 | * Used to determine what classpath needs to be used to load the function. This parameter is
60 | * injected by Maven and can't be set explicitly in a pom.xml file.
61 | */
62 | @Parameter(defaultValue = "${project.runtimeClasspathElements}", readonly = true, required = true)
63 | private ListHere is an example of an implementation that accesses the {@code messageId} property from a 24 | * payload that matches a user-defined {@code PubSubMessage} class: 25 | * 27 | * 28 | *
29 | * public class Example implements{@code BackgroundFunction} {
30 | * private static final Logger logger = Logger.getLogger(Example.class.getName());
31 | *
32 | * {@code @Override}
33 | * public void accept(PubSubMessage pubSubMessage, Context context) {
34 | * logger.info("Got messageId " + pubSubMessage.messageId);
35 | * }
36 | * }
37 | *
38 | * // Where PubSubMessage is a user-defined class like this:
39 | * public class PubSubMessage {
40 | * String data;
41 | * {@code Map} attributes;
42 | * String messageId;
43 | * String publishTime;
44 | * }
45 | *
46 | *
47 | * @param The map returned by this method may be empty but is never null.
61 | *
62 | * @return additional attributes form this event.
63 | */
64 | default Map Here is an example of an implementation that parses the JSON payload using Gson, to access its
23 | * {@code messageId} property:
24 | *
26 | *
27 | * Here is an example of an implementation that deserializes the JSON payload into a Java object
42 | * for simpler access, again using Gson:
43 | *
44 | * {@code HttpTest} contains more detailed testing, but this function is part of the integration
15 | * test that shows that we can indeed access the multipart API from a function.
16 | */
17 | public class Multipart implements HttpFunction {
18 | @Override
19 | public void service(HttpRequest request, HttpResponse response) throws Exception {
20 | response.setContentType("text/plain");
21 | String contentType = request.getContentType().orElse("
77 | * Content-Type: text/plain
78 | * Some-Header: some value
79 | * Some-Header: another value
80 | *
81 | *
82 | * ...then the returned value will map {@code "Content-Type"} to a one-element list containing
83 | * {@code "text/plain"}, and {@code "Some-Header"} to a two-element list containing {@code "some
84 | * value"} and {@code "another value"}.
85 | *
86 | * @return a map where each key is an HTTP header and the corresponding {@code List} value has one
87 | * element for each occurrence of that header.
88 | */
89 | Map
96 | * Content-Type: text/plain
97 | * Some-Header: some value
98 | * Some-Header: another value
99 | *
100 | *
101 | * ...then {@code getFirstHeader("Some-Header")} will return {@code Optional.of("some value")},
102 | * and {@code getFirstHeader("Another-Header")} will return {@code Optional.empty()}.
103 | *
104 | * @param name an HTTP header name.
105 | * @return the first value of the given header, if present.
106 | */
107 | default Optional
45 | * {@code setStatusCode(400, "Something went wrong")}. The named constants in {@link
46 | * java.net.HttpURLConnection}, such as {@link java.net.HttpURLConnection#HTTP_BAD_REQUEST
47 | * HTTP_BAD_REQUEST}, can be used as an alternative to writing numbers in your source code.
48 | *
49 | * @param code the status code.
50 | * @param message the status message.
51 | */
52 | void setStatusCode(int code, String message);
53 |
54 | /**
55 | * Sets the value to use for the {@code Content-Type} header in the response. This may include a
56 | * character encoding, for example {@code setContentType("text/plain; charset=utf-8")}.
57 | *
58 | * @param contentType the content type.
59 | */
60 | void setContentType(String contentType);
61 |
62 | /**
63 | * Returns the {@code Content-Type} that was previously set by {@link #setContentType}, or by
64 | * {@link #appendHeader} with a header name of {@code Content-Type}. If no {@code Content-Type}
65 | * has been set, returns {@code Optional.empty()}.
66 | *
67 | * @return the content type, if any.
68 | */
69 | Optional
28 | * public class Example implements RawBackgroundFunction {
29 | * private static final Logger logger = Logger.getLogger(Example.class.getName());
30 | *
31 | * {@code @Override}
32 | * public void accept(String json, Context context) {
33 | * JsonObject jsonObject = new Gson().fromJson(json, JsonObject.class);
34 | * JsonElement messageId = jsonObject.get("messageId");
35 | * String messageIdString = messageId.getAsJsonString();
36 | * logger.info("Got messageId " + messageIdString);
37 | * }
38 | * }
39 | *
40 | *
41 | *
45 | * public class Example implements RawBackgroundFunction {
46 | * private static final Logger logger = Logger.getLogger(Example.class.getName());
47 | *
48 | * {@code @Override}
49 | * public void accept(String json, Context context) {
50 | * PubSubMessage message = new Gson().fromJson(json, PubSubMessage.class);
51 | * logger.info("Got messageId " + message.messageId);
52 | * }
53 | * }
54 | *
55 | * // Where PubSubMessage is a user-defined class like this:
56 | * public class PubSubMessage {
57 | * String data;
58 | * {@code Map
63 | */
64 | @FunctionalInterface
65 | public interface RawBackgroundFunction {
66 | /**
67 | * Called to service an incoming event. This interface is implemented by user code to provide the
68 | * action for a given background function. If this method throws any exception (including any
69 | * {@link Error}) then the HTTP response will have a 500 status code.
70 | *
71 | * @param json the payload of the event, as a JSON string.
72 | * @param context the context of the event. This is a set of values that every event has,
73 | * separately from the payload, such as timestamp and event type.
74 | * @throws Exception to produce a 500 status code in the HTTP response.
75 | */
76 | void accept(String json, Context context) throws Exception;
77 | }
78 |
--------------------------------------------------------------------------------
/functions-framework-api/src/main/java/com/google/cloud/functions/TypedFunction.java:
--------------------------------------------------------------------------------
1 | // Copyright 2019 Google LLC
2 | //
3 | // Licensed under the Apache License, Version 2.0 (the "License");
4 | // you may not use this file except in compliance with the License.
5 | // You may obtain a copy of the License at
6 | //
7 | // http://www.apache.org/licenses/LICENSE-2.0
8 | //
9 | // Unless required by applicable law or agreed to in writing, software
10 | // distributed under the License is distributed on an "AS IS" BASIS,
11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 | // See the License for the specific language governing permissions and
13 | // limitations under the License.
14 |
15 | package com.google.cloud.functions;
16 |
17 | import java.lang.reflect.Type;
18 |
19 | /**
20 | * Represents a Cloud Function with a strongly typed interface that is activated by an HTTP request.
21 | */
22 | @FunctionalInterface
23 | public interface TypedFunction{@code
17 | * $ functions-framework-conformance-client \
18 | * -cmd="mvn function:run -Drun.functionTarget=com.google.cloud.functions.conformance.BackgroundEventConformanceFunction" \
19 | * -type=legacyevent \
20 | * -buildpacks=false \
21 | * -validate-mapping=false \
22 | * -start-delay=10
23 | * }
24 | */
25 | public class BackgroundEventConformanceFunction implements RawBackgroundFunction {
26 |
27 | private static final Gson gson = new GsonBuilder().serializeNulls().setPrettyPrinting().create();
28 |
29 | @Override
30 | public void accept(String data, Context context) throws Exception {
31 | try (BufferedWriter writer = new BufferedWriter(new FileWriter("function_output.json"))) {
32 | writer.write(serialize(data, context));
33 | }
34 | }
35 |
36 | /** Create a structured JSON representation of the request context and data */
37 | private String serialize(String data, Context context) {
38 | JsonObject contextJson = new JsonObject();
39 | contextJson.addProperty("eventId", context.eventId());
40 | contextJson.addProperty("timestamp", context.timestamp());
41 | contextJson.addProperty("eventType", context.eventType());
42 |
43 | if (context.resource().startsWith("{")) {
44 | JsonElement resource = gson.fromJson(context.resource(), JsonElement.class);
45 | contextJson.add("resource", resource);
46 | } else {
47 | contextJson.addProperty("resource", context.resource());
48 | }
49 |
50 | JsonObject dataJson = gson.fromJson(data, JsonObject.class);
51 |
52 | JsonObject json = new JsonObject();
53 | json.add("data", dataJson);
54 | json.add("context", contextJson);
55 | return gson.toJson(json);
56 | }
57 | }
58 |
--------------------------------------------------------------------------------
/invoker/conformance/src/main/java/com/google/cloud/functions/conformance/CloudEventsConformanceFunction.java:
--------------------------------------------------------------------------------
1 | // Copyright 2020 Google LLC
2 | //
3 | // Licensed under the Apache License, Version 2.0 (the "License");
4 | // you may not use this file except in compliance with the License.
5 | // You may obtain a copy of the License at
6 | //
7 | // http://www.apache.org/licenses/LICENSE-2.0
8 | //
9 | // Unless required by applicable law or agreed to in writing, software
10 | // distributed under the License is distributed on an "AS IS" BASIS,
11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 | // See the License for the specific language governing permissions and
13 | // limitations under the License.
14 |
15 | package com.google.cloud.functions.conformance;
16 |
17 | import static java.nio.charset.StandardCharsets.UTF_8;
18 |
19 | import com.google.cloud.functions.CloudEventsFunction;
20 | import io.cloudevents.CloudEvent;
21 | import io.cloudevents.core.format.EventFormat;
22 | import io.cloudevents.core.provider.EventFormatProvider;
23 | import io.cloudevents.jackson.JsonFormat;
24 | import java.io.BufferedWriter;
25 | import java.io.FileWriter;
26 |
27 | /**
28 | * This class is used by the Functions Framework Conformance Tools to validate the framework's Cloud
29 | * Events API. It can be run with the following command:
30 | *
31 | * {@code
32 | * $ functions-framework-conformance-client \
33 | * -cmd="mvn function:run -Drun.functionTarget=com.google.cloud.functions.conformance.CloudEventsConformanceFunction" \
34 | * -type=cloudevent \
35 | * -buildpacks=false \
36 | * -validate-mapping=false \
37 | * -start-delay=5
38 | * }
39 | */
40 | public class CloudEventsConformanceFunction implements CloudEventsFunction {
41 |
42 | @Override
43 | public void accept(CloudEvent event) throws Exception {
44 | try (BufferedWriter writer = new BufferedWriter(new FileWriter("function_output.json"))) {
45 | EventFormat format = EventFormatProvider.getInstance().resolveFormat(JsonFormat.CONTENT_TYPE);
46 | writer.write(new String(format.serialize(event), UTF_8));
47 | }
48 | }
49 | }
50 |
--------------------------------------------------------------------------------
/invoker/conformance/src/main/java/com/google/cloud/functions/conformance/ConcurrentHttpConformanceFunction.java:
--------------------------------------------------------------------------------
1 | // Copyright 2020 Google LLC
2 | //
3 | // Licensed under the Apache License, Version 2.0 (the "License");
4 | // you may not use this file except in compliance with the License.
5 | // You may obtain a copy of the License at
6 | //
7 | // http://www.apache.org/licenses/LICENSE-2.0
8 | //
9 | // Unless required by applicable law or agreed to in writing, software
10 | // distributed under the License is distributed on an "AS IS" BASIS,
11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 | // See the License for the specific language governing permissions and
13 | // limitations under the License.
14 |
15 | package com.google.cloud.functions.conformance;
16 |
17 | import com.google.cloud.functions.HttpFunction;
18 | import com.google.cloud.functions.HttpRequest;
19 | import com.google.cloud.functions.HttpResponse;
20 |
21 | /**
22 | * This class is used by the Functions Framework Conformance Tools to validate concurrency for HTTP
23 | * functions. It can be run with the following command:
24 | *
25 | * {@code
26 | * $ functions-framework-conformance-client \
27 | * -cmd="mvn function:run -Drun.functionTarget=com.google.cloud.functions.conformance.ConcurrentHttpConformanceFunction" \
28 | * -type=http \
29 | * -buildpacks=false \
30 | * -validate-mapping=false \
31 | * -start-delay=5 \
32 | * -validate-concurrency=true
33 | * }
34 | */
35 | public class ConcurrentHttpConformanceFunction implements HttpFunction {
36 |
37 | @Override
38 | public void service(HttpRequest request, HttpResponse response) throws InterruptedException {
39 | Thread.sleep(1000);
40 | }
41 | }
42 |
--------------------------------------------------------------------------------
/invoker/conformance/src/main/java/com/google/cloud/functions/conformance/HttpConformanceFunction.java:
--------------------------------------------------------------------------------
1 | // Copyright 2020 Google LLC
2 | //
3 | // Licensed under the Apache License, Version 2.0 (the "License");
4 | // you may not use this file except in compliance with the License.
5 | // You may obtain a copy of the License at
6 | //
7 | // http://www.apache.org/licenses/LICENSE-2.0
8 | //
9 | // Unless required by applicable law or agreed to in writing, software
10 | // distributed under the License is distributed on an "AS IS" BASIS,
11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 | // See the License for the specific language governing permissions and
13 | // limitations under the License.
14 |
15 | package com.google.cloud.functions.conformance;
16 |
17 | import com.google.cloud.functions.HttpFunction;
18 | import com.google.cloud.functions.HttpRequest;
19 | import com.google.cloud.functions.HttpResponse;
20 | import java.io.BufferedReader;
21 | import java.io.BufferedWriter;
22 | import java.io.FileWriter;
23 | import java.io.IOException;
24 |
25 | /**
26 | * This class is used by the Functions Framework Conformance Tools to validate the framework's HTTP
27 | * API. It can be run with the following command:
28 | *
29 | * {@code
30 | * $ functions-framework-conformance-client \
31 | * -cmd="mvn function:run -Drun.functionTarget=com.google.cloud.functions.conformance.HttpConformanceFunction" \
32 | * -type=http \
33 | * -buildpacks=false \
34 | * -validate-mapping=false \
35 | * -start-delay=5
36 | * }
37 | */
38 | public class HttpConformanceFunction implements HttpFunction {
39 |
40 | @Override
41 | public void service(HttpRequest request, HttpResponse response) throws IOException {
42 | try (BufferedReader reader = request.getReader();
43 | BufferedWriter writer = new BufferedWriter(new FileWriter("function_output.json"))) {
44 | int c;
45 | while ((c = reader.read()) != -1) {
46 | writer.write(c);
47 | }
48 | }
49 | }
50 | }
51 |
--------------------------------------------------------------------------------
/invoker/conformance/src/main/java/com/google/cloud/functions/conformance/TypedConformanceFunction.java:
--------------------------------------------------------------------------------
1 | package com.google.cloud.functions.conformance;
2 |
3 | import com.google.cloud.functions.TypedFunction;
4 | import com.google.gson.annotations.SerializedName;
5 |
6 | public class TypedConformanceFunction
7 | implements TypedFunction