2.2.1. Install Go lang

2.2.2. Install Docker

// Do ensure that the docker command does not need sudo to run
sudo chmod 666 /var/run/docker.sock

2.2.3. Build Project and install project

make

1. For Windows
   

   To set up P2PRC on Windows, simply run this batch file. Make sure you are not in admin mode when running this.

   .\install.bat
   

2.2.4. Add appropriate paths to .bashrc

export P2PRC=/<PATH>/p2p-rendering-computation
export PATH=/<PATH>/p2p-rendering-computation:${PATH}

2.2.5. Test if binary works

p2prc --help

1. Output:
   

   NAME:
      p2p-rendering-computation - p2p cli application to create and access VMs in other servers
   
   USAGE:
      p2prc [global options] command [command options] [arguments...]
   
   VERSION:
      2.0.0
   
   COMMANDS:
      help, h  Shows a list of commands or help for one command
   
   GLOBAL OPTIONS:
      --Server, -s                           Starts server (default: false) [$SERVER]
      --UpdateServerList, --us               Update List of Server available based on servers iptables (default: false) [$UPDATE_SERVER_LIST]
      --ListServers, --ls                    List servers which can render tasks (default: false) [$LIST_SERVERS]
      --AddServer value, --as value          Adds server IP address to iptables [$ADD_SERVER]
      --ViewImages value, --vi value         View images available on the server IP address [$VIEW_IMAGES]
      --CreateVM value, --touch value        Creates Docker container on the selected server [$CREATE_VM]
      --ContainerName value, --cn value      Specifying the container run on the server side [$CONTAINER_NAME]
      --BaseImage value, --bi value          Specifying the docker base image to template the dockerfile [$CONTAINER_NAME]
      --RemoveVM value, --rm value           Stop and Remove Docker container (IP:port) accompanied by container ID via --ID or --id [$REMOVE_VM]
      --ID value, --id value                 Docker Container ID [$ID]
      --Ports value, -p value                Number of ports to open for the Docker Container [$NUM_PORTS]
      --GPU, --gpu                           Create Docker Containers to access GPU (default: false) [$USE_GPU]
      --Specification value, --specs value   Specs of the server node [$SPECS]
      --SetDefaultConfig, --dc               Sets a default configuration file (default: false) [$SET_DEFAULT_CONFIG]
      --NetworkInterfaces, --ni              Shows the network interface in your computer (default: false) [$NETWORK_INTERFACE]
      --ViewPlugins, --vp                    Shows plugins available to be executed (default: false) [$VIEW_PLUGIN]
      --TrackedContainers, --tc              View (currently running) containers which have been created from the client side  (default: false) [$TRACKED_CONTAINERS]
      --ExecutePlugin value, --plugin value  Plugin which needs to be executed [$EXECUTE_PLUGIN]
      --CreateGroup, --cgroup                Creates a new group (default: false) [$CREATE_GROUP]
      --Group value, --group value           group flag with argument group ID [$GROUP]
      --Groups, --groups                     View all groups (default: false) [$GROUPS]
      --RemoveContainerGroup, --rmcgroup     Remove specific container in the group (default: false) [$REMOVE_CONTAINER_GROUP]
      --RemoveGroup value, --rmgroup value   Removes the entire group [$REMOVE_GROUP]
      --MAPPort value, --mp value            Maps port for a specific port provided as the parameter [$MAPPORT]
      --DomainName value, --dn value         While mapping ports allows to set a domain name to create a mapping in the proxy server [$DOMAINNAME]
      --Generate value, --gen value          Generates a new copy of P2PRC which can be modified based on your needs [$GENERATE]
      --ModuleName value, --mod value        New go project module name [$MODULENAME]
      --PullPlugin value, --pp value         Pulls plugin from git repos [$PULLPLUGIN]
      --RemovePlugin value, --rp value       Removes plugin [$REMOVEPLUGIN]
      --AddMetaData value, --amd value       Adds metadata about the current node in the p2p network which is then propagated through the network [$ADDMETADATA]
      --help, -h                             show help (default: false)
      --version, -v                          print the version (default: false)
   

   ---

4.1.1. Latency

4.3.1. Client mode

http://<turn server ip>:<server port no>/FRPport

import (
    "github.com/Akilan1999/p2p-rendering-computation/p2p/frp"
)

