building a peer file sharing multi client app: java nginx docker aws....

25 Jun, 2025

🔗 PeerLink: A Peer-to-Peer File Sharing App in Java and Next.js

PeerLink is a lightweight, full-stack peer-to-peer (P2P) file sharing application that allows users to upload and share files directly between two machines using an invite code mechanism. Built with Java on the backend and Next.js on the frontend, this project dives deep into systems-level programming topics like Java Streams, multi-threading, socket communication, and HTTP protocol parsing.

🚀 GitHub repo: [https://github.com/singhdevhub-lovepreet/PeerLink]

🧠 Motivation Behind PeerLink

As a backend and systems enthusiast, I wanted a project that would allow me to explore three things in depth:

1. Java Streams

Building a file transfer mechanism gave me the perfect opportunity to use:

• Input/Output streams (InputStream, OutputStream)
• Buffered streams for large file support
• Byte stream manipulation

2. Java Threading + Socket Server

Peer-to-peer means real-time parallel interactions. This required:

• Spawning new threads per download session
• Concurrent socket listening/serving
• Thread-safe data handling for file sharing

3. HTTP Protocol Parsing (Minimalist HTTP Server)

Instead of relying on full-fledged frameworks, I implemented:

• Barebones HTTP header parsing from socket input
• Manually serving HTTP responses with correct headers
• Handling multipart uploads/downloads via raw Java streams

PeerLink emerged as a side project turned educational sandbox for these ideas.

🧱 Project Architecture

Tech Stack

Project Structure

PeerLink/
├── src/main/java/p2p
│   ├── App.java                # Main server entry
│   ├── controller/             # REST endpoints
│   ├── service/                # File serving logic
│   └── utils/                  # Helper classes (ports, streams)
├── ui/                         # Next.js frontend
│   └── src/app, components/    # UI pages and components
├── start.sh / start.bat        # Quickstart scripts
└── README.md

🛠️ How It Works

File Upload

• The user drags and drops a file in the UI.
• The file is POSTed to the backend.
• The backend stores it and spawns a dedicated file server on a random port.
• This port acts as the "invite code".

File Sharing (Invite Code)

• The user shares the invite code (port number) with their peer.
• No complex tokens or auth — simple and fast.

File Download

• The peer enters the invite code.
• The frontend initiates a fetch request to that port.
• The backend file server serves the file over HTTP directly.

🧵 Concurrency with Threaded File Servers

Each file transfer happens in its own thread:

new Thread(() -> {
    try (ServerSocket serverSocket = new ServerSocket(port)) {
        Socket client = serverSocket.accept();
        // Serve the file via OutputStream
    } catch (IOException e) {
        // handle errors
    }
}).start();

This allows:

• Multiple simultaneous transfers
• No main-thread blocking
• Independent file servers per port

Thread Safety

• The file server uses synchronized blocks and error handling
• No shared mutable state across transfers

Architecture

🌐 Minimal HTTP Server (Custom Parser)

Instead of using Spring or Jetty, I manually parsed HTTP headers:

BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
String line;
while (!(line = reader.readLine()).isEmpty()) {
    // Parse headers manually
}

This low-level approach gave me:

• Full control over the HTTP response
• Better understanding of how clients and servers communicate
• Ability to optimize for a single use case (file download)

Example response:

HTTP/1.1 200 OK
Content-Type: application/octet-stream
Content-Disposition: attachment; filename="myfile.txt"
Content-Length: 12345

Then the raw file bytes are streamed via OutputStream.

🖥️ Frontend: Next.js UI

The frontend is built using Next.js App Router with two core components:

• FileUploader: drag-and-drop zone, previews, upload button
• FileDownloader: input field for invite code, progress bar

It uses fetch() to communicate with the backend and supports file preview + download with progress.

🔐 Security Notes

• ⚠️ This is a demo/prototype.
• No encryption or authentication is implemented.
• It runs only on local/private networks (recommended).
• Before production:
  • Add HTTPS and TLS
  • Authenticate invite codes
  • Set rate-limits and connection limits

📦 Deployment

You can run PeerLink in several ways:

• Localhost:

  ./start.sh
  

• Docker:

  docker-compose up
  

• VPS or Cloud (e.g., Railway, Heroku):

  • Expose backend ports via secure tunnel (e.g., ngrok)
  • Frontend can be deployed to Vercel/Netlify

🧪 Future Improvements

• ✅ Add authentication per invite code
• ✅ Serve files via HTTPS using embedded TLS server
• ✅ Peer discovery and NAT traversal
• ✅ Use WebRTC for direct file transfer
• ✅ Replace invite code with QR code scanner

🏁 Final Thoughts

PeerLink taught me how to:

• Use Java Streams to efficiently handle large files
• Run concurrent socket servers using threading
• Build a mini HTTP server and understand protocol internals
• Integrate backend logic with a modern frontend (Next.js)

If you're a backend developer wanting to learn systems-level Java — this project is a perfect playground. Peer-to-peer doesn't have to be complex. Sometimes, all you need is a good port and a clean stream.

🔗 Try It Out

1. Clone the repo
2. Run ./start.sh
3. Drop a file ➡ Share the code ➡ Receive the file

Let the peer-to-peer fun begin 🚀