Skip to content

Commit aab8e4c

Browse files
bevzzzbevzzz
committed
chore: apply formatting changes
1 parent 30bc878 commit aab8e4c

2 files changed

Lines changed: 78 additions & 77 deletions

File tree

‎src/main/java/io/weaviate/client/v1/async/backup/api/BackupRestorer.java‎

Lines changed: 70 additions & 68 deletions
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,18 @@
11
package io.weaviate.client.v1.async.backup.api;
22

3+
import java.util.List;
4+
import java.util.Optional;
5+
import java.util.concurrent.CompletableFuture;
6+
import java.util.concurrent.CompletionException;
7+
import java.util.concurrent.Executor;
8+
import java.util.concurrent.Future;
9+
10+
import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient;
11+
import org.apache.hc.core5.concurrent.FutureCallback;
12+
import org.apache.hc.core5.http.HttpStatus;
13+
314
import com.google.gson.annotations.SerializedName;
15+
416
import io.weaviate.client.Config;
517
import io.weaviate.client.base.AsyncBaseClient;
618
import io.weaviate.client.base.AsyncClientResult;
@@ -16,19 +28,9 @@
1628
import io.weaviate.client.v1.backup.model.RestoreStatus;
1729
import lombok.Builder;
1830
import lombok.Getter;
19-
import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient;
20-
import org.apache.hc.core5.concurrent.FutureCallback;
21-
import org.apache.hc.core5.http.HttpStatus;
22-
23-
import java.util.List;
24-
import java.util.Optional;
25-
import java.util.concurrent.CompletableFuture;
26-
import java.util.concurrent.CompletionException;
27-
import java.util.concurrent.Executor;
28-
import java.util.concurrent.Future;
2931

