Skip to content

The Unified and Autonomous Development Platform

fix: Harden internal LFS transfers and uploads

Robin Shen27216d8cdccd
diff --git a/server-core/src/main/java/io/onedev/server/cluster/ClusterResource.java b/server-core/src/main/java/io/onedev/server/cluster/ClusterResource.java
index 5b7de0463a..80bf665260 100644
--- a/server-core/src/main/java/io/onedev/server/cluster/ClusterResource.java
+++ b/server-core/src/main/java/io/onedev/server/cluster/ClusterResource.java
@@ -381,8 +381,8 @@ public class ClusterResource {
if (!SecurityUtils.isSystem())
throw new UnauthorizedException("This api can only be accessed via cluster credential");
- try (input; OutputStream os = new LfsObject(projectId, objectId).getOutputStream()) {
- IOUtils.copy(input, os, BUFFER_SIZE);
+ try (input) {
+ new LfsObject(projectId, objectId).upload(input);
} catch (IOException e) {
throw new RuntimeException(e);
}
diff --git a/server-core/src/main/java/io/onedev/server/git/GitLfsFilter.java b/server-core/src/main/java/io/onedev/server/git/GitLfsFilter.java
index 886498680c..8c3304cac7 100644
--- a/server-core/src/main/java/io/onedev/server/git/GitLfsFilter.java
+++ b/server-core/src/main/java/io/onedev/server/git/GitLfsFilter.java
@@ -1,6 +1,5 @@
package io.onedev.server.git;
-import static com.google.common.hash.Hashing.sha256;
import static io.onedev.k8shelper.KubernetesHelper.BEARER;
import static io.onedev.server.model.Project.decodeFullRepoNameAsPath;
import static io.onedev.server.util.CollectionUtils.newHashMap;
@@ -12,6 +11,7 @@ import static jakarta.servlet.http.HttpServletResponse.SC_INTERNAL_SERVER_ERROR;
import static jakarta.servlet.http.HttpServletResponse.SC_NOT_ACCEPTABLE;
import static jakarta.servlet.http.HttpServletResponse.SC_NOT_FOUND;
import static jakarta.servlet.http.HttpServletResponse.SC_NOT_IMPLEMENTED;
+import static jakarta.servlet.http.HttpServletResponse.SC_REQUEST_ENTITY_TOO_LARGE;
import static jakarta.servlet.http.HttpServletResponse.SC_UNAUTHORIZED;
import static jakarta.ws.rs.core.HttpHeaders.AUTHORIZATION;
import static jakarta.ws.rs.core.MediaType.APPLICATION_OCTET_STREAM;
@@ -28,7 +28,6 @@ import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
-import java.util.concurrent.atomic.AtomicReference;
import java.util.function.BooleanSupplier;
import jakarta.inject.Inject;
@@ -49,7 +48,6 @@ import jakarta.ws.rs.client.WebTarget;
import jakarta.ws.rs.core.Response;
import jakarta.ws.rs.core.StreamingOutput;
-import org.apache.commons.codec.binary.Hex;
import org.apache.commons.lang3.StringUtils;
import io.onedev.server.persistence.dao.Restrictions;
import org.jspecify.annotations.Nullable;
@@ -58,11 +56,11 @@ import org.slf4j.LoggerFactory;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
-import com.google.common.hash.HashingInputStream;
import io.onedev.commons.utils.ExplicitException;
import io.onedev.k8shelper.KubernetesHelper;
import io.onedev.server.cluster.ClusterService;
+import io.onedev.server.exception.HttpResponseAwareException;
import io.onedev.server.model.GitLfsLock;
import io.onedev.server.model.Project;
import io.onedev.server.persistence.SessionService;
@@ -254,50 +252,37 @@ public class GitLfsFilter implements Filter {
if (lfsObject != null) {
String activeServer = projectService.getActiveServer(lfsObject.getProjectId(), true);
- var hash = new AtomicReference<String>(null);
- try {
- if (activeServer.equals(clusterService.getLocalServerAddress())) {
- try (
- HashingInputStream is = new HashingInputStream(
- sha256(), httpRequest.getInputStream());
- OutputStream os = lfsObject.getOutputStream()) {
- IOUtils.copy(is, os, BUFFER_SIZE);
- hash.set(Hex.encodeHexString(is.hash().asBytes()));
- }
- } else {
- Client client = ClientBuilder.newClient();
- client.property(REQUEST_ENTITY_PROCESSING, "CHUNKED");
- try {
- String serverUrl = clusterService.getServerUrl(activeServer);
- WebTarget target = client.target(serverUrl)
- .path("~api/cluster/lfs")
- .queryParam("projectId", lfsObject.getProjectId())
- .queryParam("objectId", lfsObject.getObjectId());
- Invocation.Builder builder = target.request();
- builder.header(AUTHORIZATION,
- BEARER + " " + clusterService.getCredential());
-
- StreamingOutput os = output -> {
- try (HashingInputStream is = new HashingInputStream(
- sha256(), httpRequest.getInputStream())) {
- IOUtils.copy(is, output, BUFFER_SIZE);
- hash.set(Hex.encodeHexString(is.hash().asBytes()));
- } finally {
- output.close();
- }
- };
+ if (activeServer.equals(clusterService.getLocalServerAddress())) {
+ try (InputStream is = httpRequest.getInputStream()) {
+ lfsObject.upload(is);
+ }
+ } else {
+ Client client = ClientBuilder.newClient();
+ client.property(REQUEST_ENTITY_PROCESSING, "CHUNKED");
+ try {
+ String serverUrl = clusterService.getServerUrl(activeServer);
+ WebTarget target = client.target(serverUrl)
+ .path("~api/cluster/lfs")
+ .queryParam("projectId", lfsObject.getProjectId())
+ .queryParam("objectId", lfsObject.getObjectId());
+ Invocation.Builder builder = target.request();
+ builder.header(AUTHORIZATION,
+ BEARER + " " + clusterService.getCredential());
- try (Response lfsResponse = builder.post(Entity.entity(os, APPLICATION_OCTET_STREAM))) {
- KubernetesHelper.checkStatus(lfsResponse);
+ StreamingOutput os = output -> {
+ try (output; InputStream is = httpRequest.getInputStream()) {
+ LfsObject.copyUpload(is, output);
}
- } finally {
- client.close();
+ };
+
+ try (Response lfsResponse = builder.post(Entity.entity(os, APPLICATION_OCTET_STREAM))) {
+ if (lfsResponse.getStatus() == SC_REQUEST_ENTITY_TOO_LARGE)
+ throw new HttpResponseAwareException(SC_REQUEST_ENTITY_TOO_LARGE,
+ lfsResponse.readEntity(String.class));
+ KubernetesHelper.checkStatus(lfsResponse);
}
- }
- } finally {
- if (!objectId.equals(hash.get())) {
- lfsObject.delete();
- throw new RuntimeException("Invalid uploaded content: hash not equals to object id");
+ } finally {
+ client.close();
}
}
}
diff --git a/server-core/src/main/java/io/onedev/server/git/GitUtils.java b/server-core/src/main/java/io/onedev/server/git/GitUtils.java
index 8b5c7c5f08..d8b77a2f7b 100644
--- a/server-core/src/main/java/io/onedev/server/git/GitUtils.java
+++ b/server-core/src/main/java/io/onedev/server/git/GitUtils.java
@@ -806,6 +806,10 @@ public class GitUtils {
}).checkReturnCode();
+ // Restrict Git LFS to our trusted config. In bare repositories, GIT_CONFIG also
+ // prevents its "git config --blob HEAD:.lfsconfig" from reading repository content.
+ git.envs().put("GIT_CONFIG", new File(homeDir, ".gitconfig").getAbsolutePath());
+
return task.call(git);
} catch (IOException e) {
throw new RuntimeException(e);
diff --git a/server-core/src/main/java/io/onedev/server/git/LfsObject.java b/server-core/src/main/java/io/onedev/server/git/LfsObject.java
index dd0faa534c..efa2678c9b 100644
--- a/server-core/src/main/java/io/onedev/server/git/LfsObject.java
+++ b/server-core/src/main/java/io/onedev/server/git/LfsObject.java
@@ -1,33 +1,40 @@
package io.onedev.server.git;
+import static com.google.common.hash.Hashing.sha256;
import static io.onedev.server.util.IOUtils.BUFFER_SIZE;
+import static jakarta.servlet.http.HttpServletResponse.SC_REQUEST_ENTITY_TOO_LARGE;
+import static java.nio.file.StandardCopyOption.ATOMIC_MOVE;
+import static java.nio.file.StandardCopyOption.REPLACE_EXISTING;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
-import java.io.FileOutputStream;
import java.io.FilterInputStream;
-import java.io.FilterOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.Serializable;
+import java.nio.file.Files;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.regex.Pattern;
import org.apache.tika.mime.MediaType;
-import org.jetbrains.annotations.NotNull;
import org.jspecify.annotations.Nullable;
+import com.google.common.hash.HashingInputStream;
+
import io.onedev.commons.utils.ExplicitException;
import io.onedev.commons.utils.FileUtils;
import io.onedev.commons.utils.LockUtils;
import io.onedev.server.OneDev;
import io.onedev.server.cluster.ClusterTask;
+import io.onedev.server.exception.HttpResponseAwareException;
import io.onedev.server.service.ProjectService;
+import io.onedev.server.service.SettingService;
import io.onedev.server.util.ContentDetector;
+import io.onedev.server.util.IOUtils;
public class LfsObject implements Serializable {
@@ -128,29 +135,36 @@ public class LfsObject implements Serializable {
}
}
- public OutputStream getOutputStream() {
- Lock writeLock = getLock().writeLock();
- writeLock.lock();
- try {
- return new FilterOutputStream(new BufferedOutputStream(new FileOutputStream(getFile()), BUFFER_SIZE)) {
- @Override
- public void write(@NotNull byte[] b, int off, int len) throws IOException {
- out.write(b, off, len);
- }
+ public static void copyUpload(InputStream input, OutputStream output) throws IOException {
+ long maxSize = (long) OneDev.getInstance(SettingService.class)
+ .getPerformanceSetting().getMaxGitLFSFileSize() * 1024 * 1024;
+ // Read one extra byte to distinguish an exact-size upload from an oversized one.
+ if (maxSize < 0 || IOUtils.copyLarge(input, output, 0, maxSize + 1, new byte[BUFFER_SIZE]) > maxSize)
+ throw new HttpResponseAwareException(SC_REQUEST_ENTITY_TOO_LARGE,
+ "Exceeded max acceptable LFS file size " + maxSize);
+ }
- @Override
- public void close() throws IOException {
- try {
- super.close();
- } finally {
- writeLock.unlock();
- }
- }
-
- };
- } catch (FileNotFoundException e) {
- writeLock.unlock();
- throw new RuntimeException(e);
+ public void upload(InputStream input) throws IOException {
+ File file = getFile();
+ // Keep the upload on the same filesystem so publishing it can be atomic.
+ var tempFile = Files.createTempFile(file.getParentFile().toPath(), "upload-", ".tmp");
+ try {
+ var is = new HashingInputStream(sha256(), input);
+ try (OutputStream os = new BufferedOutputStream(Files.newOutputStream(tempFile), BUFFER_SIZE)) {
+ copyUpload(is, os);
+ }
+ if (!objectId.equals(is.hash().toString()))
+ throw new ExplicitException("Invalid uploaded content: hash not equals to object id");
+
+ Lock writeLock = getLock().writeLock();
+ writeLock.lock();
+ try {
+ Files.move(tempFile, file.toPath(), ATOMIC_MOVE, REPLACE_EXISTING);
+ } finally {
+ writeLock.unlock();
+ }
+ } finally {
+ Files.deleteIfExists(tempFile);
}
}
diff --git a/server-core/src/main/java/io/onedev/server/service/impl/DefaultProjectService.java b/server-core/src/main/java/io/onedev/server/service/impl/DefaultProjectService.java
index 3dd49cdc21..efa7afab62 100644
--- a/server-core/src/main/java/io/onedev/server/service/impl/DefaultProjectService.java
+++ b/server-core/src/main/java/io/onedev/server/service/impl/DefaultProjectService.java
@@ -638,7 +638,15 @@ public class DefaultProjectService extends BaseEntityService<Project>
if (withLfs)
// Use origin instead of real url as otherwise the command will
// report EOF error when fetch from a local path
- new LfsFetchAllCommand(toGitDir, "origin").run();
+ new LfsFetchAllCommand(toGitDir, "origin") {
+ @Override
+ protected Commandline newGit() {
+ var git = super.newGit();
+ // Ignore HEAD:.lfsconfig while retaining the local origin URL.
+ git.envs().put("GIT_CONFIG", new File(toGitDir, "config").getAbsolutePath());
+ return git;
+ }
+ }.run();
} else {
var remoteUrl = clusterService.getServerUrl(fromActiveServer) + "/" + fromPath;
callWithClusterCredential(git -> {
diff --git a/server-core/src/test/java/io/onedev/server/git/LfsUploadTest.java b/server-core/src/test/java/io/onedev/server/git/LfsUploadTest.java
new file mode 100644
index 0000000000..08cdf3a967
--- /dev/null
+++ b/server-core/src/test/java/io/onedev/server/git/LfsUploadTest.java
@@ -0,0 +1,320 @@
+package io.onedev.server.git;
+
+import static com.google.common.hash.Hashing.sha256;
+import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.FilterInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.List;
+import java.util.Set;
+
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.EnumSource;
+import org.mockito.MockedStatic;
+
+import com.google.common.io.CountingInputStream;
+
+import io.onedev.commons.utils.ExplicitException;
+import io.onedev.commons.utils.ExceptionUtils;
+import io.onedev.server.OneDev;
+import io.onedev.server.cluster.ClusterResource;
+import io.onedev.server.cluster.ClusterService;
+import io.onedev.server.cluster.ClusterTask;
+import io.onedev.server.exception.HttpResponseAwareException;
+import io.onedev.server.model.Project;
+import io.onedev.server.model.support.administration.PerformanceSetting;
+import io.onedev.server.persistence.SessionService;
+import io.onedev.server.security.SecurityUtils;
+import io.onedev.server.service.ProjectService;
+import io.onedev.server.service.SettingService;
+import jakarta.servlet.FilterChain;
+import jakarta.servlet.ReadListener;
+import jakarta.servlet.ServletInputStream;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
+import jakarta.ws.rs.ProcessingException;
+import jakarta.ws.rs.client.Client;
+import jakarta.ws.rs.client.ClientBuilder;
+import jakarta.ws.rs.client.Entity;
+import jakarta.ws.rs.client.Invocation;
+import jakarta.ws.rs.client.WebTarget;
+import jakarta.ws.rs.core.Response;
+import jakarta.ws.rs.core.StreamingOutput;
+
+class LfsUploadTest {
+
+ enum Endpoint { DIRECT, CLUSTER, FORWARDED }
+
+ private static final int MAX_SIZE = 1024 * 1024;
+
+ @TempDir
+ Path storage;
+
+ private final byte[] content = "existing LFS content".getBytes(UTF_8);
+ private final String objectId = sha256().hashBytes(content).toString();
+ private MockedStatic<OneDev> oneDev;
+ private MockedStatic<SecurityUtils> security;
+ private ProjectService projects;
+ private PerformanceSetting performance;
+ private GitLfsFilter filter;
+ private Path objectFile;
+ private Response forwardedResponse;
+
+ @BeforeEach
+ void setUp() {
+ projects = mock(ProjectService.class);
+ when(projects.getLfsObjectsDir(1L)).thenReturn(storage.toFile());
+ when(projects.getGitDir(1L)).thenReturn(storage.toFile());
+ when(projects.getActiveServer(1L, true)).thenReturn("local");
+ when(projects.runOnActiveServer(any(), any()))
+ .thenAnswer(it -> it.getArgument(1, ClusterTask.class).call());
+ var project = new Project();
+ project.setId(1L);
+ when(projects.findByPath("test")).thenReturn(project);
+ oneDev = mockStatic(OneDev.class);
+ oneDev.when(() -> OneDev.getInstance(ProjectService.class)).thenReturn(projects);
+ performance = new PerformanceSetting();
+ performance.setMaxGitLFSFileSize(1);
+ var settings = mock(SettingService.class);
+ when(settings.getPerformanceSetting()).thenReturn(performance);
+ oneDev.when(() -> OneDev.getInstance(SettingService.class)).thenReturn(settings);
+ security = mockStatic(SecurityUtils.class);
+ security.when(() -> SecurityUtils.canAccessProject(project)).thenReturn(true);
+ security.when(() -> SecurityUtils.canWriteCode(project)).thenReturn(true);
+ var cluster = mock(ClusterService.class);
+ when(cluster.getLocalServerAddress()).thenReturn("local");
+ when(cluster.getServerUrl("remote")).thenReturn("http://active.example.invalid");
+ filter = new GitLfsFilter(projects, null, mock(SessionService.class), settings, null, cluster, Set.of());
+ objectFile = objectFile(objectId);
+ }
+
+ @AfterEach
+ void tearDown() {
+ security.close();
+ oneDev.close();
+ }
+
+ @ParameterizedTest
+ @EnumSource(Endpoint.class)
+ void acceptsValidAndRepeatedUploads(Endpoint endpoint) throws Exception {
+ upload(endpoint, new ByteArrayInputStream(content));
+ upload(endpoint, new ByteArrayInputStream(content));
+ assertStoredContent();
+ }
+
+ @ParameterizedTest
+ @EnumSource(Endpoint.class)
+ void invalidReuploadPreservesExistingObject(Endpoint endpoint) throws Exception {
+ upload(endpoint, new ByteArrayInputStream(content));
+ assertThrows(ExplicitException.class,
+ () -> upload(endpoint, new ByteArrayInputStream(new byte[0])));
+ assertStoredContent();
+ }
+
+ @ParameterizedTest
+ @EnumSource(Endpoint.class)
+ void interruptedReuploadPreservesExistingObject(Endpoint endpoint) throws Exception {
+ upload(endpoint, new ByteArrayInputStream(content));
+ assertInterruptedUpload(endpoint);
+ assertStoredContent();
+ }
+
+ @ParameterizedTest
+ @EnumSource(Endpoint.class)
+ void failedNewUploadsLeaveNoObjectsOrTemporaryFiles(Endpoint endpoint) throws Exception {
+ assertThrows(ExplicitException.class,
+ () -> upload(endpoint, new ByteArrayInputStream(new byte[0])));
+ assertFiles(List.of());
+ assertInterruptedUpload(endpoint);
+ assertFiles(List.of());
+ }
+
+ @ParameterizedTest
+ @EnumSource(Endpoint.class)
+ void acceptsUploadExactlyAtLimit(Endpoint endpoint) throws Exception {
+ var bytes = new byte[MAX_SIZE];
+ var id = sha256().hashBytes(bytes).toString();
+ upload(endpoint, id, new ByteArrayInputStream(bytes));
+ assertArrayEquals(bytes, Files.readAllBytes(objectFile(id)));
+ assertFiles(List.of(objectFile(id)));
+ }
+
+ @ParameterizedTest
+ @EnumSource(Endpoint.class)
+ void stopsOversizedUploadsAfterFirstExcessByte(Endpoint endpoint) throws Exception {
+ for (var size : new int[] {MAX_SIZE + 1, MAX_SIZE * 2}) {
+ var bytes = new byte[size];
+ var id = sha256().hashBytes(bytes).toString();
+ try (var input = new CountingInputStream(new ByteArrayInputStream(bytes))) {
+ assertSizeError(() -> upload(endpoint, id, input));
+ assertEquals(MAX_SIZE + 1, input.getCount());
+ }
+ assertFiles(List.of());
+ }
+ }
+
+ @ParameterizedTest
+ @EnumSource(Endpoint.class)
+ void oversizedReuploadPreservesExistingObject(Endpoint endpoint) throws Exception {
+ upload(endpoint, new ByteArrayInputStream(content));
+ assertSizeError(() -> upload(endpoint, new ByteArrayInputStream(new byte[MAX_SIZE + 1])));
+ assertStoredContent();
+ }
+
+ @ParameterizedTest
+ @EnumSource(Endpoint.class)
+ void zeroLimitAcceptsOnlyEmptyObjects(Endpoint endpoint) throws Exception {
+ performance.setMaxGitLFSFileSize(0);
+ var emptyId = sha256().hashBytes(new byte[0]).toString();
+ upload(endpoint, emptyId, new ByteArrayInputStream(new byte[0]));
+ assertEquals(0, Files.size(objectFile(emptyId)));
+ assertSizeError(() -> upload(endpoint, new ByteArrayInputStream(content)));
+ assertFiles(List.of(objectFile(emptyId)));
+ }
+
+ @Test
+ void preservesSizeErrorReturnedByActiveNode() {
+ forwardedResponse = mock(Response.class);
+ when(forwardedResponse.getStatus()).thenReturn(413);
+ when(forwardedResponse.readEntity(String.class)).thenReturn("Exceeded max acceptable LFS file size 0");
+ assertSizeError(() -> upload(Endpoint.FORWARDED, new ByteArrayInputStream(content)));
+ verify(forwardedResponse).close();
+ }
+
+ private void assertSizeError(org.junit.jupiter.api.function.Executable upload) {
+ var exception = assertThrows(Exception.class, upload);
+ var cause = ExceptionUtils.find(exception, HttpResponseAwareException.class);
+ assertNotNull(cause);
+ assertEquals(413, cause.getHttpResponse().getStatus());
+ assertTrue(cause.getMessage().startsWith("Exceeded max acceptable LFS file size "));
+ }
+
+ private void assertInterruptedUpload(Endpoint endpoint) {
+ var exception = assertThrows(Exception.class, () -> upload(endpoint, interruptedInput()));
+ var cause = ExceptionUtils.find(exception, IOException.class);
+ assertNotNull(cause);
+ assertEquals("Upload interrupted", cause.getMessage());
+ }
+
+ private InputStream interruptedInput() {
+ return new FilterInputStream(new ByteArrayInputStream(content)) {
+ private boolean started;
+
+ @Override
+ public int read(byte[] bytes, int offset, int length) throws IOException {
+ if (started)
+ throw new IOException("Upload interrupted");
+ started = true;
+ return super.read(bytes, offset, Math.min(length, 4));
+ }
+ };
+ }
+
+ private void assertStoredContent() throws IOException {
+ assertArrayEquals(content, Files.readAllBytes(objectFile));
+ assertFiles(List.of(objectFile));
+ }
+
+ private void assertFiles(List<Path> expected) throws IOException {
+ try (var files = Files.walk(storage)) {
+ assertEquals(expected, files.filter(Files::isRegularFile).toList());
+ }
+ }
+
+ private void upload(Endpoint endpoint, InputStream input) throws Exception {
+ upload(endpoint, objectId, input);
+ }
+
+ private Path objectFile(String id) {
+ return storage.resolve(id.substring(0, 2)).resolve(id.substring(2, 4)).resolve(id);
+ }
+
+ private void upload(Endpoint endpoint, String id, InputStream input) throws Exception {
+ security.when(SecurityUtils::isSystem).thenReturn(endpoint == Endpoint.CLUSTER);
+ if (endpoint == Endpoint.CLUSTER) {
+ try (var response = new ClusterResource().uploadLfs(input, 1L, id)) {
+ assertEquals(200, response.getStatus());
+ }
+ } else if (endpoint == Endpoint.FORWARDED) {
+ when(projects.getActiveServer(1L, true)).thenReturn("remote");
+ var client = mock(Client.class);
+ var target = mock(WebTarget.class, RETURNS_SELF);
+ var builder = mock(Invocation.Builder.class, RETURNS_SELF);
+ when(client.target(anyString())).thenReturn(target);
+ when(target.request()).thenReturn(builder);
+ when(builder.post(any(Entity.class))).thenAnswer(it -> {
+ if (forwardedResponse != null)
+ return forwardedResponse;
+ var output = new ByteArrayOutputStream();
+ var entity = it.getArgument(0, Entity.class);
+ try {
+ ((StreamingOutput) entity.getEntity()).write(output);
+ } catch (IOException | RuntimeException e) {
+ throw new ProcessingException(e);
+ }
+ security.when(SecurityUtils::isSystem).thenReturn(true);
+ try {
+ return new ClusterResource().uploadLfs(new ByteArrayInputStream(output.toByteArray()), 1L, id);
+ } finally {
+ security.when(SecurityUtils::isSystem).thenReturn(false);
+ }
+ });
+ try (var clients = mockStatic(ClientBuilder.class)) {
+ clients.when(ClientBuilder::newClient).thenReturn(client);
+ upload(Endpoint.DIRECT, id, input);
+ } finally {
+ verify(client).close();
+ }
+ } else {
+ var request = mock(HttpServletRequest.class);
+ when(request.getRequestURI()).thenReturn("/test.git/lfs/objects/" + id);
+ when(request.getContextPath()).thenReturn("");
+ when(request.getParameter("lfs-objects")).thenReturn("true");
+ when(request.getMethod()).thenReturn("PUT");
+ when(request.getContentLengthLong()).thenReturn(-1L);
+ when(request.getInputStream()).thenReturn(new ServletInputStream() {
+ @Override
+ public int read() throws IOException {
+ return input.read();
+ }
+
+ @Override
+ public int read(byte[] bytes, int offset, int length) throws IOException {
+ return input.read(bytes, offset, length);
+ }
+
+ @Override
+ public void close() throws IOException {
+ input.close();
+ }
+
+ @Override
+ public boolean isFinished() {
+ return false;
+ }
+
+ @Override
+ public boolean isReady() {
+ return true;
+ }
+
+ @Override
+ public void setReadListener(ReadListener listener) {
+ throw new UnsupportedOperationException();
+ }
+ });
+ filter.doFilter(request, mock(HttpServletResponse.class), mock(FilterChain.class));
+ }
+ }
+}