Datei-Uploads in Java mit tus-java-client fortsetzen

(
  mkdir java-tus-demo &&
  cd java-tus-demo &&
  mkdir -p src/main/java &&
  touch yarn.lock &&
  printf 'nodeLinker: node-modules\n' > .yarnrc.yml
)

<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>example</groupId>
  <artifactId>java-tus-demo</artifactId>
  <version>1.0.0</version>
  <properties>
    <maven.compiler.release>21</maven.compiler.release>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  </properties>
  <dependencies>
    <dependency>
      <groupId>io.tus.java.client</groupId>
      <artifactId>tus-java-client</artifactId>
      <version>0.5.1</version>
    </dependency>
  </dependencies>
  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.14.1</version>
      </plugin>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-dependency-plugin</artifactId>
        <version>3.9.0</version>
      </plugin>
    </plugins>
  </build>
</project>

{
  "name": "java-tus-demo",
  "private": true,
  "type": "module",
  "packageManager": "yarn@4.12.0",
  "dependencies": {
    "@tus/file-store": "2.1.1",
    "@tus/server": "2.4.5"
  }
}

import { createServer } from 'node:http'
import { FileStore } from '@tus/file-store'
import { Server } from '@tus/server'

const port = Number(process.argv[2] ?? '1080')
if (!Number.isInteger(port) || port < 0 || port > 65535) {
  throw new Error('Port must be an integer from 0 to 65535')
}

const tus = new Server({
  path: '/files',
  datastore: new FileStore({ directory: './uploads' }),
})
let failOnce = true

const http = createServer((request, response) => {
  // Java's HttpURLConnection uses this override when it cannot send PATCH.
  if (request.method === 'POST' && request.headers['x-http-method-override'] === 'PATCH') {
    request.method = 'PATCH'
  }
  response.on('finish', () => {
    console.log(`${request.method} ${request.url} -> ${response.statusCode}, request offset=${request.headers['upload-offset'] ?? '-'}`)
  })
  if (failOnce && request.method === 'PATCH' && Number(request.headers['upload-offset']) >= 1048576) {
    failOnce = false
    request.resume()
    response.writeHead(503, { 'Tus-Resumable': '1.0.0' })
    response.end('Deliberate interruption')
    return
  }
  void tus.handle(request, response).catch((error: unknown) => {
    console.error(error)
    response.destroy()
  })
})

http.on('error', (error) => {
  console.error(`Server failed: ${error.message}`)
  process.exitCode = 1
})
http.listen(port, '127.0.0.1', () => {
  const address = http.address()
  if (address && typeof address !== 'string') {
    console.log(`Listening at http://127.0.0.1:${address.port}/files`)
  }
})

corepack yarn install && corepack yarn node server.ts 1080

import io.tus.java.client.ProtocolException;
import io.tus.java.client.TusClient;
import io.tus.java.client.TusExecutor;
import io.tus.java.client.TusUpload;
import io.tus.java.client.TusUploader;
import io.tus.java.client.TusURLMemoryStore;

import java.io.File;
import java.io.IOException;
import java.net.HttpURLConnection;
import java.net.URI;
import java.net.URL;
import java.util.ArrayList;
import java.util.List;

public class TusUploaderExample {
    public static void main(String[] args) {
        try {
            run(args);
        } catch (Exception error) {
            System.err.println("Upload failed: " + error.getMessage());
            System.exit(1);
        }
    }

    private static void run(String[] args) throws Exception {
        if (args.length != 2) {
            throw new IllegalArgumentException("Usage: TusUploaderExample ENDPOINT FILE");
        }
        File file = new File(args[1]);
        if (!file.isFile() || !file.canRead()) {
            throw new IOException("Input must be a readable regular file: " + file);
        }
        List<HttpURLConnection> connections = new ArrayList<>();
        TusClient client = new TusClient() {
            @Override
            public void prepareConnection(HttpURLConnection connection) {
                super.prepareConnection(connection);
                connection.setReadTimeout(5000);
                connections.add(connection);
            }
        };
        client.setConnectTimeout(5000);
        client.setUploadCreationURL(URI.create(args[0]).toURL());
        client.enableResuming(new TusURLMemoryStore());

        TusExecutor executor = new TusExecutor() {
            private int attempt = 0;

            @Override
            protected void makeAttempt() throws IOException, ProtocolException {
                System.out.println("Attempt " + ++attempt);
                TusUpload upload = new TusUpload(file);
                URL completedUrl;
                // Close the file even if creation, resuming, or finish() fails.
                try (var input = upload.getInputStream()) {
                    TusUploader uploader = client.resumeOrCreateUpload(upload);
                    uploader.setChunkSize(64 * 1024);
                    uploader.setRequestPayloadSize(1024 * 1024);
                    System.out.println("Starting at byte " + uploader.getOffset());
                    try {
                        while (uploader.uploadChunk() != -1) {
                            // The server response is checked when the request finishes.
                        }
                    } finally {
                        uploader.finish();
                    }
                    completedUrl = uploader.getUploadURL();
                } finally {
                    for (HttpURLConnection connection : connections) {
                        connection.disconnect();
                    }
                    connections.clear();
                }
                System.out.println("Completed: " + completedUrl);
            }
        };
        executor.setDelays(new int[] {500, 1000});
        if (!executor.makeAttempts()) {
            throw new IOException("Upload interrupted while waiting to retry");
        }
    }
}

corepack yarn node -e "require('node:fs').writeFileSync('sample.bin', require('node:crypto').randomBytes(2 * 1024 * 1024 + 4099), {flag: 'wx'})"

mvn -q compile dependency:copy-dependencies &&
java -cp 'target/classes:target/dependency/*' TusUploaderExample http://127.0.0.1:1080/files sample.bin

Attempt 1
Starting at byte 0
Attempt 2
Starting at byte 1048576
Completed: http://127.0.0.1:1080/files/<upload-id>

cmp sample.bin uploads/UPLOAD_ID && printf 'Files match\n'