diff --git a/Docs/Bindings.md b/Docs/Bindings.md index 5d6cbf0..7d12d5a 100644 --- a/Docs/Bindings.md +++ b/Docs/Bindings.md @@ -1,7 +1,139 @@ # Language Bindings [Language bindings](https://en.wikipedia.org/wiki/Language_binding) refers to wrappers to bridge 2 programming languages. This is used in P2PRC to extend calling P2PRC functions in other programming languages. Currently this is done by generating ```.so``` and ```.h``` from the Go compiler. +
+ +## How to build shared object files +#### The easier way +```bash +# Run +make sharedObjects +``` +#### Or the direct way +```bash +# Run +cd Bindings && go build -buildmode=c-shared -o p2prc.so +``` +#### If successfully built: +```bash +# Enter into the Bindings directory +cd Bindings +# List files +ls +# Find files +p2prc.h p2prc.so +``` +
+ +## Workings under the hood +Below are a sample set of commands to +open the bindings implementation. +``` +# run +cd Bindings/ +# list files +ls +# search for file +Client.go +``` +### In Client go +There a few things to notice which are different from +your standard Go programs: + +#### 1. We import "C" which means [Cgo](https://pkg.go.dev/cmd/cgo) is required. +```go +import "C" +``` +#### 2. All functions which are required to be called from other programming languages have comment such as. +```go +//export + +// ------------ 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. While looking through the file (If 2 files are compared it is pretty trivial to notice a common structure). +```go +// --------- 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) +} + +``` +#### It is easy to notice that: +- ```ConvertStructToJSONString()```: 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. + +#### A Pseudo code to refer to the common function implementation shape could be represented as: +``` +func (output *C.char) { + , := () + if != nil { + return C.CString(.Error()) + } + return ConvertStructToJSONString() +} +``` + + +
+ + ## Current languages supported - Python -## Linking process +### Build sample python program +The easier way +```bash +# 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. + + + + diff --git a/Docs/README.md b/Docs/README.md index 0b98b5d..6b103c7 100644 --- a/Docs/README.md +++ b/Docs/README.md @@ -14,5 +14,6 @@ 4. [Config Module](ConfigImplementation.md) 5. [Cli Module](CliImplementation.md) 6. [Plugin Module](PluginImplementation.md) + 7. [Language bindings](Bindings.md) diff --git a/README.md b/README.md index c1d31f7..567b3f3 100644 --- a/README.md +++ b/README.md @@ -1,4 +1,5 @@ -> **_NOTE:_** Fixing documentation to lastest changes ,If you have any questions setting up P2PRC either create an issue or send me an email (me AT akilan dot io) +> **_NOTE:_** Fixing documentation to lastest changes ,If you have any questions setting up P2PRC either create an issue or send me an email (me AT akilan dot io). +> Currently HEAD is always intended to stay on a working state. It is recommended to always use HEAD in your go.mod file.


p2prc @@ -18,20 +19,40 @@ The main aim of this project was to create a custom peer to peer network. The us client has total flexibility on how to batch the tasks and the user acting as the server has complete flexibility on tracking the container's usages and killing the containers at any point of time. -## Gophers talk -[![IMAGE ALT TEXT](https://i.ytimg.com/vi/ovcZLEhQxWk/hqdefault.jpg)](https://www.youtube.com/watch?v=ovcZLEhQxWk "P2PRC - Gophers monthly talk") +## Latest tutorial +[![IMAGE ALT TEXT](https://i.ytimg.com/vi/OMwCpedu5cs/hqdefault.jpg)](https://www.youtube.com/watch?v=OMwCpedu5cs")
-## Table of contents +## Table of contents in the current README 1. [Introduction](#Introduction) -2. [Installation](#Installation.md) +2. [Installation](#extend-your-application-with-p2prc) 3. [Design Architecture](#Design-Architecture) 4. [Implementation](#Implementation) 5. [Find out more](#Find-out-more)
+# Table of contents in the Docs folder +1. [Introduction](Docs/Introduction.md) +2. [Installation](Docs/Installation.md) +3. [Abstractions](Docs/Abstractions.md) + +4. [Implementation](Docs/Implementation.md) + 1. [Client Module](Docs/ClientImplementation.md) + 2. [P2P Module](Docs/P2PImplementation.md) + 3. [Server Module](Docs/ServerImplementation.md) + 4. [Config Module](Docs/ConfigImplementation.md) + 5. [Cli Module](Docs/CliImplementation.md) + 6. [Plugin Module](Docs/PluginImplementation.md) + 7. [Language Bindings](Docs/Bindings.md) + + +
+ ## Introduction This project aims to create a peer to peer (p2p) network, where a user can use the p2p network to act as a client (i.e sending tasks) or the server (i.e executing the tasks). A prototype application will be developed, which comes bundled with a p2p module and possible to execute docker containers or virtual environments across selected nodes.