From 56cc3d20da3a90d0fd78a0836032f43ab1b41b4e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Adri=C3=A0=20Cidre?= Date: Tue, 19 Jun 2018 09:49:24 +0200 Subject: [PATCH] First step to remove StatusAPI (#1034) --- api/api.go | 229 -------------------------------- api/utils.go | 2 +- cmd/statusd/debug/commands.go | 28 ++-- cmd/statusd/debug/debug.go | 4 +- cmd/statusd/debug/debug_test.go | 4 +- cmd/statusd/main.go | 3 +- lib/library.go | 51 +++---- lib/library_test_utils.go | 66 ++++----- lib/main.go | 2 +- t/e2e/api/api_test.go | 75 +++++------ 10 files changed, 115 insertions(+), 349 deletions(-) delete mode 100644 api/api.go diff --git a/api/api.go b/api/api.go deleted file mode 100644 index 89e2aafbe..000000000 --- a/api/api.go +++ /dev/null @@ -1,229 +0,0 @@ -package api - -import ( - "context" - - "github.com/NaySoftware/go-fcm" - "github.com/ethereum/go-ethereum/accounts/keystore" - gethcommon "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/log" - "github.com/status-im/status-go/account" - "github.com/status-im/status-go/jail" - "github.com/status-im/status-go/node" - "github.com/status-im/status-go/params" - "github.com/status-im/status-go/sign" - "github.com/status-im/status-go/transactions" -) - -// StatusAPI provides API to access Status related functionality. -type StatusAPI struct { - b *StatusBackend - log log.Logger -} - -// NewStatusAPI creates a new StatusAPI instance -func NewStatusAPI() *StatusAPI { - return NewStatusAPIWithBackend(NewStatusBackend()) -} - -// NewStatusAPIWithBackend creates a new StatusAPI instance using -// the passed backend. -func NewStatusAPIWithBackend(b *StatusBackend) *StatusAPI { - return &StatusAPI{ - b: b, - log: log.New("package", "status-go/api.StatusAPI"), - } -} - -// StatusNode returns reference to StatusNode. -func (api *StatusAPI) StatusNode() *node.StatusNode { - return api.b.StatusNode() -} - -// AccountManager returns reference to account manager -func (api *StatusAPI) AccountManager() *account.Manager { - return api.b.AccountManager() -} - -// JailManager returns reference to jail -func (api *StatusAPI) JailManager() jail.Manager { - return api.b.JailManager() -} - -// Transactor returns reference to a status transactor -func (api *StatusAPI) Transactor() *transactions.Transactor { - return api.b.Transactor() -} - -// PendingSignRequests returns reference to a list of current sign requests -func (api *StatusAPI) PendingSignRequests() *sign.PendingRequests { - return api.b.PendingSignRequests() -} - -// StartNode start Status node, fails if node is already started -func (api *StatusAPI) StartNode(config *params.NodeConfig) error { - return api.b.StartNode(config) -} - -// StartNodeAsync start Status node, fails if node is already started -// Returns immediately w/o waiting for node to start (see node.ready) -func (api *StatusAPI) StartNodeAsync(config *params.NodeConfig) <-chan error { - return runAsync(func() error { return api.StartNode(config) }) -} - -// StopNode stop Status node. Stopped node cannot be resumed. -func (api *StatusAPI) StopNode() error { - return api.b.StopNode() -} - -// StopNodeAsync stop Status node. Stopped node cannot be resumed. -// Returns immediately, w/o waiting for node to stop (see node.stopped) -func (api *StatusAPI) StopNodeAsync() <-chan error { - return runAsync(api.StopNode) -} - -// RestartNode restart running Status node, fails if node is not running -func (api *StatusAPI) RestartNode() error { - return api.b.RestartNode() -} - -// RestartNodeAsync restart running Status node, in async manner -func (api *StatusAPI) RestartNodeAsync() <-chan error { - return runAsync(api.RestartNode) -} - -// ResetChainData remove chain data from data directory. -// Node is stopped, and new node is started, with clean data directory. -func (api *StatusAPI) ResetChainData() error { - return api.b.ResetChainData() -} - -// ResetChainDataAsync remove chain data from data directory, in async manner -func (api *StatusAPI) ResetChainDataAsync() <-chan error { - return runAsync(api.ResetChainData) -} - -// CallRPC executes public RPC requests on node's in-proc RPC server. -func (api *StatusAPI) CallRPC(inputJSON string) string { - return api.b.CallRPC(inputJSON) -} - -// CallPrivateRPC executes public and private RPC requests on node's in-proc RPC server. -func (api *StatusAPI) CallPrivateRPC(inputJSON string) string { - return api.b.CallPrivateRPC(inputJSON) -} - -// CreateAccount creates an internal geth account -// BIP44-compatible keys are generated: CKD#1 is stored as account key, CKD#2 stored as sub-account root -// Public key of CKD#1 is returned, with CKD#2 securely encoded into account key file (to be used for -// sub-account derivations) -func (api *StatusAPI) CreateAccount(password string) (address, pubKey, mnemonic string, err error) { - return api.b.AccountManager().CreateAccount(password) -} - -// CreateChildAccount creates sub-account for an account identified by parent address. -// CKD#2 is used as root for master accounts (when parentAddress is ""). -// Otherwise (when parentAddress != ""), child is derived directly from parent. -func (api *StatusAPI) CreateChildAccount(parentAddress, password string) (address, pubKey string, err error) { - return api.b.AccountManager().CreateChildAccount(parentAddress, password) -} - -// RecoverAccount re-creates master key using given details. -// Once master key is re-generated, it is inserted into keystore (if not already there). -func (api *StatusAPI) RecoverAccount(password, mnemonic string) (address, pubKey string, err error) { - return api.b.AccountManager().RecoverAccount(password, mnemonic) -} - -// VerifyAccountPassword tries to decrypt a given account key file, with a provided password. -// If no error is returned, then account is considered verified. -func (api *StatusAPI) VerifyAccountPassword(keyStoreDir, address, password string) (*keystore.Key, error) { - return api.b.AccountManager().VerifyAccountPassword(keyStoreDir, address, password) -} - -// SelectAccount selects current account, by verifying that address has corresponding account which can be decrypted -// using provided password. Once verification is done, decrypted key is injected into Whisper (as a single identity, -// all previous identities are removed). -func (api *StatusAPI) SelectAccount(address, password string) error { - return api.b.SelectAccount(address, password) -} - -// Logout clears whisper identities -func (api *StatusAPI) Logout() error { - return api.b.Logout() -} - -// SendTransaction creates a new transaction and waits until it's complete. -func (api *StatusAPI) SendTransaction(ctx context.Context, args transactions.SendTxArgs) (gethcommon.Hash, error) { - return api.b.SendTransaction(ctx, args) -} - -// ApproveSignRequest instructs backend to complete sending of a given transaction -func (api *StatusAPI) ApproveSignRequest(id, password string) sign.Result { - return api.b.ApproveSignRequest(id, password) -} - -// ApproveSignRequestWithArgs instructs backend to complete sending of a given transaction -// gas and gasPrice will be overrided with the given values before signing the -// transaction. -func (api *StatusAPI) ApproveSignRequestWithArgs(id, password string, gas, gasPrice int64) sign.Result { - return api.b.ApproveSignRequestWithArgs(id, password, gas, gasPrice) -} - -// ApproveSignRequests instructs backend to complete sending of multiple transactions -func (api *StatusAPI) ApproveSignRequests(ids []string, password string) map[string]sign.Result { - return api.b.ApproveSignRequests(ids, password) -} - -// DiscardSignRequest discards a given transaction from transaction queue -func (api *StatusAPI) DiscardSignRequest(id string) error { - return api.b.DiscardSignRequest(id) -} - -// DiscardSignRequests discards given multiple transactions from transaction queue -func (api *StatusAPI) DiscardSignRequests(ids []string) map[string]error { - return api.b.DiscardSignRequests(ids) -} - -// JailParse creates a new jail cell context, with the given chatID as identifier. -// New context executes provided JavaScript code, right after the initialization. -// DEPRECATED in favour of CreateAndInitCell. -func (api *StatusAPI) JailParse(chatID string, js string) string { - return api.b.jailManager.Parse(chatID, js) -} - -// CreateAndInitCell creates a new jail cell context, with the given chatID as identifier. -// New context executes provided JavaScript code, right after the initialization. -func (api *StatusAPI) CreateAndInitCell(chatID, js string) string { - return api.b.jailManager.CreateAndInitCell(chatID, js) -} - -// JailCall executes given JavaScript function w/i a jail cell context identified by the chatID. -func (api *StatusAPI) JailCall(chatID, this, args string) string { - return api.b.jailManager.Call(chatID, this, args) -} - -// JailExecute allows to run arbitrary JS code within a jail cell. -func (api *StatusAPI) JailExecute(chatID, code string) string { - return api.b.jailManager.Execute(chatID, code) -} - -// SetJailBaseJS allows to setup initial JavaScript to be loaded on each jail.CreateAndInitCell(). -func (api *StatusAPI) SetJailBaseJS(js string) { - api.b.jailManager.SetBaseJS(js) -} - -// NotifyUsers send notifications to users. -func (api *StatusAPI) NotifyUsers(message string, payload fcm.NotificationPayload, tokens ...string) error { - return api.b.NotifyUsers(message, payload, tokens...) -} - -// ConnectionChange handles network state changes logic. -func (api *StatusAPI) ConnectionChange(typ string, expensive bool) { - api.b.ConnectionChange(typ, expensive) -} - -// AppStateChange handles app state changes (background/foreground). -// state values: see https://facebook.github.io/react-native/docs/appstate.html -func (api *StatusAPI) AppStateChange(state string) { - api.b.AppStateChange(state) -} diff --git a/api/utils.go b/api/utils.go index c61fb137d..5e129d23c 100644 --- a/api/utils.go +++ b/api/utils.go @@ -1,6 +1,6 @@ package api -func runAsync(f func() error) <-chan error { +func RunAsync(f func() error) <-chan error { resp := make(chan error, 1) go func() { err := f() diff --git a/cmd/statusd/debug/commands.go b/cmd/statusd/debug/commands.go index 3bf124791..e457e6c77 100644 --- a/cmd/statusd/debug/commands.go +++ b/cmd/statusd/debug/commands.go @@ -106,14 +106,14 @@ func exprsToArgs(exprs []ast.Expr) []interface{} { // is not possible due to non-low-level arguments. Here this wrapper // helps. type commandSet struct { - statusAPI *api.StatusAPI + statusBackend *api.StatusBackend } // newCommandSet creates the command set for the passed Status API // instance. -func newCommandSet(statusAPI *api.StatusAPI) *commandSet { +func newCommandSet(statusBackend *api.StatusBackend) *commandSet { return &commandSet{ - statusAPI: statusAPI, + statusBackend: statusBackend, } } @@ -124,52 +124,52 @@ func (cs *commandSet) StartNode(config string) error { if err != nil { return err } - return cs.statusAPI.StartNode(nodeConfig) + return cs.statusBackend.StartNode(nodeConfig) } // StopNode starts the stopped node. func (cs *commandSet) StopNode() error { - return cs.statusAPI.StopNode() + return cs.statusBackend.StopNode() } // ResetChainData removes chain data from data directory. func (cs *commandSet) ResetChainData() error { - return cs.statusAPI.ResetChainData() + return cs.statusBackend.ResetChainData() } // CallRPC calls status node via RPC. func (cs *commandSet) CallRPC(inputJSON string) string { - return cs.statusAPI.CallRPC(inputJSON) + return cs.statusBackend.CallRPC(inputJSON) } // CreateAccount creates an internal geth account. func (cs *commandSet) CreateAccount(password string) (string, string, string, error) { - return cs.statusAPI.CreateAccount(password) + return cs.statusBackend.AccountManager().CreateAccount(password) } // CreateChildAccount creates a sub-account. func (cs *commandSet) CreateChildAccount(parentAddress, password string) (string, string, error) { - return cs.statusAPI.CreateChildAccount(parentAddress, password) + return cs.statusBackend.AccountManager().CreateChildAccount(parentAddress, password) } // RecoverAccount re-creates the master key using the given details. func (cs *commandSet) RecoverAccount(password, mnemonic string) (string, string, error) { - return cs.statusAPI.RecoverAccount(password, mnemonic) + return cs.statusBackend.AccountManager().RecoverAccount(password, mnemonic) } // SelectAccount selects the addressed account. func (cs *commandSet) SelectAccount(address, password string) error { - return cs.statusAPI.SelectAccount(address, password) + return cs.statusBackend.SelectAccount(address, password) } // Logout clears the Whisper identities. func (cs *commandSet) Logout() error { - return cs.statusAPI.Logout() + return cs.statusBackend.Logout() } // ApproveSignRequest instructs API to complete sending of a given transaction. func (cs *commandSet) ApproveSignRequest(id, password string) (string, error) { - result := cs.statusAPI.ApproveSignRequest(id, password) + result := cs.statusBackend.ApproveSignRequest(id, password) if result.Error != nil { return "", result.Error } @@ -180,7 +180,7 @@ func (cs *commandSet) ApproveSignRequest(id, password string) (string, error) { // gas and gasPrice will be overrided with the given values before signing the // transaction. func (cs *commandSet) ApproveSignRequestWithArgs(id, password string, gas, gasPrice int64) (string, error) { - result := cs.statusAPI.ApproveSignRequestWithArgs(id, password, gas, gasPrice) + result := cs.statusBackend.ApproveSignRequestWithArgs(id, password, gas, gasPrice) if result.Error != nil { return "", result.Error } diff --git a/cmd/statusd/debug/debug.go b/cmd/statusd/debug/debug.go index dabeb5ccf..0e1bdea94 100644 --- a/cmd/statusd/debug/debug.go +++ b/cmd/statusd/debug/debug.go @@ -27,13 +27,13 @@ type Server struct { // New creates a debug server using the passed Status API. // It also starts the server. -func New(statusAPI *api.StatusAPI, port string) (*Server, error) { +func New(statusBackend *api.StatusBackend, port string) (*Server, error) { listener, err := net.Listen("tcp", fmt.Sprintf(":%s", port)) // nolint if err != nil { return nil, err } s := Server{ - commandSetValue: reflect.ValueOf(newCommandSet(statusAPI)), + commandSetValue: reflect.ValueOf(newCommandSet(statusBackend)), listener: listener, log: log.New("package", "status-go/cmd/statusd/debug.Server"), } diff --git a/cmd/statusd/debug/debug_test.go b/cmd/statusd/debug/debug_test.go index 34704b290..575a16ea1 100644 --- a/cmd/statusd/debug/debug_test.go +++ b/cmd/statusd/debug/debug_test.go @@ -161,8 +161,8 @@ func startDebugging(assert *testifyAssert.Assertions) { defer mu.Unlock() if d == nil { var err error - api := api.NewStatusAPI() - d, err = debug.New(api, debug.CLIPort) + backend := api.NewStatusBackend() + d, err = debug.New(backend, debug.CLIPort) assert.NoError(err) } } diff --git a/cmd/statusd/main.go b/cmd/statusd/main.go index 2da233451..f3c34c445 100644 --- a/cmd/statusd/main.go +++ b/cmd/statusd/main.go @@ -174,8 +174,7 @@ func main() { // startDebug starts the debugging API server. func startDebug(backend *api.StatusBackend) error { - statusAPI := api.NewStatusAPIWithBackend(backend) - _, err := debug.New(statusAPI, *cliPort) + _, err := debug.New(backend, *cliPort) return err } diff --git a/lib/library.go b/lib/library.go index f71990002..5c02584f3 100644 --- a/lib/library.go +++ b/lib/library.go @@ -8,6 +8,7 @@ import ( "github.com/NaySoftware/go-fcm" "github.com/ethereum/go-ethereum/log" + "github.com/status-im/status-go/api" "github.com/status-im/status-go/logutils" "github.com/status-im/status-go/params" "github.com/status-im/status-go/profiling" @@ -46,7 +47,7 @@ func StartNode(configJSON *C.char) *C.char { return makeJSONResponse(err) } - statusAPI.StartNodeAsync(config) + api.RunAsync(func() error { return statusBackend.StartNode(config) }) return makeJSONResponse(nil) } @@ -54,7 +55,7 @@ func StartNode(configJSON *C.char) *C.char { //StopNode - stop status node //export StopNode func StopNode() *C.char { - statusAPI.StopNodeAsync() + api.RunAsync(statusBackend.StopNode) return makeJSONResponse(nil) } @@ -104,21 +105,21 @@ func ValidateNodeConfig(configJSON *C.char) *C.char { //ResetChainData remove chain data from data directory //export ResetChainData func ResetChainData() *C.char { - statusAPI.ResetChainDataAsync() + api.RunAsync(statusBackend.ResetChainData) return makeJSONResponse(nil) } //CallRPC calls public APIs via RPC //export CallRPC func CallRPC(inputJSON *C.char) *C.char { - outputJSON := statusAPI.CallRPC(C.GoString(inputJSON)) + outputJSON := statusBackend.CallRPC(C.GoString(inputJSON)) return C.CString(outputJSON) } //CallPrivateRPC calls both public and private APIs via RPC //export CallPrivateRPC func CallPrivateRPC(inputJSON *C.char) *C.char { - outputJSON := statusAPI.CallPrivateRPC(C.GoString(inputJSON)) + outputJSON := statusBackend.CallPrivateRPC(C.GoString(inputJSON)) return C.CString(outputJSON) } @@ -126,7 +127,7 @@ func CallPrivateRPC(inputJSON *C.char) *C.char { // just modified to handle the function arg passing //export CreateAccount func CreateAccount(password *C.char) *C.char { - address, pubKey, mnemonic, err := statusAPI.CreateAccount(C.GoString(password)) + address, pubKey, mnemonic, err := statusBackend.AccountManager().CreateAccount(C.GoString(password)) errString := "" if err != nil { @@ -147,7 +148,7 @@ func CreateAccount(password *C.char) *C.char { //CreateChildAccount creates sub-account //export CreateChildAccount func CreateChildAccount(parentAddress, password *C.char) *C.char { - address, pubKey, err := statusAPI.CreateChildAccount(C.GoString(parentAddress), C.GoString(password)) + address, pubKey, err := statusBackend.AccountManager().CreateChildAccount(C.GoString(parentAddress), C.GoString(password)) errString := "" if err != nil { @@ -167,7 +168,7 @@ func CreateChildAccount(parentAddress, password *C.char) *C.char { //RecoverAccount re-creates master key using given details //export RecoverAccount func RecoverAccount(password, mnemonic *C.char) *C.char { - address, pubKey, err := statusAPI.RecoverAccount(C.GoString(password), C.GoString(mnemonic)) + address, pubKey, err := statusBackend.AccountManager().RecoverAccount(C.GoString(password), C.GoString(mnemonic)) errString := "" if err != nil { @@ -188,7 +189,7 @@ func RecoverAccount(password, mnemonic *C.char) *C.char { //VerifyAccountPassword verifies account password //export VerifyAccountPassword func VerifyAccountPassword(keyStoreDir, address, password *C.char) *C.char { - _, err := statusAPI.VerifyAccountPassword(C.GoString(keyStoreDir), C.GoString(address), C.GoString(password)) + _, err := statusBackend.AccountManager().VerifyAccountPassword(C.GoString(keyStoreDir), C.GoString(address), C.GoString(password)) return makeJSONResponse(err) } @@ -196,14 +197,14 @@ func VerifyAccountPassword(keyStoreDir, address, password *C.char) *C.char { // if verified, purges all the previous identities from Whisper, and injects verified key as shh identity //export Login func Login(address, password *C.char) *C.char { - err := statusAPI.SelectAccount(C.GoString(address), C.GoString(password)) + err := statusBackend.SelectAccount(C.GoString(address), C.GoString(password)) return makeJSONResponse(err) } //Logout is equivalent to clearing whisper identities //export Logout func Logout() *C.char { - err := statusAPI.Logout() + err := statusBackend.Logout() return makeJSONResponse(err) } @@ -212,7 +213,7 @@ func Logout() *C.char { // transaction. //export ApproveSignRequestWithArgs func ApproveSignRequestWithArgs(id, password *C.char, gas, gasPrice C.longlong) *C.char { - result := statusAPI.ApproveSignRequestWithArgs(C.GoString(id), C.GoString(password), int64(gas), int64(gasPrice)) + result := statusBackend.ApproveSignRequestWithArgs(C.GoString(id), C.GoString(password), int64(gas), int64(gasPrice)) return prepareApproveSignRequestResponse(result, id) } @@ -220,7 +221,7 @@ func ApproveSignRequestWithArgs(id, password *C.char, gas, gasPrice C.longlong) //ApproveSignRequest instructs backend to complete sending of a given transaction. //export ApproveSignRequest func ApproveSignRequest(id, password *C.char) *C.char { - result := statusAPI.ApproveSignRequest(C.GoString(id), C.GoString(password)) + result := statusBackend.ApproveSignRequest(C.GoString(id), C.GoString(password)) return prepareApproveSignRequestResponse(result, id) } @@ -265,7 +266,7 @@ func ApproveSignRequests(ids, password *C.char) *C.char { txIDs[i] = id } - results := statusAPI.ApproveSignRequests(txIDs, C.GoString(password)) + results := statusBackend.ApproveSignRequests(txIDs, C.GoString(password)) for txID, result := range results { txResult := SignRequestResult{ ID: txID, @@ -290,7 +291,7 @@ func ApproveSignRequests(ids, password *C.char) *C.char { //DiscardSignRequest discards a given transaction from transaction queue //export DiscardSignRequest func DiscardSignRequest(id *C.char) *C.char { - err := statusAPI.DiscardSignRequest(C.GoString(id)) + err := statusBackend.DiscardSignRequest(C.GoString(id)) errString := "" if err != nil { @@ -328,7 +329,7 @@ func DiscardSignRequests(ids *C.char) *C.char { txIDs[i] = id } - results := statusAPI.DiscardSignRequests(txIDs) + results := statusBackend.DiscardSignRequests(txIDs) for txID, err := range results { out.Results[txID] = DiscardSignRequestResult{ ID: txID, @@ -349,35 +350,35 @@ func DiscardSignRequests(ids *C.char) *C.char { //InitJail setup initial JavaScript //export InitJail func InitJail(js *C.char) { - statusAPI.SetJailBaseJS(C.GoString(js)) + statusBackend.JailManager().SetBaseJS(C.GoString(js)) } //Parse creates a new jail cell context and executes provided JavaScript code. //DEPRECATED in favour of CreateAndInitCell. //export Parse func Parse(chatID *C.char, js *C.char) *C.char { - res := statusAPI.CreateAndInitCell(C.GoString(chatID), C.GoString(js)) + res := statusBackend.JailManager().CreateAndInitCell(C.GoString(chatID), C.GoString(js)) return C.CString(res) } //CreateAndInitCell creates a new jail cell context and executes provided JavaScript code. //export CreateAndInitCell func CreateAndInitCell(chatID *C.char, js *C.char) *C.char { - res := statusAPI.CreateAndInitCell(C.GoString(chatID), C.GoString(js)) + res := statusBackend.JailManager().CreateAndInitCell(C.GoString(chatID), C.GoString(js)) return C.CString(res) } //ExecuteJS allows to run arbitrary JS code within a cell. //export ExecuteJS func ExecuteJS(chatID *C.char, code *C.char) *C.char { - res := statusAPI.JailExecute(C.GoString(chatID), C.GoString(code)) + res := statusBackend.JailManager().Execute(C.GoString(chatID), C.GoString(code)) return C.CString(res) } //Call executes given JavaScript function //export Call func Call(chatID *C.char, path *C.char, params *C.char) *C.char { - res := statusAPI.JailCall(C.GoString(chatID), C.GoString(path), C.GoString(params)) + res := statusBackend.JailManager().Call(C.GoString(chatID), C.GoString(path), C.GoString(params)) return C.CString(res) } @@ -455,7 +456,7 @@ func NotifyUsers(message, payloadJSON, tokensArray *C.char) (outCBytes *C.char) return } - err = statusAPI.NotifyUsers(C.GoString(message), payload, tokens...) + err = statusBackend.NotifyUsers(C.GoString(message), payload, tokens...) if err != nil { errString = err.Error() return @@ -467,7 +468,7 @@ func NotifyUsers(message, payloadJSON, tokensArray *C.char) (outCBytes *C.char) // AddPeer adds an enode as a peer. //export AddPeer func AddPeer(enode *C.char) *C.char { - err := statusAPI.StatusNode().AddPeer(C.GoString(enode)) + err := statusBackend.StatusNode().AddPeer(C.GoString(enode)) return makeJSONResponse(err) } @@ -475,11 +476,11 @@ func AddPeer(enode *C.char) *C.char { // by ReactNative (see https://facebook.github.io/react-native/docs/netinfo.html) //export ConnectionChange func ConnectionChange(typ *C.char, expensive C.int) { - statusAPI.ConnectionChange(C.GoString(typ), expensive == 1) + statusBackend.ConnectionChange(C.GoString(typ), expensive == 1) } // AppStateChange handles app state changes (background/foreground). //export AppStateChange func AppStateChange(state *C.char) { - statusAPI.AppStateChange(C.GoString(state)) + statusBackend.AppStateChange(C.GoString(state)) } diff --git a/lib/library_test_utils.go b/lib/library_test_utils.go index 7d631360d..9a8efbe86 100644 --- a/lib/library_test_utils.go +++ b/lib/library_test_utils.go @@ -267,7 +267,7 @@ func testResetChainData(t *testing.T) bool { return false } - EnsureNodeSync(statusAPI.StatusNode().EnsureSync) + EnsureNodeSync(statusBackend.StatusNode().EnsureSync) testCompleteTransaction(t) return true @@ -275,17 +275,17 @@ func testResetChainData(t *testing.T) bool { func testStopResumeNode(t *testing.T) bool { //nolint: gocyclo // to make sure that we start with empty account (which might have gotten populated during previous tests) - if err := statusAPI.Logout(); err != nil { + if err := statusBackend.Logout(); err != nil { t.Fatal(err) } - whisperService, err := statusAPI.StatusNode().WhisperService() + whisperService, err := statusBackend.StatusNode().WhisperService() if err != nil { t.Errorf("whisper service not running: %v", err) } // create an account - address1, pubKey1, _, err := statusAPI.CreateAccount(TestConfig.Account1.Password) + address1, pubKey1, _, err := statusBackend.AccountManager().CreateAccount(TestConfig.Account1.Password) if err != nil { t.Errorf("could not create account: %v", err) return false @@ -366,7 +366,7 @@ func testStopResumeNode(t *testing.T) bool { //nolint: gocyclo time.Sleep(10 * time.Second) // allow to start (instead of using blocking version of start, of filter event) // now, verify that we still have account logged in - whisperService, err = statusAPI.StatusNode().WhisperService() + whisperService, err = statusBackend.StatusNode().WhisperService() if err != nil { t.Errorf("whisper service not running: %v", err) } @@ -417,11 +417,11 @@ func testCallPrivateRPCWithPrivateAPI(t *testing.T) bool { func testCreateChildAccount(t *testing.T) bool { //nolint: gocyclo // to make sure that we start with empty account (which might get populated during previous tests) - if err := statusAPI.Logout(); err != nil { + if err := statusBackend.Logout(); err != nil { t.Fatal(err) } - keyStore, err := statusAPI.StatusNode().AccountKeyStore() + keyStore, err := statusBackend.StatusNode().AccountKeyStore() if err != nil { t.Error(err) return false @@ -475,7 +475,7 @@ func testCreateChildAccount(t *testing.T) bool { //nolint: gocyclo return false } - err = statusAPI.SelectAccount(address, TestConfig.Account1.Password) + err = statusBackend.SelectAccount(address, TestConfig.Account1.Password) if err != nil { t.Errorf("Test failed: could not select account: %v", err) return false @@ -552,10 +552,10 @@ func testCreateChildAccount(t *testing.T) bool { //nolint: gocyclo } func testRecoverAccount(t *testing.T) bool { //nolint: gocyclo - keyStore, _ := statusAPI.StatusNode().AccountKeyStore() + keyStore, _ := statusBackend.StatusNode().AccountKeyStore() // create an account - address, pubKey, mnemonic, err := statusAPI.CreateAccount(TestConfig.Account1.Password) + address, pubKey, mnemonic, err := statusBackend.AccountManager().CreateAccount(TestConfig.Account1.Password) if err != nil { t.Errorf("could not create account: %v", err) return false @@ -643,7 +643,7 @@ func testRecoverAccount(t *testing.T) bool { //nolint: gocyclo } // time to login with recovered data - whisperService, err := statusAPI.StatusNode().WhisperService() + whisperService, err := statusBackend.StatusNode().WhisperService() if err != nil { t.Errorf("whisper service not running: %v", err) } @@ -652,7 +652,7 @@ func testRecoverAccount(t *testing.T) bool { //nolint: gocyclo if whisperService.HasKeyPair(pubKeyCheck) { t.Error("identity already present in whisper") } - err = statusAPI.SelectAccount(addressCheck, TestConfig.Account1.Password) + err = statusBackend.SelectAccount(addressCheck, TestConfig.Account1.Password) if err != nil { t.Errorf("Test failed: could not select account: %v", err) return false @@ -666,20 +666,20 @@ func testRecoverAccount(t *testing.T) bool { //nolint: gocyclo func testAccountSelect(t *testing.T) bool { //nolint: gocyclo // test to see if the account was injected in whisper - whisperService, err := statusAPI.StatusNode().WhisperService() + whisperService, err := statusBackend.StatusNode().WhisperService() if err != nil { t.Errorf("whisper service not running: %v", err) } // create an account - address1, pubKey1, _, err := statusAPI.CreateAccount(TestConfig.Account1.Password) + address1, pubKey1, _, err := statusBackend.AccountManager().CreateAccount(TestConfig.Account1.Password) if err != nil { t.Errorf("could not create account: %v", err) return false } t.Logf("Account created: {address: %s, key: %s}", address1, pubKey1) - address2, pubKey2, _, err := statusAPI.CreateAccount(TestConfig.Account1.Password) + address2, pubKey2, _, err := statusBackend.AccountManager().CreateAccount(TestConfig.Account1.Password) if err != nil { t.Error("Test failed: could not create account") return false @@ -749,14 +749,14 @@ func testAccountSelect(t *testing.T) bool { //nolint: gocyclo } func testAccountLogout(t *testing.T) bool { - whisperService, err := statusAPI.StatusNode().WhisperService() + whisperService, err := statusBackend.StatusNode().WhisperService() if err != nil { t.Errorf("whisper service not running: %v", err) return false } // create an account - address, pubKey, _, err := statusAPI.CreateAccount(TestConfig.Account1.Password) + address, pubKey, _, err := statusBackend.AccountManager().CreateAccount(TestConfig.Account1.Password) if err != nil { t.Errorf("could not create account: %v", err) return false @@ -769,7 +769,7 @@ func testAccountLogout(t *testing.T) bool { } // select/login - err = statusAPI.SelectAccount(address, TestConfig.Account1.Password) + err = statusBackend.SelectAccount(address, TestConfig.Account1.Password) if err != nil { t.Errorf("Test failed: could not select account: %v", err) return false @@ -802,12 +802,12 @@ func testAccountLogout(t *testing.T) bool { } func testCompleteTransaction(t *testing.T) bool { - signRequests := statusAPI.PendingSignRequests() + signRequests := statusBackend.PendingSignRequests() - EnsureNodeSync(statusAPI.StatusNode().EnsureSync) + EnsureNodeSync(statusBackend.StatusNode().EnsureSync) // log into account from which transactions will be sent - if err := statusAPI.SelectAccount(TestConfig.Account1.Address, TestConfig.Account1.Password); err != nil { + if err := statusBackend.SelectAccount(TestConfig.Account1.Address, TestConfig.Account1.Password); err != nil { t.Errorf("cannot select account: %v. Error %q", TestConfig.Account1.Address, err) return false } @@ -849,7 +849,7 @@ func testCompleteTransaction(t *testing.T) bool { }) // this call blocks, up until Complete Transaction is called - txCheckHash, err := statusAPI.SendTransaction(context.TODO(), transactions.SendTxArgs{ + txCheckHash, err := statusBackend.SendTransaction(context.TODO(), transactions.SendTxArgs{ From: account.FromAddress(TestConfig.Account1.Address), To: account.ToAddress(TestConfig.Account2.Address), Value: (*hexutil.Big)(big.NewInt(1000000000000)), @@ -881,10 +881,10 @@ func testCompleteTransaction(t *testing.T) bool { } func testCompleteMultipleQueuedTransactions(t *testing.T) bool { //nolint: gocyclo - signRequests := statusAPI.PendingSignRequests() + signRequests := statusBackend.PendingSignRequests() // log into account from which transactions will be sent - if err := statusAPI.SelectAccount(TestConfig.Account1.Address, TestConfig.Account1.Password); err != nil { + if err := statusBackend.SelectAccount(TestConfig.Account1.Address, TestConfig.Account1.Password); err != nil { t.Errorf("cannot select account: %v", TestConfig.Account1.Address) return false } @@ -913,7 +913,7 @@ func testCompleteMultipleQueuedTransactions(t *testing.T) bool { //nolint: gocyc // this call blocks, and should return when DiscardQueuedTransaction() for a given tx id is called sendTx := func() { - txHashCheck, err := statusAPI.SendTransaction(context.TODO(), transactions.SendTxArgs{ + txHashCheck, err := statusBackend.SendTransaction(context.TODO(), transactions.SendTxArgs{ From: account.FromAddress(TestConfig.Account1.Address), To: account.ToAddress(TestConfig.Account2.Address), Value: (*hexutil.Big)(big.NewInt(1000000000000)), @@ -1013,10 +1013,10 @@ func testCompleteMultipleQueuedTransactions(t *testing.T) bool { //nolint: gocyc } func testDiscardTransaction(t *testing.T) bool { //nolint: gocyclo - signRequests := statusAPI.PendingSignRequests() + signRequests := statusBackend.PendingSignRequests() // log into account from which transactions will be sent - if err := statusAPI.SelectAccount(TestConfig.Account1.Address, TestConfig.Account1.Password); err != nil { + if err := statusBackend.SelectAccount(TestConfig.Account1.Address, TestConfig.Account1.Password); err != nil { t.Errorf("cannot select account: %v", TestConfig.Account1.Address) return false } @@ -1058,7 +1058,7 @@ func testDiscardTransaction(t *testing.T) bool { //nolint: gocyclo } // try completing discarded transaction - err := statusAPI.ApproveSignRequest(string(txID), TestConfig.Account1.Password).Error + err := statusBackend.ApproveSignRequest(string(txID), TestConfig.Account1.Password).Error if err != sign.ErrSignReqNotFound { t.Error("expects tx not found, but call to CompleteTransaction succeeded") return @@ -1094,7 +1094,7 @@ func testDiscardTransaction(t *testing.T) bool { //nolint: gocyclo }) // this call blocks, and should return when DiscardQueuedTransaction() is called - txHashCheck, err := statusAPI.SendTransaction(context.TODO(), transactions.SendTxArgs{ + txHashCheck, err := statusBackend.SendTransaction(context.TODO(), transactions.SendTxArgs{ From: account.FromAddress(TestConfig.Account1.Address), To: account.ToAddress(TestConfig.Account2.Address), Value: (*hexutil.Big)(big.NewInt(1000000000000)), @@ -1126,10 +1126,10 @@ func testDiscardTransaction(t *testing.T) bool { //nolint: gocyclo } func testDiscardMultipleQueuedTransactions(t *testing.T) bool { //nolint: gocyclo - signRequests := statusAPI.PendingSignRequests() + signRequests := statusBackend.PendingSignRequests() // log into account from which transactions will be sent - if err := statusAPI.SelectAccount(TestConfig.Account1.Address, TestConfig.Account1.Password); err != nil { + if err := statusBackend.SelectAccount(TestConfig.Account1.Address, TestConfig.Account1.Password); err != nil { t.Errorf("cannot select account: %v", TestConfig.Account1.Address) return false } @@ -1185,7 +1185,7 @@ func testDiscardMultipleQueuedTransactions(t *testing.T) bool { //nolint: gocycl // this call blocks, and should return when DiscardQueuedTransaction() for a given tx id is called sendTx := func() { - txHashCheck, err := statusAPI.SendTransaction(context.TODO(), transactions.SendTxArgs{ + txHashCheck, err := statusBackend.SendTransaction(context.TODO(), transactions.SendTxArgs{ From: account.FromAddress(TestConfig.Account1.Address), To: account.ToAddress(TestConfig.Account2.Address), Value: (*hexutil.Big)(big.NewInt(1000000000000)), @@ -1472,7 +1472,7 @@ func startTestNode(t *testing.T) <-chan struct{} { // sync if syncRequired { t.Logf("Sync is required") - EnsureNodeSync(statusAPI.StatusNode().EnsureSync) + EnsureNodeSync(statusBackend.StatusNode().EnsureSync) } else { time.Sleep(5 * time.Second) } diff --git a/lib/main.go b/lib/main.go index e3c8ba739..6064e5210 100644 --- a/lib/main.go +++ b/lib/main.go @@ -2,7 +2,7 @@ package main import "github.com/status-im/status-go/api" -var statusAPI = api.NewStatusAPI() +var statusBackend = api.NewStatusBackend() // Technically this package supposed to be a lib for // cross-compilation and usage with Android/iOS, but diff --git a/t/e2e/api/api_test.go b/t/e2e/api/api_test.go index b2505870e..7def1225b 100644 --- a/t/e2e/api/api_test.go +++ b/t/e2e/api/api_test.go @@ -9,7 +9,6 @@ import ( "testing" "time" - "github.com/ethereum/go-ethereum/log" "github.com/status-im/status-go/api" "github.com/status-im/status-go/node" "github.com/status-im/status-go/params" @@ -30,18 +29,18 @@ func TestAPI(t *testing.T) { type APITestSuite struct { suite.Suite - api *api.StatusAPI + backend *api.StatusBackend } func (s *APITestSuite) ensureNodeStopped() { - if err := s.api.StopNode(); err != node.ErrNoRunningNode && err != nil { + if err := s.backend.StopNode(); err != node.ErrNoRunningNode && err != nil { s.NoError(err, "unexpected error") } } func (s *APITestSuite) SetupTest() { - s.api = api.NewStatusAPI() - s.NotNil(s.api) + s.backend = api.NewStatusBackend() + s.NotNil(s.backend) } func (s *APITestSuite) TestCHTUpdate() { @@ -76,29 +75,25 @@ func (s *APITestSuite) TestRaceConditions() { var funcsToTest = []func(*params.NodeConfig){ func(config *params.NodeConfig) { - log.Info("StartNodeAsync()") - s.api.StartNodeAsync(config) - s.T().Logf("StartNodeAsync() for network: %d", config.NetworkID) + s.T().Logf("async call to StartNode() for network: %d", config.NetworkID) + api.RunAsync(func() error { return s.backend.StartNode(config) }) progress <- struct{}{} }, func(config *params.NodeConfig) { - log.Info("StopNodeAsync()") - s.api.StopNodeAsync() - s.T().Logf("StopNodeAsync()") + s.T().Logf("async call to StopNode() for network: %d", config.NetworkID) + api.RunAsync(s.backend.StopNode) progress <- struct{}{} }, func(config *params.NodeConfig) { - log.Info("RestartNodeAsync()") - s.api.RestartNodeAsync() - s.T().Logf("RestartNodeAsync()") + s.T().Logf("async call to RestartNode() for network: %d", config.NetworkID) + api.RunAsync(s.backend.RestartNode) progress <- struct{}{} }, // TODO(adam): quarantined until it uses a different datadir // as otherwise it wipes out cached blockchain data. // func(config *params.NodeConfig) { - // log.Info("ResetChainDataAsync()") - // _, err := s.api.ResetChainDataAsync() - // s.T().Logf("ResetChainDataAsync(), error: %v", err) + // s.T().Logf("async call to ResetChainData() for network: %d", config.NetworkID) + // _, err := s.api.ResetChainData() // progress <- struct{}{} // }, } @@ -141,29 +136,29 @@ func (s *APITestSuite) TestCellsRemovedAfterSwitchAccount() { config, err := MakeTestNodeConfig(GetNetworkID()) require.NoError(err) - err = s.api.StartNode(config) + err = s.backend.StartNode(config) require.NoError(err) - defer s.api.StopNode() //nolint: errcheck + defer s.backend.StopNode() //nolint: errcheck - address1, _, _, err := s.api.AccountManager().CreateAccount(TestConfig.Account1.Password) + address1, _, _, err := s.backend.AccountManager().CreateAccount(TestConfig.Account1.Password) require.NoError(err) - address2, _, _, err := s.api.AccountManager().CreateAccount(TestConfig.Account2.Password) + address2, _, _, err := s.backend.AccountManager().CreateAccount(TestConfig.Account2.Password) require.NoError(err) - err = s.api.SelectAccount(address1, TestConfig.Account1.Password) + err = s.backend.SelectAccount(address1, TestConfig.Account1.Password) require.NoError(err) for i := 0; i < itersCount; i++ { - _, e := s.api.JailManager().CreateCell(getChatID(i)) + _, e := s.backend.JailManager().CreateCell(getChatID(i)) require.NoError(e) } - err = s.api.SelectAccount(address2, TestConfig.Account2.Password) + err = s.backend.SelectAccount(address2, TestConfig.Account2.Password) require.NoError(err) for i := 0; i < itersCount; i++ { - _, e := s.api.JailManager().Cell(getChatID(i)) + _, e := s.backend.JailManager().Cell(getChatID(i)) require.Error(e) } } @@ -178,22 +173,22 @@ func (s *APITestSuite) TestLogoutRemovesCells() { config, err := MakeTestNodeConfig(GetNetworkID()) require.NoError(err) - err = s.api.StartNode(config) + err = s.backend.StartNode(config) require.NoError(err) - defer s.api.StopNode() //nolint: errcheck + defer s.backend.StopNode() //nolint: errcheck - address1, _, _, err := s.api.AccountManager().CreateAccount(TestConfig.Account1.Password) + address1, _, _, err := s.backend.AccountManager().CreateAccount(TestConfig.Account1.Password) require.NoError(err) - err = s.api.SelectAccount(address1, TestConfig.Account1.Password) + err = s.backend.SelectAccount(address1, TestConfig.Account1.Password) require.NoError(err) - s.api.JailManager().CreateAndInitCell(testChatID) + s.backend.JailManager().CreateAndInitCell(testChatID) - err = s.api.Logout() + err = s.backend.Logout() require.NoError(err) - _, err = s.api.JailManager().Cell(testChatID) + _, err = s.backend.JailManager().Cell(testChatID) require.Error(err, "Expected that cells was removed") } @@ -216,14 +211,14 @@ func (s *APITestSuite) TestEventsNodeStartStop() { nodeConfig, err := MakeTestNodeConfig(GetNetworkID()) s.NoError(err) - s.NoError(s.api.StartNode(nodeConfig)) - s.NoError(s.api.StopNode()) + s.NoError(s.backend.StartNode(nodeConfig)) + s.NoError(s.backend.StopNode()) s.verifyEnvelopes(envelopes, signal.EventNodeStarted, signal.EventNodeReady, signal.EventNodeStopped) - s.NoError(s.api.StartNode(nodeConfig)) + s.NoError(s.backend.StartNode(nodeConfig)) s.verifyEnvelopes(envelopes, signal.EventNodeStarted, signal.EventNodeReady) - s.NoError(s.api.RestartNode()) + s.NoError(s.backend.RestartNode()) s.verifyEnvelopes(envelopes, signal.EventNodeStopped, signal.EventNodeStarted, signal.EventNodeReady) - s.NoError(s.api.StopNode()) + s.NoError(s.backend.StopNode()) s.verifyEnvelopes(envelopes, signal.EventNodeStopped) } @@ -266,7 +261,7 @@ func (s *APITestSuite) TestNodeStartCrash() { s.NoError(err) // now try starting using node manager, it should fail (error is irrelevant as it is implementation detail) - s.Error(<-s.api.StartNodeAsync(nodeConfig)) + s.Error(<-api.RunAsync(func() error { return s.backend.StartNode(nodeConfig) })) select { case <-time.After(500 * time.Millisecond): @@ -277,7 +272,7 @@ func (s *APITestSuite) TestNodeStartCrash() { // stop outside node, and re-try s.NoError(outsideNode.Stop()) signalReceived = make(chan struct{}) - s.NoError(<-s.api.StartNodeAsync(nodeConfig)) + s.NoError(<-api.RunAsync(func() error { return s.backend.StartNode(nodeConfig) })) select { case <-time.After(500 * time.Millisecond): @@ -286,5 +281,5 @@ func (s *APITestSuite) TestNodeStartCrash() { } // cleanup - s.NoError(s.api.StopNode()) + s.NoError(s.backend.StopNode()) }