func main() {
  serverPort, err := frp.GetFRPServerPort("http://" + <lowestLatencyIpAddress.Ipv4> + ":" + lowestLatencyIpAddress.ServerPort)
   if err != nil {
    return nil, err
   }
   // Create 1 second delay to allow FRP server to start
   time.Sleep(1 * time.Second)
   // Starts FRP as a client with
   proxyPort, err := frp.StartFRPClientForServer(<lowestLatencyIpAddress.Ipv4>, serverPort, <the port you want to expose externally>)
   if err != nil {
     return nil, err
   }
}

5.2.1. In Client go

1. 1. We import "C" which means Cgo is required.
   

   import "C"
   

2. 2. All functions which are required to be called from other programming languages have comment such as.
   

   //export <function name>
   
   // ------------ Example ----------------
   // The function below allows to externally
   // to call the P2PRC function to start containers
   // in a specific node in the know list of nodes
   // in the p2p network.
   // Note: the comment "//export StartContainer".
   
   //export StartContainer
   func StartContainer(IP string) (output *C.char) {
        container, err := client.StartContainer(IP, 0, false, "", "")
        if err != nil {
            return C.CString(err.Error())
        }
        return ConvertStructToJSONString(container)
    }
   

3. 3. While looking through the file (If 2 files are compared it is pretty trivial to notice a common structure).
   

   // --------- Example ------------
   
   //export StartContainer
   func StartContainer(IP string) (output *C.char) {
        container, err := client.StartContainer(IP, 0, false, "", "")
        if err != nil {
            return C.CString(err.Error())
        }
        return ConvertStructToJSONString(container)
   }
   
   //export ViewPlugin
   func ViewPlugin() (output *C.char) {
       plugins, err := plugin.DetectPlugins()
       if err != nil {
           return C.CString(err.Error())
       }
       return ConvertStructToJSONString(plugins)
   }
   

4. It is easy to notice that:
   
   • ConvertStructToJSONString(<go object>): This is a helper function that convert a go object to JSON string initially and converts it to CString.
   • (output *C.char): This is the return type for most of the functions.
5. A Pseudo code to refer to the common function implementation shape could be represented as:
   

   func <Function name> (output *C.char) {
         <response>,<error> := <P2PRC function name>(<parameters if needed>)
         if <error> != nil {
             return C.CString(<error>.Error())
         }
         return ConvertStructToJSONString(<response>)
   }
   

5.3.1. Python

1. Build sample python program
   

   The easier way

   # Run
   make python
   # Expected ouput
   Output is in the Directory Bindings/python/export/
   # Run
   cd Bindings/python/export/
   # list files
   ls
   # Expected output
   SharedObjects/  p2prc.py
   

   Above shows a generated folder which consists of a folder called "SharedObjects/" which consists of p2prc.so and p2prc.h files. p2prc.py refers to a sample python script calling P2PRC go functions. To start an any project to extend P2PRC with python, This generated folder can copied and created as a new git repo for P2PRC extensions scripted or used a reference point as proof of concept that P2PRC can be called from other programming languages.

5.3.2. Haskell

10.1.1. 1. Find a program you want to run

1. Let's run Linkwarden using docker compose and P2PRC
   

   Installation instructions:

   mkdir linkwarden && cd linkwarden
   curl -O https://raw.githubusercontent.com/linkwarden/linkwarden/refs/heads/main/docker-compose.yml
   curl -L https://raw.githubusercontent.com/linkwarden/linkwarden/refs/heads/main/.env.sample -o ".env"
   

   Environment configuration

   vim .env
   
   # Change values
   NEXTAUTH_URL=https://<DOMAIN NAME>/api/v1/auth
   NEXTAUTH_SECRET=VERY_SENSITIVE_SECRET
   POSTGRES_PASSWORD=CUSTOM_POSTGRES_PASSWORD
   

   Run linkwarden!

   docker compose up
   

   If setup correctly linkwarden should be running. Local link: http://localhost:3000

   Time to setup P2PRC Installation Instructions

   Run p2prc as a background

   p2prc -s &
   

   Run map port and domain mapping

   p2prc --mp 3000 --dn <DOMAIN NAME>
   

   Sample response

    {
           "IPAddress": "217.76.63.222",
           "PortNo": "61582",
           "EntireAddress": "217.76.63.222:61582"
   }
   

   Add DNS entry

   A entry 217.76.63.222
   

   Your done now just head to the DOMAIN NAME you added. ex: https://linkwarden.akilan.io

11.1.1. Assumptions:

11.1.2. Set of interesting possible:

11.1.3. Implementation