main.go

package main

import (
	"bytes"
	"fmt"
	"io"
	"log"
	"time"

	"github.com/ArditZubaku/distributed-file-storage/crypto"
	"github.com/ArditZubaku/distributed-file-storage/p2p"
	"github.com/ArditZubaku/distributed-file-storage/server"
	"github.com/ArditZubaku/distributed-file-storage/store"
)

func makeServer(listenAddr string, nodes ...string) *server.FileServer {
	tcpTransportOpts := p2p.TCPTransportOpts{
		ListenAddr:    ":" + listenAddr,
		HandShakeFunc: p2p.NOPHandShakeFunc,
		Decoder:       p2p.DefaultDecoder{},
	}

	tcpTransport := p2p.NewTCPTransport(tcpTransportOpts)

	fileServerOpts := server.FileServerOpts{
		EncKey:            crypto.NewEncryptionKey(),
		StorageRoot:       listenAddr + "_network",
		PathTransformFunc: store.CASPathTransformFunc,
		Transport:         tcpTransport,
		BootstrapNodes:    nodes,
	}

	s := server.NewFileServer(fileServerOpts)
	tcpTransport.OnPeer = s.OnPeer

	return s
}

func main() {
	s1 := makeServer("3000", "")
	s2 := makeServer("4000", ":3000")
	s3 := makeServer("5000", ":3000", ":4000")

	go func() {
		log.Fatal(s1.Start())
	}()

	go func() {
		log.Fatal(s2.Start())
	}()

	time.Sleep(2 * time.Second)

	go s3.Start()
	time.Sleep(2 * time.Second)

	for i := range 20 {
		key := fmt.Sprintf("picture_%d.png", i)

		data := bytes.NewReader([]byte("my big data file"))
		if err := s3.StoreFile(key, data); err != nil {
			log.Fatal(err)
		}

		if err := s3.Store.Delete(s3.ID, key); err != nil {
			log.Fatal(err)
		}

		r, err := s3.Get(key)
		if err != nil {
			log.Fatal(err)
		}

		b, err := io.ReadAll(r)
		if err != nil {
			log.Fatal(err)
		}

		fmt.Println(string(b))

		// Delete from all servers
		if err := s3.DeleteFile(key); err != nil {
			log.Fatal(err)
		}
	}

}