6.5 KiB
title, publishDate, authors
| title | publishDate | authors | |
|---|---|---|---|
| Peernet: An easy way to extend p2p capabilities to your go program | 2022-12-11 |
|
Today we are going to explore Peernet a p2p protocol designed for file sharing. But the main objective being simple to use and powerful at the same time. Out of my personal experience extending regular application with p2p capabilities,this has always been a nightmare. The standard problems would be how do I talk to nodes behind NAT, how do I discover nodes in a p2p network etc... If you ask the current community of go developers, IPFS would be considered as the standard solution. When building my initial project p2prc, I did consider trying to extend it with IPFS. The end result was that it was easier writing your own p2p network than extending IPFS with Libp2p (This was a huge nightmare in my case). Encountering Peernet did checkmark most of the reasons for a good protocol to extend go applications with p2p capabilities. Peernet is an amazing well abstracted p2p network which utilizes UDT to transfer files with the support of UPNP and UDP hole punching to support talking to nodes behind NAT. There are even more nice features such as a clean decentralized search etc...
Steps to get stated
The aim of todays blog post would be to build a sample p2p application using the Peernet Abstraction library. The Peernet abstraction library helps extend a go program with p2p capabilities (i.e simple set of function calls.)
Write a the boiler plate code
This is the go main function with the Peernet boiler plate code needed to get
started:
package main
import (
"encoding/json"
"fmt"
Abstrations "github.com/PeernetOfficial/Abstraction"
"github.com/PeernetOfficial/Abstraction/webapi"
"github.com/PeernetOfficial/core"
"github.com/google/uuid"
"os"
"runtime"
"time"
)
// go main function
func main() {
backend, status, err := core.Init("<application name>/<version no>", "Config.yaml", nil, nil)
if status != core.ExitSuccess {
fmt.Printf("Error %d initializing backend: %s\n", status, err.Error())
}
backend.Connect()
api := webapi.Start(backend, []string{"<ip address>:<port no>"}, false, "", "", 0, 0, uuid.New())
// The abstracted funcitons will be called below here
}
Set a warm up time
Before calling the abstracted functions to provide a delay
so that the go routines in the connect function can learning about
nodes in the network. For example below we gave a 6 second
delay before executing the next function.
// 6 seconds
time.Sleep(time.Millisecond * 6000)
Searching the p2p network
It's as simple as calling a function called Abstrations.Search(&<web api object>, "<term>")
to search about files metadata in the p2p network. This function
returns an search result object.
search, err := Abstrations.Search(api, "space")
if err != nil {
// handle error
}
Downloading a file from the p2p network
To download a file it is a simple function call
called Abstrations.Download(&<web api object>,<file hash>,<node id>,<download path>). This will ensure the user can download a file from the p2p network based on a hash and node id which is derived from the meta
data of a file. This meta data can be derived from the search results object as an example.
// Get download dir of the following machine
homeDir, _ := os.UserHomeDir()
var downloadDir string
if runtime.GOOS == "darwin" {
downloadDir = homeDir + "/Downloads/"
} else {
downloadDir = homeDir + "\\Downloads\\"
}
downloadID, err := Abstrations.Download(api, search.Files[0].Hash, search.Files[0].NodeID, downloadDir+search.Files[0].Name)
if err != nil {
fmt.Println(err)
return
}
In the code snippet above the hash and node id is derived from the first object of the search result array for the search term "space".
Calling the download function will return a download id, using this ID it's possible to track the status of
the download. The DownloadStatus function gets the current status of the current download.
downloadStatus, err := Abstrations.DownloadStatus(api, downloadID)
if err != nil {
fmt.Println(err)
}
fmt.Println("========= Downloading file " + downloadStatus.File.Name + " ==============")
// The status 5 means that the file has completed downloading
for downloadStatus.DownloadStatus != 5 {
downloadStatus, err = Abstrations.DownloadStatus(api, downloadID)
if err != nil {
fmt.Println(err)
}
}
The code snippet above implements checks if the download is complete and then terminates the loop.
Sharing a file from Peernet
Sharing a file is as simple as calling the function touch. The following function has the
shape of Abstrations.Touch(&<web api object>,<file path>). Calling this function will allow
a user all their file to the Peernet Warehouse
and Peernet blockchain.
touch, file, err := Abstrations.Touch(api, "example.go")
if err != nil {
// handle error
}
// Printing about information about the file added
fmt.Printf("blockchain verison: %v, blockchain height: %v, file hash: %v \n", touch.BlockchainVersion, touch.BlockchainHeight, file.Hash)
Removing a file from peernet
If a file wants to be removed from the Peernet Warehouse and Peernet blockchain it can be easily
removed with a single function call. This function consists of the shape Abstrations.Rm(&<web api object>,<file id>).
err = Abstrations.Rm(api, file.ID)
if err != nil {
// handle error
}
More information
The full source code to abstractions repo can found here
NOTE: This repo was created particularly for the following blog post. This repo will get deprecated once these functions are officially supported in the peernet core repo.
The example of the following flow:
The Peernet protocol source code:
Official Cmd repo:
White paper: