177 lines
7.0 KiB
TeX
177 lines
7.0 KiB
TeX
% Created 2024-12-10 Tue 23:38
|
|
% Intended LaTeX compiler: pdflatex
|
|
\documentclass[11pt]{article}
|
|
\usepackage[utf8]{inputenc}
|
|
\usepackage[T1]{fontenc}
|
|
\usepackage{graphicx}
|
|
\usepackage{longtable}
|
|
\usepackage{wrapfig}
|
|
\usepackage{rotating}
|
|
\usepackage[normalem]{ulem}
|
|
\usepackage{amsmath}
|
|
\usepackage{amssymb}
|
|
\usepackage{capt-of}
|
|
\usepackage{hyperref}
|
|
\author{Akilan}
|
|
\date{\today}
|
|
\title{}
|
|
\hypersetup{
|
|
pdfauthor={Akilan},
|
|
pdftitle={},
|
|
pdfkeywords={},
|
|
pdfsubject={},
|
|
pdfcreator={Emacs 29.1 (Org mode 9.6.6)},
|
|
pdflang={English}}
|
|
\begin{document}
|
|
|
|
\tableofcontents
|
|
|
|
\section{P2PRC tracking home server}
|
|
\label{sec:org64aa45e}
|
|
\subsection{Abstract}
|
|
\label{sec:org3d87056}
|
|
This is a libary on top of P2PRC to create easier abstractions
|
|
to setup servers on spare laptops at home and run applications
|
|
which can exibit a monolithic behavoir (Ex: Self hosted
|
|
jitsi, Indvidious). The motivation is to ensure users can
|
|
share self hosted infrastructure with friends and can design
|
|
a really simple replicatable instances of servers.
|
|
|
|
\subsection{Problems being addressed}
|
|
\label{sec:org553bb54}
|
|
\begin{enumerate}
|
|
\item Remembering ports mapped and stateful restart. Rather than the OS remember
|
|
information of the processes. The P2P network should also track it and
|
|
propogate it to other nodes in the network. This is to ensure when a process
|
|
fails there is a formally representable reason which can appropirate corrective
|
|
actions.
|
|
\item Arbitary instructions used to start a process and should be remembered to reproduce a
|
|
process if a node is down.
|
|
\end{enumerate}
|
|
|
|
|
|
\subsection{What are attempting to do}
|
|
\label{sec:org7867a81}
|
|
The section below describes in detail the ideal startegy of addressing the problems stated
|
|
above.
|
|
|
|
\subsubsection{Building Abstraction}
|
|
\label{sec:org4988e19}
|
|
We are proposting to build a library of the Haskell bindings which do the following:
|
|
\begin{itemize}
|
|
\item Creating a P2PRC process and allowing users to modify it's behavoir in functional manner with for instance
|
|
immutable datatypes.
|
|
\item Allowing users to run this abstraction in a reproducable manner or constrainting it to run on precise
|
|
sets of machines.
|
|
\item Should be able to represent the deployment strategy used (ex: Nix, Ansible etc\ldots{}). This keeps the
|
|
deployment agnostic and not vendor specific.
|
|
\item The intended idea of this is to only work with monolithic applications.
|
|
\end{itemize}
|
|
|
|
\subsubsection{Building it for only home server users}
|
|
\label{sec:orge2d540d}
|
|
\begin{itemize}
|
|
\item The use case is to ensure it's easier to setup a set of servers and shuffle P2PRC processes around
|
|
when needed. We intend to do this by ensuring a process is represented as type.
|
|
\item Targets initially with the assumption that there is only 1 reliable root node to relay traffic to the make the setup
|
|
easier. Future plans will create a DNS layer which can make root nodes and P2PRC processes reproducable.
|
|
\end{itemize}
|
|
|
|
\subsubsection{Linient rules}
|
|
\label{sec:orge1dc5da}
|
|
\begin{itemize}
|
|
\item This library is built for home users, therefore the library will be setup for P2PRC using the \href{https://github.com/Akilan1999/p2p-rendering-computation/pull/115}{unsafe mode} which will ensure that all public
|
|
keys will be added to the \href{https://www.ssh.com/academy/ssh/authorized-keys-file\#:\~:text=The\%20authorized\_keys\%20file\%20in\%20SSH,keys\%20and\%20needs\%20proper\%20management}{SSH auth list} of all nodes avaliable in the network. While this is not secure it
|
|
comes with pre-assumption that all nodes joining the network are home servers and are needed to access each other
|
|
with limited rules (set by user permission from the OS side).
|
|
\item We assume that all P2PRC processes run on a bare-metal machine without any virtualisation.
|
|
This is because most users run on machines which they own and we offload to the users
|
|
reponsibility to choose a tool that can support reproducable builds like \href{https://nixos.org/}{Nix}.
|
|
\end{itemize}
|
|
|
|
\begin{center}
|
|
\includegraphics[width=.9\linewidth]{./P2PRC-Tracking-home-server.png}
|
|
\end{center}
|
|
|
|
\subsection{Plan}
|
|
\label{sec:org7e9ebcb}
|
|
Based on the \href{https://github.com/Akilan1999/p2p-rendering-computation/tree/master/haskell}{Haskell bindings} to build an extended library (There are still changes needed
|
|
in the Haskell bindings before the addon can be built).
|
|
|
|
\subsubsection{Handle more cases than machine name}
|
|
\label{sec:org0007684}
|
|
The current haskell library seems to only support 1 type Machine name which is parseable from
|
|
the config file. We would need to handle conditions such as handling types such as \href{https://github.com/Akilan1999/p2p-rendering-computation/blob/67165d4bf63d82794a1a264edf843295b727c226/config/config.go\#L39}{Baremetal} and \href{https://github.com/Akilan1999/p2p-rendering-computation/blob/67165d4bf63d82794a1a264edf843295b727c226/config/config.go\#L40}{UnsafeMode}.
|
|
On this proposed library they would both be set to true.
|
|
\begin{verbatim}
|
|
instance FromJSON P2prcConfig where
|
|
parseJSON (Object o) = do
|
|
|
|
machineName <- o .: "MachineName"
|
|
|
|
pure
|
|
$ MkP2prConfig
|
|
{ machineName=machineName
|
|
}
|
|
|
|
parseJSON _ = mzero
|
|
\end{verbatim}
|
|
|
|
\subsubsection{Representation of a process}
|
|
\label{sec:org07241c8}
|
|
To design a data structure that can represent current set of properties:
|
|
\begin{enumerate}
|
|
\item IP address (string)
|
|
\item Port no (int)
|
|
\item Task name (string)
|
|
\item Task id (int)
|
|
\item Encoded deployment script (multi-line string)
|
|
\item Command to run deployment script (multi line string)
|
|
\item Command to kill deployment script (multi line string)
|
|
\item Status (boolean)
|
|
\item Domain name (string)
|
|
\end{enumerate}
|
|
|
|
\subsubsection{Representation of a node:}
|
|
\label{sec:org7837ede}
|
|
Follows the implemented Haskell data structure from the bindings:
|
|
\begin{verbatim}
|
|
instance FromJSON ServerInfo where
|
|
parseJSON = withObject "ServerInfo" $
|
|
\ o -> do
|
|
|
|
name <- o .: "Name"
|
|
ip4str <- o .: "IPV4"
|
|
ip6str <- o .: "IPV6"
|
|
latency <- o .: "Latency"
|
|
download <- o .: "Download"
|
|
upload <- o .: "Upload"
|
|
serverPort <- o .: "ServerPort"
|
|
bmSshPort <- o .: "BareMetalSSHPort"
|
|
nat <- o .: "NAT"
|
|
mEscImpl <- o .: "EscapeImplementation"
|
|
custInfo <- o .: "CustomInformation"
|
|
\end{verbatim}
|
|
|
|
\subsubsection{Function expected to be built:}
|
|
\label{sec:org27760db}
|
|
The following refers to the functions we would be building for our abstraction:
|
|
\begin{enumerate}
|
|
\item SpinProcess(<P2PRC process type>,<Node Type>)
|
|
\item KillProcess(<P2PRC process type>)
|
|
\item ProcessInformation(<process id> or <domain name>) returns <P2PRC process type>
|
|
\item ListProcess() return <P2PRC process type>
|
|
\end{enumerate}
|
|
|
|
\subsection{Terms}
|
|
\label{sec:org2f4d383}
|
|
P2PRC process: A p2prc process refers to potencially an instance (i.e web-server or any task). This process
|
|
stores information such as:
|
|
\begin{itemize}
|
|
\item Memory usage.
|
|
\item Instructions to re-produce that task etc\ldots{}
|
|
\end{itemize}
|
|
|
|
Root node: Refers to a node running P2PRC with a public IPV4 address to relay traffic through for nodes
|
|
behind NAT and can potencially even act a proxy for nodes(Used for domain name mapping) in the P2P network.
|
|
\end{document} |