Skip to content
Snippets Groups Projects
Commit 6aaf8071 authored by capossele's avatar capossele
Browse files

Merge branch 'feat/client-lib' into feat/drng-ontology

parents 9d7a41b3 5292e069
No related branches found
No related tags found
No related merge requests found
Show whitespace changes
Inline Side-by-side
Showing
with 141 additions and 319 deletions
client/lib.go
+ 30
− 75
View file @ 6aaf8071
// Implements a very simple wrapper for GoShimmer's web API .
package goshimmer
package client
import (
"bytes"
......@@ -11,16 +11,10 @@ import (
"net/http"
webapi_broadcastData "github.com/iotaledger/goshimmer/plugins/webapi/broadcastData"
webapi_findTransactionHashes "github.com/iotaledger/goshimmer/plugins/webapi/findTransactionHashes"
webapi_findMessageById "github.com/iotaledger/goshimmer/plugins/webapi/findMessageById"
webapi_getNeighbors "github.com/iotaledger/goshimmer/plugins/webapi/getNeighbors"
webapi_getTransactionObjectsByHash "github.com/iotaledger/goshimmer/plugins/webapi/getTransactionObjectsByHash"
webapi_getTransactionTrytesByHash "github.com/iotaledger/goshimmer/plugins/webapi/getTransactionTrytesByHash"
webapi_gtta "github.com/iotaledger/goshimmer/plugins/webapi/gtta"
webapi_spammer "github.com/iotaledger/goshimmer/plugins/webapi/spammer"
webapi_auth "github.com/iotaledger/goshimmer/plugins/webauth"
"github.com/iotaledger/iota.go/consts"
"github.com/iotaledger/iota.go/guards"
"github.com/iotaledger/iota.go/trinary"
)
var (
......@@ -34,13 +28,11 @@ var (
const (
routeBroadcastData = "broadcastData"
routeGetTransactionTrytesByHash = "getTransactionTrytesByHash"
routeGetTransactionObjectsByHash = "getTransactionObjectsByHash"
routeFindTransactionsHashes = "findTransactionHashes"
routeGetMessageById = "getMessageById"
routeGetNeighbors = "getNeighbors"
routeGetTransactionsToApprove = "getTransactionsToApprove"
routeSpammer = "spammer"
routeLogin = "login"
//routeGetTransactionsToApprove = "getTransactionsToApprove"
contentTypeJSON = "application/json"
)
......@@ -155,69 +147,32 @@ func (api *GoShimmerAPI) Login(username string, password string) error {
return nil
}
// BroadcastData sends the given data by creating a zero value transaction in the backend targeting the given address.
func (api *GoShimmerAPI) BroadcastData(targetAddress trinary.Trytes, data string) (trinary.Hash, error) {
if !guards.IsHash(targetAddress) {
return "", fmt.Errorf("%w: invalid address: %s", consts.ErrInvalidHash, targetAddress)
}
// BroadcastData sends the given data (payload) by creating a message in the backend.
func (api *GoShimmerAPI) BroadcastData(data []byte) (string, error) {
res := &webapi_broadcastData.Response{}
if err := api.do(http.MethodPost, routeBroadcastData,
&webapi_broadcastData.Request{Address: targetAddress, Data: data}, res); err != nil {
&webapi_broadcastData.Request{Data: data}, res); err != nil {
return "", err
}
return res.Hash, nil
}
// GetTransactionTrytesByHash gets the corresponding transaction trytes given the transaction hashes.
func (api *GoShimmerAPI) GetTransactionTrytesByHash(txHashes trinary.Hashes) ([]trinary.Trytes, error) {
for _, hash := range txHashes {
if !guards.IsTrytes(hash) {
return nil, fmt.Errorf("%w: invalid hash: %s", consts.ErrInvalidHash, hash)
}
}
res := &webapi_getTransactionTrytesByHash.Response{}
if err := api.do(http.MethodPost, routeGetTransactionTrytesByHash,
&webapi_getTransactionTrytesByHash.Request{Hashes: txHashes}, res); err != nil {
return nil, err
}
return res.Trytes, nil
}
// GetTransactionObjectsByHash gets the transaction objects given the transaction hashes.
func (api *GoShimmerAPI) GetTransactionObjectsByHash(txHashes trinary.Hashes) ([]webapi_getTransactionObjectsByHash.Transaction, error) {
for _, hash := range txHashes {
if !guards.IsTrytes(hash) {
return nil, fmt.Errorf("%w: invalid hash: %s", consts.ErrInvalidHash, hash)
}
}
res := &webapi_getTransactionObjectsByHash.Response{}
if err := api.do(http.MethodPost, routeGetTransactionObjectsByHash,
&webapi_getTransactionObjectsByHash.Request{Hashes: txHashes}, res); err != nil {
return nil, err
return res.Id, nil
}
return res.Transactions, nil
}
func (api *GoShimmerAPI) FindMessageById(base58EncodedIds []string) (*webapi_findMessageById.Response, error) {
res := &webapi_findMessageById.Response{}
// FindTransactionHashes finds the given transaction hashes given the query.
func (api *GoShimmerAPI) FindTransactionHashes(query *webapi_findTransactionHashes.Request) ([]trinary.Hashes, error) {
for _, hash := range query.Addresses {
if !guards.IsTrytes(hash) {
return nil, fmt.Errorf("%w: invalid hash: %s", consts.ErrInvalidHash, hash)
}
}
res := &webapi_findTransactionHashes.Response{}
if err := api.do(http.MethodPost, routeFindTransactionsHashes, query, res); err != nil {
err := api.do(
http.MethodPost,
routeGetMessageById,
&webapi_findMessageById.Request{Ids: base58EncodedIds},
res,
)
if err != nil {
return nil, err
}
return res.Transactions, nil
return res, nil
}
// GetNeighbors gets the chosen/accepted neighbors.
......@@ -235,14 +190,14 @@ func (api *GoShimmerAPI) GetNeighbors(knownPeers bool) (*webapi_getNeighbors.Res
return res, nil
}
// GetTips executes the tip-selection on the node to retrieve tips to approve.
func (api *GoShimmerAPI) GetTransactionsToApprove() (*webapi_gtta.Response, error) {
res := &webapi_gtta.Response{}
if err := api.do(http.MethodGet, routeGetTransactionsToApprove, nil, res); err != nil {
return nil, err
}
return res, nil
}
// // GetTips executes the tip-selection on the node to retrieve tips to approve.
// func (api *GoShimmerAPI) GetTransactionsToApprove() (*webapi_gtta.Response, error) {
// res := &webapi_gtta.Response{}
// if err := api.do(http.MethodGet, routeGetTransactionsToApprove, nil, res); err != nil {
// return nil, err
// }
// return res, nil
// }
// ToggleSpammer toggles the node internal spammer.
func (api *GoShimmerAPI) ToggleSpammer(enable bool) (*webapi_spammer.Response, error) {
......
......
pluginmgr/webapi/plugins.go
+ 3
− 8
View file @ 6aaf8071
......@@ -3,11 +3,8 @@ package webapi
import (
"github.com/iotaledger/goshimmer/plugins/webapi"
"github.com/iotaledger/goshimmer/plugins/webapi/broadcastData"
"github.com/iotaledger/goshimmer/plugins/webapi/findTransactionHashes"
"github.com/iotaledger/goshimmer/plugins/webapi/findMessageById"
"github.com/iotaledger/goshimmer/plugins/webapi/getNeighbors"
"github.com/iotaledger/goshimmer/plugins/webapi/getTransactionObjectsByHash"
"github.com/iotaledger/goshimmer/plugins/webapi/getTransactionTrytesByHash"
"github.com/iotaledger/goshimmer/plugins/webapi/gtta"
"github.com/iotaledger/goshimmer/plugins/webapi/spammer"
"github.com/iotaledger/goshimmer/plugins/webauth"
"github.com/iotaledger/hive.go/node"
......@@ -16,11 +13,9 @@ import (
var PLUGINS = node.Plugins(
webapi.PLUGIN,
webauth.PLUGIN,
gtta.PLUGIN,
//gtta.PLUGIN,
spammer.PLUGIN,
broadcastData.PLUGIN,
getTransactionTrytesByHash.PLUGIN,
getTransactionObjectsByHash.PLUGIN,
findTransactionHashes.PLUGIN,
findMessageById.PLUGIN,
getNeighbors.PLUGIN,
)
plugins/webapi/broadcastData/plugin.go
+ 8
− 7
View file @ 6aaf8071
......@@ -19,8 +19,8 @@ func configure(plugin *node.Plugin) {
webapi.Server.POST("broadcastData", broadcastData)
}
// broadcastData creates a data (0-value) transaction given an input of bytes and
// broadcasts it to the node's neighbors. It returns the transaction hash if successful.
// broadcastData creates a message of the given payload and
// broadcasts it to the node's neighbors. It returns the message ID if successful.
func broadcastData(c echo.Context) error {
var request Request
if err := c.Bind(&request); err != nil {
......@@ -28,17 +28,18 @@ func broadcastData(c echo.Context) error {
return c.JSON(http.StatusBadRequest, Response{Error: err.Error()})
}
tx := messagelayer.MessageFactory.IssuePayload(payload.NewData([]byte(request.Data)))
//TODO: to check max payload size allowed, if exceeding return an error
return c.JSON(http.StatusOK, Response{Hash: tx.Id().String()})
tx := messagelayer.MessageFactory.IssuePayload(payload.NewData(request.Data))
return c.JSON(http.StatusOK, Response{Id: tx.Id().String()})
}
type Response struct {
Hash string `json:"hash,omitempty"`
Id string `json:"id,omitempty"`
Error string `json:"error,omitempty"`
}
type Request struct {
Address string `json:"address"`
Data string `json:"data"`
Data []byte `json:"data"`
}
plugins/webapi/findMessageById/plugin.go 0 → 100644
+ 85
− 0
View file @ 6aaf8071
package findMessageById
import (
"net/http"
"github.com/iotaledger/goshimmer/packages/binary/messagelayer/message"
"github.com/iotaledger/goshimmer/plugins/messagelayer"
"github.com/iotaledger/goshimmer/plugins/webapi"
"github.com/labstack/echo"
"github.com/iotaledger/hive.go/logger"
"github.com/iotaledger/hive.go/node"
)
var PLUGIN = node.NewPlugin("WebAPI findMessageById Endpoint", node.Enabled, configure)
var log *logger.Logger
func configure(plugin *node.Plugin) {
log = logger.NewLogger("API-findMessageById")
webapi.Server.POST("findMessageById", findMessageById)
}
// findMessageById returns the array of messages for the
// given message ids (MUST be encoded in base58), in the same order as the parameters.
// If a node doesn't have the message for a given ID in its ledger,
// the value at the index of that message ID is empty.
func findMessageById(c echo.Context) error {
var request Request
if err := c.Bind(&request); err != nil {
log.Info(err.Error())
return c.JSON(http.StatusBadRequest, Response{Error: err.Error()})
}
var result []Message
for _, id := range request.Ids {
log.Info("Received:", id)
msgId, err := message.NewId(id)
if err != nil {
log.Info(err)
continue
}
msgObject := messagelayer.Tangle.Message(msgId)
if !msgObject.Exists() {
continue
}
msg := msgObject.Unwrap()
msgResp := Message{
Id: msg.Id().String(),
TrunkId: msg.TrunkId().String(),
BranchId: msg.BranchId().String(),
IssuerPublicKey: msg.IssuerPublicKey().String(),
IssuingTime: msg.IssuingTime().String(),
SequenceNumber: msg.SequenceNumber(),
Payload: msg.Payload().Bytes(),
Signature: msg.Signature().String(),
}
result = append(result, msgResp)
msgObject.Release()
}
return c.JSON(http.StatusOK, Response{Messages: result})
}
type Response struct {
Messages []Message `json:"messages,omitempty"`
Error string `json:"error,omitempty"`
}
type Request struct {
Ids []string `json:"ids"`
}
type Message struct {
Id string `json:"Id,omitempty"`
TrunkId string `json:"trunkId,omitempty"`
BranchId string `json:"branchId,omitempty"`
IssuerPublicKey string `json:"issuerPublicKey,omitempty"`
IssuingTime string `json:"issuingTime,omitempty"`
SequenceNumber uint64 `json:"sequenceNumber,omitempty"`
Payload []byte `json:"payload,omitempty"`
Signature string `json:"signature,omitempty"`
}
plugins/webapi/findTransactionHashes/plugin.go deleted 100644 → 0
+ 0
− 58
View file @ 9d7a41b3
package findTransactionHashes
import (
"net/http"
"github.com/iotaledger/goshimmer/plugins/webapi"
"github.com/iotaledger/hive.go/logger"
"github.com/iotaledger/hive.go/node"
"github.com/iotaledger/iota.go/trinary"
"github.com/labstack/echo"
)
var PLUGIN = node.NewPlugin("WebAPI findTransactionHashes Endpoint", node.Enabled, configure)
var log *logger.Logger
func configure(plugin *node.Plugin) {
log = logger.NewLogger("API-findTransactionHashes")
webapi.Server.POST("findTransactionHashes", findTransactionHashes)
}
// findTransactionHashes returns the array of transaction hashes for the
// given addresses (in the same order as the parameters).
// If a node doesn't have any transaction hash for a given address in its ledger,
// the value at the index of that address is empty.
func findTransactionHashes(c echo.Context) error {
return c.JSON(http.StatusInternalServerError, Response{Error: "TODO: ADD LOGIC ACCORDING TO VALUE TANGLE"})
// TODO: ADD LOGIC ACCORDING TO VALUE TANGLE
/*
var request Request
if err := c.Bind(&request); err != nil {
log.Info(err.Error())
return c.JSON(http.StatusBadRequest, Response{Error: err.Error()})
}
log.Debug("Received:", request.Addresses)
result := make([][]trinary.Trytes, len(request.Addresses))
for i, address := range request.Addresses {
txs, err := tangle_old.ReadTransactionHashesForAddressFromDatabase(address)
if err != nil {
return c.JSON(http.StatusInternalServerError, Response{Error: err.Error()})
}
result[i] = append(result[i], txs...)
}
return c.JSON(http.StatusOK, Response{Transactions: result})
*/
}
type Response struct {
Transactions [][]trinary.Trytes `json:"transactions,omitempty"` //string
Error string `json:"error,omitempty"`
}
type Request struct {
Addresses []string `json:"addresses"`
}
plugins/webapi/getTransactionObjectsByHash/plugin.go deleted 100644 → 0
+ 0
− 87
View file @ 9d7a41b3
package getTransactionObjectsByHash
import (
"net/http"
"github.com/iotaledger/hive.go/logger"
"github.com/iotaledger/hive.go/node"
"github.com/iotaledger/iota.go/trinary"
"github.com/labstack/echo"
"github.com/iotaledger/goshimmer/plugins/webapi"
)
var PLUGIN = node.NewPlugin("WebAPI getTransactionObjectsByHash Endpoint", node.Enabled, configure)
var log *logger.Logger
func configure(plugin *node.Plugin) {
log = logger.NewLogger("API-getTransactionObjectsByHash")
webapi.Server.POST("getTransactionObjectsByHash", getTransactionObjectsByHash)
}
// getTransactionObjectsByHash returns the array of transactions for the
// given transaction hashes (in the same order as the parameters).
// If a node doesn't have the transaction for a given transaction hash in its ledger,
// the value at the index of that transaction hash is empty.
func getTransactionObjectsByHash(c echo.Context) error {
var request Request
result := []Transaction{}
if err := c.Bind(&request); err != nil {
log.Info(err.Error())
return c.JSON(http.StatusBadRequest, Response{Error: err.Error()})
}
log.Debug("Received:", request.Hashes)
/*
for _, hash := range request.Hashes {
tx, err := tangle_old.GetTransaction(hash)
if err != nil {
return c.JSON(http.StatusInternalServerError, Response{Error: err.Error()})
}
if tx == nil {
return c.JSON(http.StatusNotFound, Response{Error: fmt.Sprintf("transaction not found: %s", hash)})
}
t := Transaction{
Hash: tx.GetHash(),
WeightMagnitude: tx.GetWeightMagnitude(),
TrunkTransactionHash: tx.GetTrunkTransactionHash(),
BranchTransactionHash: tx.GetBranchTransactionHash(),
Head: tx.IsHead(),
Tail: tx.IsTail(),
Nonce: tx.GetNonce(),
Address: tx.GetAddress(),
Value: tx.GetValue(),
Timestamp: tx.GetTimestamp(),
SignatureMessageFragment: tx.GetSignatureMessageFragment(),
}
result = append(result, t)
}
*/
return c.JSON(http.StatusOK, Response{Transactions: result})
}
type Response struct {
Transactions []Transaction `json:"transaction,omitempty"`
Error string `json:"error,omitempty"`
}
type Request struct {
Hashes []string `json:"hashes"`
}
type Transaction struct {
Hash trinary.Trytes `json:"hash,omitempty"`
WeightMagnitude int `json:"weightMagnitude,omitempty"`
TrunkTransactionHash trinary.Trytes `json:"trunkTransactionHash,omitempty"`
BranchTransactionHash trinary.Trytes `json:"branchTransactionHash,omitempty"`
Head bool `json:"head,omitempty"`
Tail bool `json:"tail,omitempty"`
Nonce trinary.Trytes `json:"nonce,omitempty"`
Address trinary.Trytes `json:"address,omitempty"`
Value int64 `json:"value,omitempty"`
Timestamp uint `json:"timestamp,omitempty"`
SignatureMessageFragment trinary.Trytes `json:"signatureMessageFragment,omitempty"`
}
plugins/webapi/getTransactionTrytesByHash/plugin.go deleted 100644 → 0
+ 0
− 60
View file @ 9d7a41b3
package getTransactionTrytesByHash
import (
"net/http"
"github.com/iotaledger/hive.go/logger"
"github.com/iotaledger/hive.go/node"
"github.com/iotaledger/iota.go/trinary"
"github.com/labstack/echo"
"github.com/iotaledger/goshimmer/plugins/webapi"
)
var PLUGIN = node.NewPlugin("WebAPI getTransactionTrytesByHash Endpoint", node.Enabled, configure)
var log *logger.Logger
func configure(plugin *node.Plugin) {
log = logger.NewLogger("API-getTransactionTrytesByHash")
webapi.Server.POST("getTransactionTrytesByHash", getTransactionTrytesByHash)
}
// getTransactionTrytesByHash returns the array of transaction trytes for the
// given transaction hashes (in the same order as the parameters).
// If a node doesn't have the trytes for a given transaction hash in its ledger,
// the value at the index of that transaction hash is empty.
func getTransactionTrytesByHash(c echo.Context) error {
var request Request
result := []trinary.Trytes{}
if err := c.Bind(&request); err != nil {
log.Info(err.Error())
return c.JSON(http.StatusBadRequest, Response{Error: err.Error()})
}
log.Debug("Received:", request.Hashes)
/*
for _, hash := range request.Hashes {
tx, err := tangle_old.GetTransaction(hash)
if err != nil {
return c.JSON(http.StatusInternalServerError, Response{Error: err.Error()})
}
if tx == nil {
return c.JSON(http.StatusNotFound, Response{Error: fmt.Sprintf("transaction not found: %s", hash)})
}
trytes := trinary.MustTritsToTrytes(tx.GetTrits())
result = append(result, trytes)
}
*/
return c.JSON(http.StatusOK, Response{Trytes: result})
}
type Response struct {
Trytes []trinary.Trytes `json:"trytes,omitempty"` //string
Error string `json:"error,omitempty"`
}
type Request struct {
Hashes []string `json:"hashes"`
}
tools/relay-checker/config.go
+ 2
− 6
View file @ 6aaf8071
......@@ -5,8 +5,7 @@ import "github.com/iotaledger/goshimmer/plugins/config"
var (
nodes []string
target = ""
txnAddr = "GOSHIMMER99TEST999999999999999999999999999999999999999999999999999999999999999999"
txnData = "TEST99BROADCAST99DATA"
msgData = "TEST99BROADCAST99DATA"
cooldownTime = 2
repeat = 1
)
......@@ -23,11 +22,8 @@ func InitConfig() {
nodes = append(nodes, config.Node.GetStringSlice(CFG_TEST_NODES)...)
// optional settings
if config.Node.GetString(CFG_TX_ADDRESS) != "" {
txnAddr = config.Node.GetString(CFG_TX_ADDRESS)
}
if config.Node.GetString(CFG_DATA) != "" {
txnData = config.Node.GetString(CFG_DATA)
msgData = config.Node.GetString(CFG_DATA)
}
if config.Node.GetInt(CFG_COOLDOWN_TIME) > 0 {
cooldownTime = config.Node.GetInt(CFG_COOLDOWN_TIME)
......
......
tools/relay-checker/config.json
+ 0
− 1
View file @ 6aaf8071
......@@ -4,7 +4,6 @@
"testNodes": [
"http://127.0.0.1:8080"
],
"txAddress": "SHIMMER99TEST99999999999999999999999999999999999999999999999999999999999999999999",
"data": "TEST99BROADCAST99DATA",
"cooldownTime": 10,
"repeat": 2
......
......
tools/relay-checker/main.go
+ 12
− 14
View file @ 6aaf8071
......@@ -7,34 +7,32 @@ import (
client "github.com/iotaledger/goshimmer/client"
"github.com/iotaledger/goshimmer/plugins/config"
"github.com/iotaledger/goshimmer/plugins/logger"
"github.com/iotaledger/iota.go/trinary"
)
func testBroadcastData(api *client.GoShimmerAPI) (trinary.Hash, error) {
txnHash, err := api.BroadcastData(txnAddr, txnData)
func testBroadcastData(api *client.GoShimmerAPI) (string, error) {
msgId, err := api.BroadcastData([]byte(msgData))
if err != nil {
return "", fmt.Errorf("broadcast failed: %w", err)
}
return txnHash, nil
return msgId, nil
}
func testTargetGetTransactions(api *client.GoShimmerAPI, txnHash trinary.Hash) error {
func testTargetGetMessagess(api *client.GoShimmerAPI, msgId string) error {
// query target node for broadcasted data
if _, err := api.GetTransactionObjectsByHash([]trinary.Hash{txnHash}); err != nil {
if _, err := api.FindMessageById([]string{msgId}); err != nil {
return fmt.Errorf("querying the target node failed: %w", err)
}
return nil
}
func testNodesGetTransactions(txnHash trinary.Hash) error {
func testNodesGetMessages(msgId string) error {
// query nodes node for broadcasted data
for _, n := range nodes {
nodesApi := client.NewGoShimmerAPI(n)
if _, err := nodesApi.GetTransactionObjectsByHash([]trinary.Hash{txnHash}); err != nil {
if _, err := nodesApi.FindMessageById([]string{msgId}); err != nil {
return fmt.Errorf("querying node %s failed: %w", n, err)
}
fmt.Printf("txn found in node %s\n", n)
fmt.Printf("msg found in node %s\n", n)
}
return nil
}
......@@ -47,25 +45,25 @@ func main() {
api := client.NewGoShimmerAPI(target)
for i := 0; i < repeat; i++ {
txnHash, err := testBroadcastData(api)
msgId, err := testBroadcastData(api)
if err != nil {
fmt.Printf("%s\n", err)
break
}
fmt.Printf("txnHash: %s\n", txnHash)
fmt.Printf("msgId: %s\n", msgId)
// cooldown time
time.Sleep(time.Duration(cooldownTime) * time.Second)
// query target node
err = testTargetGetTransactions(api, txnHash)
err = testTargetGetMessagess(api, msgId)
if err != nil {
fmt.Printf("%s\n", err)
break
}
// query test nodes
err = testNodesGetTransactions(txnHash)
err = testNodesGetMessages(msgId)
if err != nil {
fmt.Printf("%s\n", err)
break
......
......
tools/relay-checker/parameters.go
+ 1
− 3
View file @ 6aaf8071
......@@ -7,7 +7,6 @@ import (
const (
CFG_TARGET_NODE = "relayChecker.targetNode"
CFG_TEST_NODES = "relayChecker.testNodes"
CFG_TX_ADDRESS = "relayChecker.txAddress"
CFG_DATA = "relayChecker.data"
CFG_COOLDOWN_TIME = "relayChecker.cooldownTime"
CFG_REPEAT = "relayChecker.repeat"
......@@ -15,8 +14,7 @@ const (
func init() {
flag.StringSlice(CFG_TEST_NODES, []string{""}, "the list of nodes to check after the cooldown")
flag.String(CFG_TARGET_NODE, "http://127.0.0.1:8080", "the target node from the which transaction will be broadcasted from")
flag.String(CFG_TX_ADDRESS, "SHIMMER99TEST99999999999999999999999999999999999999999999999999999999999999999999", "the transaction address")
flag.String(CFG_TARGET_NODE, "http://127.0.0.1:8080", "the target node from the which message will be broadcasted from")
flag.String(CFG_DATA, "TEST99BROADCAST99DATA", "data to broadcast")
flag.Int(CFG_COOLDOWN_TIME, 10, "the cooldown time after broadcasting the data on the specified target node")
flag.Int(CFG_REPEAT, 1, "the amount of times to repeat the relay-checker queries")
......
......
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Please to comment