diff --git a/optimization/snippets/pom.xml b/optimization/snippets/pom.xml new file mode 100644 index 00000000000..a8d13e8bab5 --- /dev/null +++ b/optimization/snippets/pom.xml @@ -0,0 +1,65 @@ + + + 4.0.0 + com.example.optimization + optimization-ai-snippets + pom + Google Cloud Fleet Routing Samples Parent + https://github.com/GoogleCloudPlatform/java-docs-samples/tree/main/optimization + + Java idiomatic client for Google Cloud Platform services. + + + + + com.google.cloud.samples + shared-configuration + 1.2.0 + + + + 1.8 + 1.8 + UTF-8 + + + + + + + com.google.cloud + libraries-bom + 26.1.4 + pom + import + + + + + + + com.google.cloud + google-cloud-optimization + 1.1.14 + + + com.google.cloud + google-cloud-storage + + + junit + junit + 4.13.2 + test + + + com.google.truth + truth + 1.1.3 + test + + + diff --git a/optimization/snippets/resources/sync_request.textproto b/optimization/snippets/resources/sync_request.textproto new file mode 100644 index 00000000000..d1026f95eb0 --- /dev/null +++ b/optimization/snippets/resources/sync_request.textproto @@ -0,0 +1,64 @@ +# proto-file: google3/google/cloud/optimization/v1/fleet_routing.proto +# proto-message: OptimizeToursRequest +model { + shipments { + pickups { + arrival_location { latitude: 48.874507 longitude: 2.30361 } + time_windows { + start_time { seconds: 1000 } + end_time { seconds: 2000 } + } + duration { seconds: 150 } + } + deliveries { + arrival_location { latitude: 48.880942 longitude: 2.323866 } + time_windows { + start_time { seconds: 3000 } + end_time { seconds: 4000 } + } + duration: { seconds: 250 } + } + load_demands { + key: "weight" + value: { amount: 10 } + } + } + shipments { + pickups { + arrival_location { latitude: 48.880943 longitude: 2.323867 } + time_windows { + start_time { seconds: 1001 } + end_time { seconds: 2001 } + } + duration { seconds: 151 } + } + deliveries { + arrival_location { latitude: 48.880940 longitude: 2.323844 } + time_windows { + start_time { seconds: 3001 } + end_time { seconds: 4001 } + } + duration { seconds: 251 } + } + load_demands { + key: "weight" + value: { amount: 20 } + } + } + vehicles { + start_location { latitude: 48.863102 longitude: 2.341204 } + end_location { latitude: 48.863110 longitude: 2.341205 } + load_limits { + key: "weight" + value: { max_load: 50 } + } + } + vehicles { + start_location { latitude: 48.863112 longitude: 2.341214 } + end_location { latitude: 48.863120 longitude: 2.341215 } + load_limits { + key: "weight" + value: { max_load: 60 } + } + } + } \ No newline at end of file diff --git a/optimization/snippets/src/main/java/com/example/optimizationai/AsyncApi.java b/optimization/snippets/src/main/java/com/example/optimizationai/AsyncApi.java new file mode 100644 index 00000000000..97430d34720 --- /dev/null +++ b/optimization/snippets/src/main/java/com/example/optimizationai/AsyncApi.java @@ -0,0 +1,85 @@ +/* + * Copyright 2022 Google LLC + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.optimizationai; + +// [START cloudoptimization_async_api] +import com.google.api.gax.longrunning.OperationFuture; +import com.google.cloud.optimization.v1.AsyncModelMetadata; +import com.google.cloud.optimization.v1.BatchOptimizeToursRequest; +import com.google.cloud.optimization.v1.BatchOptimizeToursRequest.AsyncModelConfig; +import com.google.cloud.optimization.v1.BatchOptimizeToursResponse; +import com.google.cloud.optimization.v1.DataFormat; +import com.google.cloud.optimization.v1.FleetRoutingClient; +import com.google.cloud.optimization.v1.GcsDestination; +import com.google.cloud.optimization.v1.GcsSource; +import com.google.cloud.optimization.v1.InputConfig; +import com.google.cloud.optimization.v1.OutputConfig; + +/** + * This is an example to send a request to Cloud Fleet Routing asynchronous API via Java API Client. + * A sample async_request_java.textproto file and a sample request_model_java.json file can be found + * in the resources folder. + */ +public class AsyncApi { + public static void callAsyncApi() throws Exception { + // TODO(developer): Replace these variables before running the sample. + String projectParent = "projects/{YOUR_GCP_PROJECT_ID}"; + String inputUri = "gs://YOUR_GCS_PATH"; + String outputUri = "gs://YOUR_SOLUTION_PATH"; + callAsyncApi(projectParent, inputUri, outputUri); + } + + public static void callAsyncApi(String projectParent, String inputUri, String outputUri) + throws Exception { + GcsSource gcsSource = GcsSource.newBuilder().setUri(inputUri).build(); + InputConfig inputConfig = + InputConfig.newBuilder().setGcsSource(gcsSource).setDataFormat(DataFormat.JSON).build(); + GcsDestination gcsDestination = GcsDestination.newBuilder().setUri(outputUri).build(); + OutputConfig outputConfig = + OutputConfig.newBuilder() + .setGcsDestination(gcsDestination) + .setDataFormat(DataFormat.JSON) + .build(); + + AsyncModelConfig asyncModelConfig = + AsyncModelConfig.newBuilder() + .setInputConfig(inputConfig) + .setOutputConfig(outputConfig) + .build(); + BatchOptimizeToursRequest request = + BatchOptimizeToursRequest.newBuilder() + .setParent(projectParent) + .addModelConfigs(asyncModelConfig) + .build(); + + FleetRoutingClient fleetRoutingClient = FleetRoutingClient.create(); + OperationFuture response = + fleetRoutingClient.batchOptimizeToursAsync(request); + System.out.format("the response name: %s\n", response.getInitialFuture().get().getName()); + + // Block to wait for the job to finish. + response.getPollingFuture().get(); + if (response.getMetadata().get().getState() == AsyncModelMetadata.State.SUCCEEDED) { + // Code to do your stuff + System.out.println("Job finished successfully."); + } else { + System.out.println( + "Job failed with message:" + response.getPollingFuture().get().getErrorMessage()); + } + } +} +// [END cloudoptimization_async_api] diff --git a/optimization/snippets/src/main/java/com/example/optimizationai/GetOperation.java b/optimization/snippets/src/main/java/com/example/optimizationai/GetOperation.java new file mode 100644 index 00000000000..6a6e8fd0ece --- /dev/null +++ b/optimization/snippets/src/main/java/com/example/optimizationai/GetOperation.java @@ -0,0 +1,57 @@ +/* + * Copyright 2022 Google LLC + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.example.optimizationai; + +// [START cloudoptimization_get_operation] +import com.google.cloud.optimization.v1.FleetRoutingClient; +import com.google.longrunning.Operation; +import java.io.IOException; + +class GetOperation { + + static void getOperation() throws IOException { + // TODO(developer): Replace these variables before running the sample. + String operationFullId = "projects/[projectId]/operations/[operationId]"; + getOperation(operationFullId); + } + + // Get the status of an operation + static void getOperation(String operationFullId) throws IOException { + // Initialize client that will be used to send requests. This client only needs to be created + // once, and can be reused for multiple requests. After completing all of your requests, call + // the "close" method on the client to safely clean up any remaining background resources. + try (FleetRoutingClient client = FleetRoutingClient.create()) { + // Get the latest state of a long-running operation. + Operation operation = client.getOperationsClient().getOperation(operationFullId); + + // Display operation details. + System.out.println("Operation details:"); + System.out.format("\tName: %s\n", operation.getName()); + System.out.format("\tMetadata Type Url: %s\n", operation.getMetadata().getTypeUrl()); + System.out.format("\tDone: %s\n", operation.getDone()); + if (operation.hasResponse()) { + System.out.format("\tResponse Type Url: %s\n", operation.getResponse().getTypeUrl()); + } + if (operation.hasError()) { + System.out.println("\tResponse:"); + System.out.format("\t\tError code: %s\n", operation.getError().getCode()); + System.out.format("\t\tError message: %s\n", operation.getError().getMessage()); + } + } + } +} +// [END cloudoptimization_get_operation] diff --git a/optimization/snippets/src/main/java/com/example/optimizationai/SyncApi.java b/optimization/snippets/src/main/java/com/example/optimizationai/SyncApi.java new file mode 100644 index 00000000000..5e73344b17b --- /dev/null +++ b/optimization/snippets/src/main/java/com/example/optimizationai/SyncApi.java @@ -0,0 +1,57 @@ +/* + * Copyright 2022 Google LLC + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.example.optimizationai; + +// [START cloudoptimization_sync_api] + +import com.google.cloud.optimization.v1.FleetRoutingClient; +import com.google.cloud.optimization.v1.OptimizeToursRequest; +import com.google.cloud.optimization.v1.OptimizeToursResponse; +import com.google.protobuf.Duration; +import com.google.protobuf.TextFormat; +import java.io.FileInputStream; +import java.io.InputStream; +import java.io.InputStreamReader; +import java.io.Reader; + +/** + * This is an example to send a request to Cloud Fleet Routing synchronous API via Java API Client. + * A sample sync_request.textproto file can be found in the resources folder. + */ +public class SyncApi { + public static void callSyncApi() throws Exception { + // TODO(developer): Replace these variables before running the sample. + String projectParent = "projects/{YOUR_GCP_PROJECT_ID}"; + String modelPath = "YOUR_MODEL_PATH"; + callSyncApi(projectParent, modelPath); + } + + public static void callSyncApi(String projectParent, String modelPath) throws Exception { + int timeoutSeconds = 100; + InputStream modelInputstream = new FileInputStream(modelPath); + Reader modelInputStreamReader = new InputStreamReader(modelInputstream); + OptimizeToursRequest.Builder requestBuilder = + OptimizeToursRequest.newBuilder() + .setTimeout(Duration.newBuilder().setSeconds(timeoutSeconds).build()) + .setParent(projectParent); + TextFormat.getParser().merge(modelInputStreamReader, requestBuilder); + FleetRoutingClient fleetRoutingClient = FleetRoutingClient.create(); + OptimizeToursResponse response = fleetRoutingClient.optimizeTours(requestBuilder.build()); + System.out.println(response.toString()); + } +} +// [END cloudoptimization_sync_api] diff --git a/optimization/snippets/src/main/java/com/example/optimizationai/SyncApiWithLongTimeout.java b/optimization/snippets/src/main/java/com/example/optimizationai/SyncApiWithLongTimeout.java new file mode 100644 index 00000000000..152fd08e901 --- /dev/null +++ b/optimization/snippets/src/main/java/com/example/optimizationai/SyncApiWithLongTimeout.java @@ -0,0 +1,66 @@ +/* + * Copyright 2022 Google LLC + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.example.optimizationai; + +// [START cloudoptimization_long_timeout] + +import com.google.cloud.optimization.v1.FleetRoutingClient; +import com.google.cloud.optimization.v1.FleetRoutingSettings; +import com.google.cloud.optimization.v1.OptimizeToursRequest; +import com.google.cloud.optimization.v1.OptimizeToursResponse; +import com.google.protobuf.Duration; +import com.google.protobuf.TextFormat; +import java.io.FileInputStream; +import java.io.InputStream; +import java.io.InputStreamReader; +import java.io.Reader; + +/** + * This is an example to send a request to Cloud Fleet Routing synchronous API via Java API Client. + */ +public class SyncApiWithLongTimeout { + public static void longTimeout() throws Exception { + // TODO(developer): Replace these variables before running the sample. + String projectParent = "projects/{YOUR_GCP_PROJECT_ID}"; + String modelPath = "YOUR_MODEL_PATH"; + longTimeout(projectParent, modelPath); + } + + public static void longTimeout(String projectParent, String modelPath) throws Exception { + int timeoutSeconds = 100; + InputStream modelInputstream = new FileInputStream(modelPath); + Reader modelInputStreamReader = new InputStreamReader(modelInputstream); + OptimizeToursRequest.Builder requestBuilder = + OptimizeToursRequest.newBuilder() + .setTimeout(Duration.newBuilder().setSeconds(timeoutSeconds).build()) + .setParent(projectParent); + TextFormat.getParser().merge(modelInputStreamReader, requestBuilder); + + // Checks the gRPC connection every 5 mins and keeps it alive. + FleetRoutingClient fleetRoutingClientClient = + FleetRoutingClient.create( + FleetRoutingSettings.newBuilder() + .setTransportChannelProvider( + FleetRoutingSettings.defaultGrpcTransportProviderBuilder() + .setKeepAliveTime(org.threeten.bp.Duration.ofSeconds(300)) + .build()) + .build()); + OptimizeToursResponse response = fleetRoutingClientClient.optimizeTours(requestBuilder.build()); + System.out.println(response.toString()); + } +} +// [END cloudoptimization_long_timeout] diff --git a/optimization/snippets/src/test/java/com/example/optimizationai/AsyncApiTest.java b/optimization/snippets/src/test/java/com/example/optimizationai/AsyncApiTest.java new file mode 100644 index 00000000000..058b46a3b9f --- /dev/null +++ b/optimization/snippets/src/test/java/com/example/optimizationai/AsyncApiTest.java @@ -0,0 +1,93 @@ +/* + * Copyright 2022 Google LLC + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.optimizationai; + +import static com.google.common.truth.Truth.assertThat; + +import com.google.api.gax.paging.Page; +import com.google.cloud.storage.Blob; +import com.google.cloud.storage.BucketInfo; +import com.google.cloud.storage.Storage; +import com.google.cloud.storage.StorageOptions; +import java.io.ByteArrayOutputStream; +import java.io.PrintStream; +import java.util.UUID; +import org.junit.After; +import org.junit.Before; +import org.junit.Test; + +/** Tests for AsyncApi sample. */ +public class AsyncApiTest { + private static final String PROJECT_ID = System.getenv("GOOGLE_CLOUD_PROJECT"); + private static final String PROJECT_PARENT = String.format("projects/%s", PROJECT_ID); + private static final String BUCKET_NAME = + String.format("optimizationai-test-%s", UUID.randomUUID()); + private static final String INPUT_URI = + "gs://cloud-samples-data/optimization-ai/async_request_model.json"; + private static final String BATCH_OUTPUT_URI = + String.format("gs://%s/code_snippets_test_output.json", BUCKET_NAME); + + private ByteArrayOutputStream bout; + private PrintStream out; + private PrintStream originalPrintStream; + + private static void cleanUpBucket() { + Storage storage = StorageOptions.getDefaultInstance().getService(); + Page blobs = storage.list(BUCKET_NAME, Storage.BlobListOption.currentDirectory()); + + deleteDirectory(storage, blobs); + } + + private static void deleteDirectory(Storage storage, Page blobs) { + for (Blob blob : blobs.iterateAll()) { + if (!blob.delete()) { + Page subBlobs = + storage.list( + BUCKET_NAME, + Storage.BlobListOption.currentDirectory(), + Storage.BlobListOption.prefix(blob.getName())); + + deleteDirectory(storage, subBlobs); + } + } + } + + @Before + public void setUp() { + bout = new ByteArrayOutputStream(); + out = new PrintStream(bout); + originalPrintStream = System.out; + System.setOut(out); + + Storage storage = StorageOptions.getDefaultInstance().getService(); + storage.create(BucketInfo.of(BUCKET_NAME)); + } + + @After + public void tearDown() { + cleanUpBucket(); + System.out.flush(); + System.setOut(originalPrintStream); + } + + @Test + public void testAsyncApi() throws Exception { + AsyncApi.callAsyncApi(PROJECT_PARENT, INPUT_URI, BATCH_OUTPUT_URI); + String got = bout.toString(); + assertThat(got).contains("Job"); + } +} diff --git a/optimization/snippets/src/test/java/com/example/optimizationai/GetOperationTest.java b/optimization/snippets/src/test/java/com/example/optimizationai/GetOperationTest.java new file mode 100644 index 00000000000..32ef2cb0528 --- /dev/null +++ b/optimization/snippets/src/test/java/com/example/optimizationai/GetOperationTest.java @@ -0,0 +1,67 @@ +/* + * Copyright 2022 Google LLC + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.example.optimizationai; + +import static com.google.common.truth.Truth.assertThat; + +import com.google.api.gax.longrunning.OperationFuture; +import com.google.cloud.optimization.v1.AsyncModelMetadata; +import com.google.cloud.optimization.v1.BatchOptimizeToursRequest; +import com.google.cloud.optimization.v1.BatchOptimizeToursResponse; +import com.google.cloud.optimization.v1.FleetRoutingClient; +import java.io.ByteArrayOutputStream; +import java.io.PrintStream; +import org.junit.After; +import org.junit.Before; +import org.junit.Test; + +/** Tests for GetOperation sample. */ +public class GetOperationTest { + private static final String PROJECT_ID = System.getenv("GOOGLE_CLOUD_PROJECT"); + private static final String PROJECT_PARENT = String.format("projects/%s", PROJECT_ID); + + private ByteArrayOutputStream bout; + private PrintStream out; + private PrintStream originalPrintStream; + + @Before + public void setUp() { + bout = new ByteArrayOutputStream(); + out = new PrintStream(bout); + originalPrintStream = System.out; + System.setOut(out); + } + + @After + public void tearDown() { + System.out.flush(); + System.setOut(originalPrintStream); + } + + @Test + public void testSyncApi() throws Exception { + FleetRoutingClient fleetRoutingClient = FleetRoutingClient.create(); + BatchOptimizeToursRequest request = + BatchOptimizeToursRequest.newBuilder().setParent(PROJECT_PARENT).build(); + OperationFuture response = + fleetRoutingClient.batchOptimizeToursAsync(request); + + GetOperation.getOperation(response.getInitialFuture().get().getName()); + String got = bout.toString(); + assertThat(got).contains("operations"); + } +} diff --git a/optimization/snippets/src/test/java/com/example/optimizationai/SyncApiTest.java b/optimization/snippets/src/test/java/com/example/optimizationai/SyncApiTest.java new file mode 100644 index 00000000000..e663a924584 --- /dev/null +++ b/optimization/snippets/src/test/java/com/example/optimizationai/SyncApiTest.java @@ -0,0 +1,57 @@ +/* + * Copyright 2022 Google LLC + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.example.optimizationai; + +import static com.google.common.truth.Truth.assertThat; + +import java.io.ByteArrayOutputStream; +import java.io.PrintStream; +import org.junit.After; +import org.junit.Before; +import org.junit.Test; + +/** Tests for SyncApi sample. */ +public class SyncApiTest { + private static final String PROJECT_ID = System.getenv("GOOGLE_CLOUD_PROJECT"); + private static final String PROJECT_PARENT = String.format("projects/%s", PROJECT_ID); + private static final String MODEL_PATH = "resources/sync_request.textproto"; + + private ByteArrayOutputStream bout; + private PrintStream out; + private PrintStream originalPrintStream; + + @Before + public void setUp() { + bout = new ByteArrayOutputStream(); + out = new PrintStream(bout); + originalPrintStream = System.out; + System.setOut(out); + } + + @After + public void tearDown() { + System.out.flush(); + System.setOut(originalPrintStream); + } + + @Test + public void testSyncApi() throws Exception { + SyncApi.callSyncApi(PROJECT_PARENT, MODEL_PATH); + String got = bout.toString(); + assertThat(got).contains("routes"); + } +} diff --git a/optimization/snippets/src/test/java/com/example/optimizationai/SyncApiWithLongTimeoutTest.java b/optimization/snippets/src/test/java/com/example/optimizationai/SyncApiWithLongTimeoutTest.java new file mode 100644 index 00000000000..0dc7b1125fa --- /dev/null +++ b/optimization/snippets/src/test/java/com/example/optimizationai/SyncApiWithLongTimeoutTest.java @@ -0,0 +1,57 @@ +/* + * Copyright 2022 Google LLC + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.example.optimizationai; + +import static com.google.common.truth.Truth.assertThat; + +import java.io.ByteArrayOutputStream; +import java.io.PrintStream; +import org.junit.After; +import org.junit.Before; +import org.junit.Test; + +/** Tests for SyncApiWithLongTimeout sample. */ +public class SyncApiWithLongTimeoutTest { + private static final String PROJECT_ID = System.getenv("GOOGLE_CLOUD_PROJECT"); + private static final String PROJECT_PARENT = String.format("projects/%s", PROJECT_ID); + private static final String MODEL_PATH = "resources/sync_request.textproto"; + + private ByteArrayOutputStream bout; + private PrintStream out; + private PrintStream originalPrintStream; + + @Before + public void setUp() { + bout = new ByteArrayOutputStream(); + out = new PrintStream(bout); + originalPrintStream = System.out; + System.setOut(out); + } + + @After + public void tearDown() { + System.out.flush(); + System.setOut(originalPrintStream); + } + + @Test + public void testSyncApi() throws Exception { + SyncApiWithLongTimeout.longTimeout(PROJECT_PARENT, MODEL_PATH); + String got = bout.toString(); + assertThat(got).contains("routes"); + } +}