3032
public class BackupRestorer extends AsyncBaseClient<BackupRestoreResponse>
31-
implements AsyncClientResult<BackupRestoreResponse> {
33+
implements AsyncClientResult<BackupRestoreResponse> {
3234

3335
private static final long WAIT_INTERVAL = 1000;
3436

@@ -41,14 +43,13 @@ public class BackupRestorer extends AsyncBaseClient<BackupRestoreResponse>
4143
private boolean waitForCompletion;
4244
private final Executor executor;
4345

44-
45-
public BackupRestorer(CloseableHttpAsyncClient client, Config config, AccessTokenProvider tokenProvider, BackupRestoreStatusGetter statusGetter, Executor executor) {
46+
public BackupRestorer(CloseableHttpAsyncClient client, Config config, AccessTokenProvider tokenProvider,
47+
BackupRestoreStatusGetter statusGetter, Executor executor) {
4648
super(client, config, tokenProvider);
4749
this.statusGetter = statusGetter;
4850
this.executor = executor;
4951
}
5052

51-
5253
public BackupRestorer withIncludeClassNames(String... classNames) {
5354
this.includeClassNames = classNames;
5455
return this;
@@ -87,19 +88,20 @@ public Future<Result<BackupRestoreResponse>> run(FutureCallback<Result<BackupRes
8788
return restore(callback);
8889
}
8990

90-
9191
private Future<Result<BackupRestoreResponse>> restore(FutureCallback<Result<BackupRestoreResponse>> callback) {
9292
BackupRestore payload = BackupRestore.builder()
93-
.config(BackupRestoreConfig.builder().build())
94-
.include(includeClassNames)
95-
.exclude(excludeClassNames)
96-
.config(config)
97-
.build();
98-
String path = String.format("/backups/%s/%s/restore", UrlEncoder.encodePathParam(backend), UrlEncoder.encodePathParam(backupId));
93+
.config(BackupRestoreConfig.builder().build())
94+
.include(includeClassNames)
95+
.exclude(excludeClassNames)
96+
.config(config)
97+
.build();
98+
String path = String.format("/backups/%s/%s/restore", UrlEncoder.encodePathParam(backend),
99+
UrlEncoder.encodePathParam(backupId));
99100
return sendPostRequest(path, payload, BackupRestoreResponse.class, callback);
100101
}
101102

102-
private Future<Result<BackupRestoreResponse>> restoreAndWaitForCompletion(FutureCallback<Result<BackupRestoreResponse>> callback) {
103+
private Future<Result<BackupRestoreResponse>> restoreAndWaitForCompletion(
104+
FutureCallback<Result<BackupRestoreResponse>> callback) {
103105
CompletableFuture<Result<BackupRestoreResponse>> future = new CompletableFuture<>();
104106
FutureCallback<Result<BackupRestoreResponse>> internalCallback = new FutureCallback<Result<BackupRestoreResponse>>() {
105107
@Override
@@ -124,64 +126,65 @@ public void cancelled() {
124126
restore(internalCallback);
125127

126128
return future.thenCompose(restoreResult -> {
127-
if (restoreResult.hasErrors()) {
128-
return CompletableFuture.completedFuture(restoreResult);
129-
}
130-
return getStatusRecursively(backend, backupId, restoreResult);
131-
})
132-
.whenComplete((restoreResult, throwable) -> {
133-
if (callback != null) {
134-
if (throwable != null) {
135-
callback.failed((Exception) throwable);
136-
} else {
137-
callback.completed(restoreResult);
129+
if (restoreResult.hasErrors()) {
130+
return CompletableFuture.completedFuture(restoreResult);
131+
}
132+
return getStatusRecursively(backend, backupId, restoreResult);
133+
})
134+
.whenComplete((restoreResult, throwable) -> {
135+
if (callback != null) {
136+
if (throwable != null) {
137+
callback.failed((Exception) throwable);
138+
} else {
139+
callback.completed(restoreResult);
140+
}
138141
}
139-
}
140-
});
142+
});
141143
}
142144

143145
private CompletableFuture<Result<BackupRestoreStatusResponse>> getStatus(String backend, String backupId) {
144146
CompletableFuture<Result<BackupRestoreStatusResponse>> future = new CompletableFuture<>();
145147
statusGetter.withBackend(backend).withBackupId(backupId)
146-
.run(new FutureCallback<Result<BackupRestoreStatusResponse>>() {
147-
@Override
148-
public void completed(Result<BackupRestoreStatusResponse> createStatusResult) {
149-
future.complete(createStatusResult);
150-
}
148+
.run(new FutureCallback<Result<BackupRestoreStatusResponse>>() {
149+
@Override
150+
public void completed(Result<BackupRestoreStatusResponse> createStatusResult) {
151+
future.complete(createStatusResult);
152+
}
151153

152-
@Override
153-
public void failed(Exception e) {
154-
future.completeExceptionally(e);
155-
}
154+
@Override
155+
public void failed(Exception e) {
156+
future.completeExceptionally(e);
157+
}
156158

157-
@Override
158-
public void cancelled() {
159-
}
160-
});
159+
@Override
160+
public void cancelled() {
161+
}
162+
});
161163
return future;
162164
}
163165

164166
private CompletableFuture<Result<BackupRestoreResponse>> getStatusRecursively(String backend, String backupId,
165-
Result<BackupRestoreResponse> restoreResult) {
167+
Result<BackupRestoreResponse> restoreResult) {
166168
return Futures.thenComposeAsync(getStatus(backend, backupId), restoreStatusResult -> {
167169
boolean isRunning = Optional.of(restoreStatusResult)
168-
.filter(r -> !r.hasErrors())
169-
.map(Result::getResult)
170-
.map(BackupRestoreStatusResponse::getStatus)
171-
.filter(status -> {
172-
switch (status) {
173-
case RestoreStatus.SUCCESS:
174-
case RestoreStatus.FAILED:
175-
return false;
176-
default:
177-
return true;
178-
}
179-
})
180-
.isPresent();
170+
.filter(r -> !r.hasErrors())
171+
.map(Result::getResult)
172+
.map(BackupRestoreStatusResponse::getStatus)
173+
.filter(status -> {
174+
switch (status) {
175+
case RestoreStatus.SUCCESS:
176+
case RestoreStatus.FAILED:
177+
return false;
178+
default:
179+
return true;
180+
}
181+
})
182+
.isPresent();
181183

182184
if (isRunning) {
183185
try {
184-
return Futures.supplyDelayed(() -> getStatusRecursively(backend, backupId, restoreResult), WAIT_INTERVAL, executor);
186+
return Futures.supplyDelayed(() -> getStatusRecursively(backend, backupId, restoreResult), WAIT_INTERVAL,
187+
executor);
185188
} catch (InterruptedException e) {
186189
throw new CompletionException(e);
187190
}
@@ -191,7 +194,7 @@ private CompletableFuture<Result<BackupRestoreResponse>> getStatusRecursively(St
191194
}
192195

193196
private Result<BackupRestoreResponse> merge(Result<BackupRestoreStatusResponse> restoreStatusResult,
194-
Result<BackupRestoreResponse> restoreResult) {
197+
Result<BackupRestoreResponse> restoreResult) {
195198
BackupRestoreStatusResponse restoreStatusResponse = restoreStatusResult.getResult();
196199
BackupRestoreResponse restoreResponse = restoreResult.getResult();
197200

@@ -215,15 +218,14 @@ private Result<BackupRestoreResponse> merge(Result<BackupRestoreStatusResponse>
215218
List<WeaviateErrorMessage> messages = error.getMessages();
216219

217220
errorResponse = WeaviateErrorResponse.builder()
218-
.code(statusCode)
219-
.error(messages)
220-
.build();
221+
.code(statusCode)
222+
.error(messages)
223+
.build();
221224
}
222225

223226
return new Result<>(statusCode, merged, errorResponse);
224227
}
225228

226-
227229
@Getter
228230
@Builder
229231
private static class BackupRestore {

‎src/main/java/io/weaviate/client/v1/backup/api/BackupRestorer.java‎

Lines changed: 8 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -68,19 +68,18 @@ public BackupRestorer withWaitForCompletion(boolean waitForCompletion) {
6868
@Override
6969
public Result<BackupRestoreResponse> run() {
7070
BackupRestore payload = BackupRestore.builder()
71-
.config(BackupRestoreConfig.builder().build())
72-
.include(includeClassNames)
73-
.exclude(excludeClassNames)
74-
.config(config)
75-
.build();
71+
.config(BackupRestoreConfig.builder().build())
72+
.include(includeClassNames)
73+
.exclude(excludeClassNames)
74+
.config(config)
75+
.build();
7676

7777
if (waitForCompletion) {
7878
return restoreAndWaitForCompletion(payload);
7979
}
8080
return restore(payload);
8181
}
8282

83-
8483
private Result<BackupRestoreResponse> restore(BackupRestore payload) {
8584
Response<BackupRestoreResponse> response = sendPostRequest(path(), payload, BackupRestoreResponse.class);
8685
return new Result<>(response);
@@ -93,7 +92,7 @@ private Result<BackupRestoreResponse> restoreAndWaitForCompletion(BackupRestore
9392
}
9493

9594
statusGetter.withBackend(backend).withBackupId(backupId);
96-
while(true) {
95+
while (true) {
9796
Response<BackupRestoreStatusResponse> statusResponse = statusGetter.statusRestore();
9897
if (new Result<>(statusResponse).hasErrors()) {
9998
return merge(statusResponse, result);
@@ -117,7 +116,8 @@ private String path() {
117116
return String.format("/backups/%s/%s/restore", backend, backupId);
118117
}
119118

120-
private Result<BackupRestoreResponse> merge(Response<BackupRestoreStatusResponse> response, Result<BackupRestoreResponse> result) {
119+
private Result<BackupRestoreResponse> merge(Response<BackupRestoreStatusResponse> response,
120+
Result<BackupRestoreResponse> result) {
121121
BackupRestoreStatusResponse statusRestoreResponse = response.getBody();
122122
BackupRestoreResponse restoreResponse = result.getResult();
123123

@@ -136,7 +136,6 @@ private Result<BackupRestoreResponse> merge(Response<BackupRestoreStatusResponse
136136
return new Result<>(response.getStatusCode(), merged, response.getErrors());
137137
}
138138

139-
140139
@Getter
141140
@Builder
142141
private static class BackupRestore {

0 commit comments

Comments
 (0)