From cfac2114cd79f1dc5a30164ff2e9cc322a753085 Mon Sep 17 00:00:00 2001 From: number571 Date: Thu, 1 Jun 2023 18:40:44 +0700 Subject: [PATCH] update --- TODO.md | 1 + cmd/hidden_lake/messenger/cmd/hlm/init_app.go | 3 +- .../messenger/cmd/m_hlm/init_app.go | 7 +- cmd/hidden_lake/messenger/internal/app/app.go | 14 ++-- .../messenger/internal/app/init_storage.go | 7 +- .../messenger/internal/app/state/clear.go | 24 ++++-- .../messenger/internal/app/state/state.go | 68 ++++++++++----- .../messenger/internal/app/state/update.go | 28 ++++--- .../messenger/internal/app/state/updater.go | 16 ++-- .../messenger/internal/config/config.go | 17 ++-- .../messenger/internal/database/database.go | 44 +++++----- .../messenger/internal/database/wrapper.go | 6 +- cmd/hidden_lake/service/cmd/hls/init_app.go | 8 +- cmd/hidden_lake/service/cmd/m_hls/init_app.go | 5 +- cmd/hidden_lake/service/pkg/app/app.go | 38 ++++----- .../service/pkg/app/init_database.go | 3 +- cmd/hidden_lake/service/pkg/client/client.go | 77 +++++++++++++---- .../service/pkg/client/requester.go | 70 ++++++++++++---- cmd/hidden_lake/service/pkg/config/config.go | 25 +++--- cmd/hidden_lake/service/pkg/config/editor.go | 11 +-- cmd/hidden_lake/service/pkg/config/init.go | 13 ++- .../service/pkg/request/request.go | 7 +- .../service/pkg/response/response.go | 11 ++- cmd/hidden_lake/traffic/cmd/hlt/init_app.go | 3 +- cmd/hidden_lake/traffic/cmd/m_hlt/init_app.go | 3 +- cmd/hidden_lake/traffic/internal/app/app.go | 32 +++---- .../traffic/internal/app/init_database.go | 3 +- .../traffic/internal/config/config.go | 17 ++-- .../traffic/internal/config/init.go | 13 ++- .../traffic/internal/database/database.go | 34 ++++---- .../traffic/internal/database/wrapper.go | 6 +- cmd/hidden_lake/traffic/pkg/client/client.go | 20 ++++- .../traffic/pkg/client/requester.go | 17 ++-- internal/api/request.go | 18 ++-- internal/mobile/mobile.go | 5 +- internal/mobile/openurl.go | 8 +- pkg/client/client.go | 37 +++++---- pkg/client/queue/queue.go | 8 +- pkg/encoding/serialize.go | 11 ++- pkg/errors/errors.go | 83 +++++++++++++++++++ pkg/errors/errors_test.go | 70 ++++++++++++++++ pkg/filesystem/file.go | 9 +- pkg/network/anonymity/anonymity.go | 53 ++++++++---- pkg/network/conn/conn.go | 28 +++---- pkg/network/conn_keeper/conn_keeper.go | 6 +- pkg/network/network.go | 24 +++--- pkg/storage/database/encrypt.go | 8 +- pkg/storage/database/sqlite.go | 24 ++++-- pkg/storage/memory.go | 6 +- pkg/storage/storage.go | 22 ++--- pkg/types/closer.go | 10 +-- pkg/types/stopper.go | 10 +-- 52 files changed, 753 insertions(+), 338 deletions(-) create mode 100644 pkg/errors/errors.go create mode 100644 pkg/errors/errors_test.go diff --git a/TODO.md b/TODO.md index a428a573..2fbdd76c 100644 --- a/TODO.md +++ b/TODO.md @@ -6,3 +6,4 @@ 4. Write linters (names with prefixes 'p', 'f', 's', 'i', 'c', 'g'), (objects with name=p) 5. Create HLC (Hidden Lake Connector) 6. HLM to service +7. Errors wrapper diff --git a/cmd/hidden_lake/messenger/cmd/hlm/init_app.go b/cmd/hidden_lake/messenger/cmd/hlm/init_app.go index a9c82854..a9c8381f 100644 --- a/cmd/hidden_lake/messenger/cmd/hlm/init_app.go +++ b/cmd/hidden_lake/messenger/cmd/hlm/init_app.go @@ -4,13 +4,14 @@ import ( "github.com/number571/go-peer/cmd/hidden_lake/messenger/internal/app" "github.com/number571/go-peer/cmd/hidden_lake/messenger/internal/config" "github.com/number571/go-peer/cmd/hidden_lake/messenger/internal/settings" + "github.com/number571/go-peer/pkg/errors" "github.com/number571/go-peer/pkg/types" ) func initApp() (types.ICommand, error) { cfg, err := config.InitConfig(settings.CPathCFG, nil) if err != nil { - return nil, err + return nil, errors.WrapError(err, "init config") } return app.NewApp(cfg, "."), nil diff --git a/cmd/hidden_lake/messenger/cmd/m_hlm/init_app.go b/cmd/hidden_lake/messenger/cmd/m_hlm/init_app.go index 0149949f..5855030f 100644 --- a/cmd/hidden_lake/messenger/cmd/m_hlm/init_app.go +++ b/cmd/hidden_lake/messenger/cmd/m_hlm/init_app.go @@ -7,6 +7,7 @@ import ( "github.com/number571/go-peer/cmd/hidden_lake/messenger/internal/config" "github.com/number571/go-peer/cmd/hidden_lake/messenger/internal/settings" "github.com/number571/go-peer/pkg/crypto/asymmetric" + "github.com/number571/go-peer/pkg/errors" "github.com/number571/go-peer/pkg/types" hls_app "github.com/number571/go-peer/cmd/hidden_lake/service/pkg/app" @@ -21,7 +22,7 @@ const ( func initApp(pPathTo string) (types.ICommand, types.ICommand, error) { privKey := asymmetric.NewRSAPrivKey(hls_settings.CAKeySize) if privKey == nil { - return nil, nil, fmt.Errorf("private key is invalid") + return nil, nil, errors.NewError("private key is invalid") } cfgHLS, err := hls_config.InitConfig( @@ -38,7 +39,7 @@ func initApp(pPathTo string) (types.ICommand, types.ICommand, error) { }, ) if err != nil { - return nil, nil, err + return nil, nil, errors.WrapError(err, "init config HLS") } cfgHLM, err := config.InitConfig( @@ -55,7 +56,7 @@ func initApp(pPathTo string) (types.ICommand, types.ICommand, error) { }, ) if err != nil { - return nil, nil, err + return nil, nil, errors.WrapError(err, "init config HLM") } return hls_app.NewApp(cfgHLS, privKey, pPathTo), app.NewApp(cfgHLM, pPathTo), nil diff --git a/cmd/hidden_lake/messenger/internal/app/app.go b/cmd/hidden_lake/messenger/internal/app/app.go index e73067d6..2bcf7b5c 100644 --- a/cmd/hidden_lake/messenger/internal/app/app.go +++ b/cmd/hidden_lake/messenger/internal/app/app.go @@ -19,6 +19,7 @@ import ( hls_settings "github.com/number571/go-peer/cmd/hidden_lake/service/pkg/settings" hlt_client "github.com/number571/go-peer/cmd/hidden_lake/traffic/pkg/client" internal_logger "github.com/number571/go-peer/internal/logger" + pkg_errors "github.com/number571/go-peer/pkg/errors" ) const ( @@ -85,7 +86,7 @@ func (p *sApp) Run() error { defer p.fMutex.Unlock() if p.fIsRun { - return errors.New("application already running") + return pkg_errors.NewError("application already running") } p.fIsRun = true @@ -112,8 +113,7 @@ func (p *sApp) Run() error { select { case err := <-res: - p.Stop() - return err + return pkg_errors.AppendError(err, p.Stop()) case <-time.After(cInitStart): p.fLogger.PushInfo(fmt.Sprintf("%s is running...", settings.CServiceName)) return nil @@ -125,7 +125,7 @@ func (p *sApp) Stop() error { defer p.fMutex.Unlock() if !p.fIsRun { - return errors.New("application already stopped or not started") + return pkg_errors.NewError("application already stopped or not started") } p.fIsRun = false p.fLogger.PushInfo(fmt.Sprintf("%s is shutting down...", settings.CServiceName)) @@ -133,9 +133,13 @@ func (p *sApp) Stop() error { // state may be already closed _ = p.fState.ClearActiveState() - return types.CloseAll([]types.ICloser{ + err := types.CloseAll([]types.ICloser{ p.fIntServiceHTTP, p.fIncServiceHTTP, p.fState.GetWrapperDB(), }) + if err != nil { + return pkg_errors.WrapError(err, "close/stop all") + } + return nil } diff --git a/cmd/hidden_lake/messenger/internal/app/init_storage.go b/cmd/hidden_lake/messenger/internal/app/init_storage.go index 5f5e0842..a6d6a117 100644 --- a/cmd/hidden_lake/messenger/internal/app/init_storage.go +++ b/cmd/hidden_lake/messenger/internal/app/init_storage.go @@ -5,13 +5,18 @@ import ( "github.com/number571/go-peer/cmd/hidden_lake/messenger/internal/config" hlm_settings "github.com/number571/go-peer/cmd/hidden_lake/messenger/internal/settings" + "github.com/number571/go-peer/pkg/errors" "github.com/number571/go-peer/pkg/storage" ) func initCryptoStorage(pCfg config.IConfig, pPathTo string) (storage.IKeyValueStorage, error) { - return storage.NewCryptoStorage(storage.NewSettings(&storage.SSettings{ + stg, err := storage.NewCryptoStorage(storage.NewSettings(&storage.SSettings{ FPath: fmt.Sprintf("%s/%s", pPathTo, hlm_settings.CPathSTG), FWorkSize: hlm_settings.CWorkForKeys, FCipherKey: []byte(pCfg.GetStorageKey()), })) + if err != nil { + return nil, errors.WrapError(err, "new crypto storage") + } + return stg, nil } diff --git a/cmd/hidden_lake/messenger/internal/app/state/clear.go b/cmd/hidden_lake/messenger/internal/app/state/clear.go index cdd681cd..ef939cc8 100644 --- a/cmd/hidden_lake/messenger/internal/app/state/clear.go +++ b/cmd/hidden_lake/messenger/internal/app/state/clear.go @@ -3,25 +3,33 @@ package state import ( pkg_settings "github.com/number571/go-peer/cmd/hidden_lake/service/pkg/settings" "github.com/number571/go-peer/pkg/crypto/asymmetric" + "github.com/number571/go-peer/pkg/errors" ) func (p *sState) clearClientState() error { if err := p.clearClientPrivKey(); err != nil { - return err + return errors.WrapError(err, "clear client private key") } if err := p.clearClientFriends(); err != nil { - return err + return errors.WrapError(err, "clear client friends") } - return p.clearClientConnections() + if err := p.clearClientConnections(); err != nil { + return errors.WrapError(err, "clear client connections") + } + + return nil } func (p *sState) clearClientPrivKey() error { client := p.GetClient().Service() pseudoPrivKey := asymmetric.NewRSAPrivKey(pkg_settings.CAKeySize) - return client.SetPrivKey(pseudoPrivKey) + if err := client.SetPrivKey(pseudoPrivKey); err != nil { + return errors.WrapError(err, "set pseudo private key") + } + return nil } func (p *sState) clearClientFriends() error { @@ -29,12 +37,12 @@ func (p *sState) clearClientFriends() error { friends, err := client.GetFriends() if err != nil { - return err + return errors.WrapError(err, "get friends") } for aliasName := range friends { if err := client.DelFriend(aliasName); err != nil { - return err + return errors.WrapError(err, "del friend") } } @@ -46,11 +54,11 @@ func (p *sState) clearClientConnections() error { connects, err := client.GetConnections() if err != nil { - return err + return errors.WrapError(err, "get connections") } for _, conn := range connects { if err := client.DelConnection(conn); err != nil { - return err + return errors.WrapError(err, "del connection") } } diff --git a/cmd/hidden_lake/messenger/internal/app/state/state.go b/cmd/hidden_lake/messenger/internal/app/state/state.go index ceae7c8c..029c5f20 100644 --- a/cmd/hidden_lake/messenger/internal/app/state/state.go +++ b/cmd/hidden_lake/messenger/internal/app/state/state.go @@ -8,6 +8,7 @@ import ( "github.com/number571/go-peer/pkg/crypto/asymmetric" "github.com/number571/go-peer/pkg/crypto/entropy" "github.com/number571/go-peer/pkg/encoding" + "github.com/number571/go-peer/pkg/errors" "github.com/number571/go-peer/pkg/storage" hlm_settings "github.com/number571/go-peer/cmd/hidden_lake/messenger/internal/settings" @@ -80,9 +81,12 @@ func (p *sState) GetTemplate() *STemplateState { func (p *sState) CreateState(pHashLP []byte, pPrivKey asymmetric.IPrivKey) error { if _, err := p.GetStorage().Get(pHashLP); err == nil { - return fmt.Errorf("state already exists") + return errors.NewError("state already exists") } - return p.newStorageState(pHashLP, pPrivKey) + if err := p.newStorageState(pHashLP, pPrivKey); err != nil { + return errors.WrapError(err, "new storage state") + } + return nil } func (p *sState) UpdateState(pHashLP []byte) error { @@ -90,22 +94,26 @@ func (p *sState) UpdateState(pHashLP []byte) error { defer p.fMutex.Unlock() if p.IsActive() { - return fmt.Errorf("state already exists") + return errors.NewError("state already exists") } stateValue, err := p.getStorageState(pHashLP) if err != nil { - return err + return errors.WrapError(err, "get storage state") } entropyBooster := entropy.NewEntropyBooster(hlm_settings.CWorkForKeys, []byte{5, 7, 1}) - p.GetWrapperDB().Set(database.NewKeyValueDB( + db, err := database.NewKeyValueDB( fmt.Sprintf("%s/%s", p.fPathTo, hlm_settings.CPathDB), entropyBooster.BoostEntropy(pHashLP), - )) + ) + if err != nil { + return errors.WrapError(err, "open KV database") + } + p.GetWrapperDB().Set(db) if err := p.updateClientState(stateValue); err != nil { - return err + return errors.WrapError(err, "update client state") } p.fHashLP = pHashLP @@ -118,42 +126,50 @@ func (p *sState) ClearActiveState() error { defer p.fMutex.Unlock() if !p.IsActive() { - return fmt.Errorf("state does not exist") + return errors.NewError("state does not exist") } p.fHashLP = nil if err := p.GetWrapperDB().Close(); err != nil { - return err + return errors.WrapError(err, "close database") } if err := p.clearClientState(); err != nil { - return err + return errors.WrapError(err, "clear client state") } return nil } func (p *sState) AddFriend(pAliasName string, pPubKey asymmetric.IPubKey) error { - return p.stateUpdater( + err := p.stateUpdater( p.updateClientFriends, func(storageValue *SStorageState) { storageValue.FFriends[pAliasName] = pPubKey.ToString() }, ) + if err != nil { + return errors.WrapError(err, "add friend (state updater)") + } + return nil } func (p *sState) DelFriend(pAliasName string) error { - return p.stateUpdater( + err := p.stateUpdater( p.updateClientFriends, func(storageValue *SStorageState) { delete(storageValue.FFriends, pAliasName) }, ) + if err != nil { + return errors.WrapError(err, "del friend (state updater)") + } + return nil } func (p *sState) AddConnection(pConnect string) error { - return p.stateUpdater( + err := p.stateUpdater( p.updateClientConnections, func(storageValue *SStorageState) { storageValue.FConnections = append( @@ -162,10 +178,14 @@ func (p *sState) AddConnection(pConnect string) error { ) }, ) + if err != nil { + return errors.WrapError(err, "add connection (state updater)") + } + return nil } func (p *sState) DelConnection(pConnect string) error { - return p.stateUpdater( + err := p.stateUpdater( p.updateClientConnections, func(storageValue *SStorageState) { storageValue.FConnections = remove( @@ -174,6 +194,10 @@ func (p *sState) DelConnection(pConnect string) error { ) }, ) + if err != nil { + return errors.WrapError(err, "del connection (state updater)") + } + return nil } func (p *sState) IsActive() bool { @@ -184,26 +208,32 @@ func (p *sState) newStorageState(pHashLP []byte, pPrivKey asymmetric.IPrivKey) e stateValueBytes := encoding.Serialize(&SStorageState{ FPrivKey: pPrivKey.ToString(), }) - return p.GetStorage().Set(pHashLP, stateValueBytes) + if err := p.GetStorage().Set(pHashLP, stateValueBytes); err != nil { + return errors.WrapError(err, "new storage state") + } + return nil } func (p *sState) setStorageState(pStateValue *SStorageState) error { stateValueBytes := encoding.Serialize(pStateValue) - return p.GetStorage().Set(p.fHashLP, stateValueBytes) + if err := p.GetStorage().Set(p.fHashLP, stateValueBytes); err != nil { + return errors.WrapError(err, "update storage state") + } + return nil } func (p *sState) getStorageState(pHashLP []byte) (*SStorageState, error) { stateValueBytes, err := p.GetStorage().Get(pHashLP) if err != nil { - return nil, err + return nil, errors.WrapError(err, "get storage state") } var stateValue = new(SStorageState) if err := encoding.Deserialize(stateValueBytes, stateValue); err != nil { - return nil, err + return nil, errors.WrapError(err, "deserialize state") } - return stateValue, err + return stateValue, nil } func remove(pSlice []string, pElem string) []string { diff --git a/cmd/hidden_lake/messenger/internal/app/state/update.go b/cmd/hidden_lake/messenger/internal/app/state/update.go index 6b2a62e3..6373bbdf 100644 --- a/cmd/hidden_lake/messenger/internal/app/state/update.go +++ b/cmd/hidden_lake/messenger/internal/app/state/update.go @@ -1,22 +1,21 @@ package state import ( - "fmt" - "github.com/number571/go-peer/pkg/crypto/asymmetric" + "github.com/number571/go-peer/pkg/errors" ) func (p *sState) updateClientState(pStateValue *SStorageState) error { if err := p.updateClientPrivKey(pStateValue); err != nil { - return err + return errors.WrapError(err, "update client private key") } if err := p.updateClientFriends(pStateValue); err != nil { - return err + return errors.WrapError(err, "update client friends") } if err := p.updateClientConnections(pStateValue); err != nil { - return err + return errors.WrapError(err, "update client connections") } return nil @@ -26,28 +25,31 @@ func (p *sState) updateClientPrivKey(pStateValue *SStorageState) error { hlsClient := p.GetClient().Service() if err := p.clearClientPrivKey(); err != nil { - return err + return errors.WrapError(err, "clear client private key") } privKey := asymmetric.LoadRSAPrivKey(pStateValue.FPrivKey) if privKey == nil { - return fmt.Errorf("private key is null") + return errors.NewError("private key is null") } - return hlsClient.SetPrivKey(privKey) + if err := hlsClient.SetPrivKey(privKey); err != nil { + return errors.WrapError(err, "set private key") + } + return nil } func (p *sState) updateClientFriends(pStateValue *SStorageState) error { client := p.GetClient().Service() if err := p.clearClientFriends(); err != nil { - return err + return errors.WrapError(err, "clear client friends") } for aliasName, pubKeyString := range pStateValue.FFriends { pubKey := asymmetric.LoadRSAPubKey(pubKeyString) if err := client.AddFriend(aliasName, pubKey); err != nil { - return err + return errors.WrapError(err, "add friend") } } @@ -58,12 +60,12 @@ func (p *sState) updateClientConnections(pStateValue *SStorageState) error { client := p.GetClient().Service() if err := p.clearClientConnections(); err != nil { - return err + return errors.WrapError(err, "clear client connections") } for _, conn := range pStateValue.FConnections { if err := client.AddConnection(conn); err != nil { - return err + return errors.WrapError(err, "add connections") } } @@ -76,7 +78,7 @@ func (p *sState) updateClientTraffic(pStateValue *SStorageState) error { hashes, err := hltClient.GetHashes() if err != nil { - return err + return errors.WrapError(err, "get hashes") } for _, hash := range hashes { diff --git a/cmd/hidden_lake/messenger/internal/app/state/updater.go b/cmd/hidden_lake/messenger/internal/app/state/updater.go index 61c5d91d..58e0cef8 100644 --- a/cmd/hidden_lake/messenger/internal/app/state/updater.go +++ b/cmd/hidden_lake/messenger/internal/app/state/updater.go @@ -1,6 +1,6 @@ package state -import "fmt" +import "github.com/number571/go-peer/pkg/errors" func (p *sState) stateUpdater( clientUpdater func(storageValue *SStorageState) error, @@ -10,22 +10,28 @@ func (p *sState) stateUpdater( defer p.fMutex.Unlock() if !p.IsActive() { - return fmt.Errorf("state does not exist") + return errors.NewError("state does not exist") } oldStorageValue, err := p.getStorageState(p.fHashLP) if err != nil { - return err + return errors.WrapError(err, "get old storage state") } newStorageValue := copyStorageState(oldStorageValue) middleWare(newStorageValue) if err := clientUpdater(newStorageValue); err == nil { - return p.setStorageState(newStorageValue) + if err := p.setStorageState(newStorageValue); err != nil { + return errors.WrapError(err, "get new storage state") + } + return nil } - return p.setStorageState(oldStorageValue) + if err := p.setStorageState(oldStorageValue); err != nil { + return errors.WrapError(err, "update state (old -> new)") + } + return nil } func copyStorageState(pStorageValue *SStorageState) *SStorageState { diff --git a/cmd/hidden_lake/messenger/internal/config/config.go b/cmd/hidden_lake/messenger/internal/config/config.go index 32bc924a..f9a09906 100644 --- a/cmd/hidden_lake/messenger/internal/config/config.go +++ b/cmd/hidden_lake/messenger/internal/config/config.go @@ -4,6 +4,7 @@ import ( "fmt" "github.com/number571/go-peer/pkg/encoding" + "github.com/number571/go-peer/pkg/errors" "github.com/number571/go-peer/pkg/filesystem" "github.com/number571/go-peer/pkg/logger" ) @@ -39,15 +40,15 @@ func BuildConfig(pFilepath string, pCfg *SConfig) (IConfig, error) { configFile := filesystem.OpenFile(pFilepath) if configFile.IsExist() { - return nil, fmt.Errorf("config file '%s' already exist", pFilepath) + return nil, errors.NewError(fmt.Sprintf("config file '%s' already exist", pFilepath)) } if err := configFile.Write(encoding.Serialize(pCfg)); err != nil { - return nil, err + return nil, errors.WrapError(err, "write config") } if err := pCfg.loadLogging(); err != nil { - return nil, err + return nil, errors.WrapError(err, "load logging") } return pCfg, nil } @@ -56,21 +57,21 @@ func LoadConfig(pFilepath string) (IConfig, error) { configFile := filesystem.OpenFile(pFilepath) if !configFile.IsExist() { - return nil, fmt.Errorf("config file '%s' does not exist", pFilepath) + return nil, errors.NewError(fmt.Sprintf("config file '%s' does not exist", pFilepath)) } bytes, err := configFile.Read() if err != nil { - return nil, err + return nil, errors.WrapError(err, "read config") } cfg := new(SConfig) if err := encoding.Deserialize(bytes, cfg); err != nil { - return nil, err + return nil, errors.WrapError(err, "deserialize config") } if err := cfg.loadLogging(); err != nil { - return nil, err + return nil, errors.WrapError(err, "load logging") } return cfg, nil } @@ -88,7 +89,7 @@ func (p *SConfig) loadLogging() error { for _, v := range p.FLogging { logType, ok := mapping[v] if !ok { - return fmt.Errorf("undefined log type '%s'", v) + return errors.NewError(fmt.Sprintf("undefined log type '%s'", v)) } logging[logType] = true } diff --git a/cmd/hidden_lake/messenger/internal/database/database.go b/cmd/hidden_lake/messenger/internal/database/database.go index 64f13fe1..329e1588 100644 --- a/cmd/hidden_lake/messenger/internal/database/database.go +++ b/cmd/hidden_lake/messenger/internal/database/database.go @@ -1,10 +1,10 @@ package database import ( - "fmt" "sync" "github.com/number571/go-peer/pkg/encoding" + "github.com/number571/go-peer/pkg/errors" gp_database "github.com/number571/go-peer/pkg/storage/database" ) @@ -13,7 +13,7 @@ type sKeyValueDB struct { fDB *gp_database.IKeyValueDB } -func NewKeyValueDB(pPath string, pKey []byte) IKeyValueDB { +func NewKeyValueDB(pPath string, pKey []byte) (IKeyValueDB, error) { db, err := gp_database.NewSQLiteDB( gp_database.NewSettings(&gp_database.SSettings{ FPath: pPath, @@ -22,11 +22,11 @@ func NewKeyValueDB(pPath string, pKey []byte) IKeyValueDB { }), ) if err != nil { - return nil + return nil, errors.WrapError(err, "new sqlite") } return &sKeyValueDB{ fDB: &db, - } + }, nil } func (p *sKeyValueDB) Size(pR IRelation) uint64 { @@ -41,23 +41,23 @@ func (p *sKeyValueDB) Load(pR IRelation, pStart, pEnd uint64) ([]IMessage, error defer p.fMutex.Unlock() if pStart > pEnd { - return nil, fmt.Errorf("start > end") + return nil, errors.NewError("start > end") } size := p.getSize(pR) if pEnd > size { - return nil, fmt.Errorf("end > size") + return nil, errors.NewError("end > size") } res := make([]IMessage, 0, pEnd-pStart) for i := pStart; i < pEnd; i++ { data, err := (*p.fDB).Get(getKeyMessageByEnum(pR, i)) if err != nil { - return nil, fmt.Errorf("message undefined") + return nil, errors.WrapError(err, "message undefined") } msg := LoadMessage(data) if msg == nil { - return nil, fmt.Errorf("message is null") + return nil, errors.NewError("message is null") } res = append(res, msg) } @@ -69,31 +69,35 @@ func (p *sKeyValueDB) Push(pR IRelation, pMsg IMessage) error { p.fMutex.Lock() defer p.fMutex.Unlock() - _, err := (*p.fDB).Get(getKeyMessageByHash(pR, pMsg.GetSHA256UID())) - if err == nil { - return fmt.Errorf("message is already exist") + if _, err := (*p.fDB).Get(getKeyMessageByHash(pR, pMsg.GetSHA256UID())); err == nil { + return errors.WrapError(err, "message is already exist") } - err = (*p.fDB).Set(getKeyMessageByHash(pR, pMsg.GetSHA256UID()), []byte{1}) - if err != nil { - return err + if err := (*p.fDB).Set(getKeyMessageByHash(pR, pMsg.GetSHA256UID()), []byte{1}); err != nil { + return errors.WrapError(err, "set uid to database") } size := p.getSize(pR) - err = (*p.fDB).Set(getKeyMessageByEnum(pR, size), pMsg.ToBytes()) - if err != nil { - return err + numBytes := encoding.Uint64ToBytes(size + 1) + if err := (*p.fDB).Set(getKeySize(pR), numBytes[:]); err != nil { + return errors.WrapError(err, "set size of message to database") } - numBytes := encoding.Uint64ToBytes(size + 1) - return (*p.fDB).Set(getKeySize(pR), numBytes[:]) + if err := (*p.fDB).Set(getKeyMessageByEnum(pR, size), pMsg.ToBytes()); err != nil { + return errors.WrapError(err, "set message to database") + } + + return nil } func (p *sKeyValueDB) Close() error { p.fMutex.Lock() defer p.fMutex.Unlock() - return (*p.fDB).Close() + if err := (*p.fDB).Close(); err != nil { + return errors.WrapError(err, "close KV database") + } + return nil } func (p *sKeyValueDB) getSize(pR IRelation) uint64 { diff --git a/cmd/hidden_lake/messenger/internal/database/wrapper.go b/cmd/hidden_lake/messenger/internal/database/wrapper.go index d91e6c18..bceed8e0 100644 --- a/cmd/hidden_lake/messenger/internal/database/wrapper.go +++ b/cmd/hidden_lake/messenger/internal/database/wrapper.go @@ -3,6 +3,7 @@ package database import ( "sync" + "github.com/number571/go-peer/pkg/errors" "github.com/number571/go-peer/pkg/wrapper" ) @@ -49,5 +50,8 @@ func (p *sWrapperDB) Close() error { } p.fWrapper.Set(nil) - return db.Close() + if err := db.Close(); err != nil { + return errors.WrapError(err, "close database wrapper") + } + return nil } diff --git a/cmd/hidden_lake/service/cmd/hls/init_app.go b/cmd/hidden_lake/service/cmd/hls/init_app.go index 0f20d5ba..b9be404d 100644 --- a/cmd/hidden_lake/service/cmd/hls/init_app.go +++ b/cmd/hidden_lake/service/cmd/hls/init_app.go @@ -2,10 +2,10 @@ package main import ( "flag" - "fmt" "github.com/number571/go-peer/cmd/hidden_lake/service/pkg/app" "github.com/number571/go-peer/pkg/crypto/asymmetric" + "github.com/number571/go-peer/pkg/errors" "github.com/number571/go-peer/pkg/filesystem" "github.com/number571/go-peer/pkg/types" @@ -29,18 +29,18 @@ func initApp() (types.ICommand, error) { default: privKeyStr, err := filesystem.OpenFile(inputKey).Read() if err != nil { - return nil, err + return nil, errors.WrapError(err, "read public key") } privKey = asymmetric.LoadRSAPrivKey(string(privKeyStr)) } if privKey == nil { - return nil, fmt.Errorf("private key is invalid") + return nil, errors.NewError("private key is invalid") } cfg, err := pkg_config.InitConfig(pkg_settings.CPathCFG, nil) if err != nil { - return nil, err + return nil, errors.WrapError(err, "init config") } return app.NewApp(cfg, privKey, "."), nil diff --git a/cmd/hidden_lake/service/cmd/m_hls/init_app.go b/cmd/hidden_lake/service/cmd/m_hls/init_app.go index 609f76a9..44b9fdeb 100644 --- a/cmd/hidden_lake/service/cmd/m_hls/init_app.go +++ b/cmd/hidden_lake/service/cmd/m_hls/init_app.go @@ -5,6 +5,7 @@ import ( "github.com/number571/go-peer/cmd/hidden_lake/service/pkg/app" "github.com/number571/go-peer/pkg/crypto/asymmetric" + "github.com/number571/go-peer/pkg/errors" "github.com/number571/go-peer/pkg/types" pkg_config "github.com/number571/go-peer/cmd/hidden_lake/service/pkg/config" @@ -19,7 +20,7 @@ const ( func initApp(pPathTo string) (types.ICommand, error) { privKey := asymmetric.NewRSAPrivKey(pkg_settings.CAKeySize) if privKey == nil { - return nil, fmt.Errorf("private key is invalid") + return nil, errors.NewError("private key is invalid") } cfg, err := pkg_config.InitConfig( @@ -33,7 +34,7 @@ func initApp(pPathTo string) (types.ICommand, error) { }, ) if err != nil { - return nil, err + return nil, errors.WrapError(err, "init config") } return app.NewApp(cfg, privKey, pPathTo), nil diff --git a/cmd/hidden_lake/service/pkg/app/app.go b/cmd/hidden_lake/service/pkg/app/app.go index b7c3f0f9..384b636e 100644 --- a/cmd/hidden_lake/service/pkg/app/app.go +++ b/cmd/hidden_lake/service/pkg/app/app.go @@ -18,6 +18,7 @@ import ( "github.com/number571/go-peer/cmd/hidden_lake/service/internal/handler" pkg_settings "github.com/number571/go-peer/cmd/hidden_lake/service/pkg/settings" internal_logger "github.com/number571/go-peer/internal/logger" + pkg_errors "github.com/number571/go-peer/pkg/errors" ) const ( @@ -61,13 +62,13 @@ func (p *sApp) Run() error { defer p.fMutex.Unlock() if p.fIsRun { - return errors.New("application already running") + return pkg_errors.NewError("application already running") } p.fIsRun = true p.initServiceHTTP() if err := p.initDatabase(); err != nil { - return err + return pkg_errors.WrapError(err, "init database") } res := make(chan error) @@ -112,7 +113,7 @@ func (p *sApp) Run() error { // run node in server mode err := p.fNode.GetNetworkNode().Run() - if err != nil && !errors.Is(err, net.ErrClosed) { + if err != nil && !pkg_errors.HasError(err, net.ErrClosed) { res <- err return } @@ -120,8 +121,7 @@ func (p *sApp) Run() error { select { case err := <-res: - p.Stop() - return err + return pkg_errors.AppendError(pkg_errors.WrapError(err, "got run error"), p.Stop()) case <-time.After(cInitStart): p.fLogger.PushInfo(fmt.Sprintf("%s is running...", pkg_settings.CServiceName)) return nil @@ -133,25 +133,25 @@ func (p *sApp) Stop() error { defer p.fMutex.Unlock() if !p.fIsRun { - return errors.New("application already stopped or not started") + return pkg_errors.NewError("application already stopped or not started") } p.fIsRun = false p.fLogger.PushInfo(fmt.Sprintf("%s is shutting down...", pkg_settings.CServiceName)) p.fNode.HandleFunc(pkg_settings.CServiceMask, nil) - lastErr := types.StopAll([]types.ICommand{ - p.fNode, - p.fConnKeeper, - p.fNode.GetNetworkNode(), - }) - - err := types.CloseAll([]types.ICloser{ - p.fServiceHTTP, - p.fNode.GetWrapperDB(), - }) + err := pkg_errors.AppendError( + types.StopAll([]types.ICommand{ + p.fNode, + p.fConnKeeper, + p.fNode.GetNetworkNode(), + }), + types.CloseAll([]types.ICloser{ + p.fServiceHTTP, + p.fNode.GetWrapperDB(), + }), + ) if err != nil { - lastErr = err + return pkg_errors.WrapError(err, "close/stop all") } - - return lastErr + return nil } diff --git a/cmd/hidden_lake/service/pkg/app/init_database.go b/cmd/hidden_lake/service/pkg/app/init_database.go index d0d785d0..76cd7f07 100644 --- a/cmd/hidden_lake/service/pkg/app/init_database.go +++ b/cmd/hidden_lake/service/pkg/app/init_database.go @@ -4,6 +4,7 @@ import ( "fmt" pkg_settings "github.com/number571/go-peer/cmd/hidden_lake/service/pkg/settings" + "github.com/number571/go-peer/pkg/errors" "github.com/number571/go-peer/pkg/storage/database" ) @@ -16,7 +17,7 @@ func (p *sApp) initDatabase() error { }), ) if err != nil { - return err + return errors.WrapError(err, "new sqlitedb") } p.fNode.GetWrapperDB().Set(db) return nil diff --git a/cmd/hidden_lake/service/pkg/client/client.go b/cmd/hidden_lake/service/pkg/client/client.go index 46a2cb4d..d0214e78 100644 --- a/cmd/hidden_lake/service/pkg/client/client.go +++ b/cmd/hidden_lake/service/pkg/client/client.go @@ -5,6 +5,7 @@ import ( "github.com/number571/go-peer/cmd/hidden_lake/service/pkg/response" "github.com/number571/go-peer/pkg/client/message" "github.com/number571/go-peer/pkg/crypto/asymmetric" + "github.com/number571/go-peer/pkg/errors" ) var ( @@ -24,57 +25,105 @@ func NewClient(pBuilder IBuilder, pRequester IRequester) IClient { } func (p *sClient) GetIndex() (string, error) { - return p.fRequester.GetIndex() + res, err := p.fRequester.GetIndex() + if err != nil { + return "", errors.WrapError(err, "get index (client)") + } + return res, nil } func (p *sClient) HandleMessage(pMsg message.IMessage) error { - return p.fRequester.HandleMessage(p.fBuilder.Message(pMsg)) + if err := p.fRequester.HandleMessage(p.fBuilder.Message(pMsg)); err != nil { + return errors.WrapError(err, "handle message (client)") + } + return nil } func (p *sClient) BroadcastRequest(pRecv asymmetric.IPubKey, pData request.IRequest) error { - return p.fRequester.BroadcastRequest(p.fBuilder.Request(pRecv, pData)) + if err := p.fRequester.BroadcastRequest(p.fBuilder.Request(pRecv, pData)); err != nil { + return errors.WrapError(err, "broadcast request (client)") + } + return nil } func (p *sClient) FetchRequest(pRecv asymmetric.IPubKey, pData request.IRequest) (response.IResponse, error) { - return p.fRequester.FetchRequest(p.fBuilder.Request(pRecv, pData)) + res, err := p.fRequester.FetchRequest(p.fBuilder.Request(pRecv, pData)) + if err != nil { + return nil, errors.WrapError(err, "fetch request (client)") + } + return res, nil } func (p *sClient) GetFriends() (map[string]asymmetric.IPubKey, error) { - return p.fRequester.GetFriends() + res, err := p.fRequester.GetFriends() + if err != nil { + return nil, errors.WrapError(err, "get friends (client)") + } + return res, nil } func (p *sClient) AddFriend(pAliasName string, pPubKey asymmetric.IPubKey) error { - return p.fRequester.AddFriend(p.fBuilder.Friend(pAliasName, pPubKey)) + if err := p.fRequester.AddFriend(p.fBuilder.Friend(pAliasName, pPubKey)); err != nil { + return errors.WrapError(err, "add friend (client)") + } + return nil } func (p *sClient) DelFriend(pAliasName string) error { - return p.fRequester.DelFriend(p.fBuilder.Friend(pAliasName, nil)) + if err := p.fRequester.DelFriend(p.fBuilder.Friend(pAliasName, nil)); err != nil { + return errors.WrapError(err, "del friend (client)") + } + return nil } func (p *sClient) GetOnlines() ([]string, error) { - return p.fRequester.GetOnlines() + res, err := p.fRequester.GetOnlines() + if err != nil { + return nil, errors.WrapError(err, "get onlines (client)") + } + return res, nil } func (p *sClient) DelOnline(pConnect string) error { - return p.fRequester.DelOnline(p.fBuilder.Connect(pConnect)) + if err := p.fRequester.DelOnline(p.fBuilder.Connect(pConnect)); err != nil { + return errors.WrapError(err, "del online (client)") + } + return nil } func (p *sClient) GetConnections() ([]string, error) { - return p.fRequester.GetConnections() + res, err := p.fRequester.GetConnections() + if err != nil { + return nil, errors.WrapError(err, "get connections (client)") + } + return res, nil } func (p *sClient) AddConnection(pConnect string) error { - return p.fRequester.AddConnection(p.fBuilder.Connect(pConnect)) + if err := p.fRequester.AddConnection(p.fBuilder.Connect(pConnect)); err != nil { + return errors.WrapError(err, "add connection (client)") + } + return nil } func (p *sClient) DelConnection(pConnect string) error { - return p.fRequester.DelConnection(p.fBuilder.Connect(pConnect)) + if err := p.fRequester.DelConnection(p.fBuilder.Connect(pConnect)); err != nil { + return errors.WrapError(err, "del connection (client)") + } + return nil } func (p *sClient) SetPrivKey(pPrivKey asymmetric.IPrivKey) error { - return p.fRequester.SetPrivKey(p.fBuilder.SetPrivKey(pPrivKey)) + if err := p.fRequester.SetPrivKey(p.fBuilder.SetPrivKey(pPrivKey)); err != nil { + return errors.WrapError(err, "set private key (client)") + } + return nil } func (p *sClient) GetPubKey() (asymmetric.IPubKey, error) { - return p.fRequester.GetPubKey() + res, err := p.fRequester.GetPubKey() + if err != nil { + return nil, errors.WrapError(err, "get public key (client)") + } + return res, nil } diff --git a/cmd/hidden_lake/service/pkg/client/requester.go b/cmd/hidden_lake/service/pkg/client/requester.go index f5e96e26..b9f752f2 100644 --- a/cmd/hidden_lake/service/pkg/client/requester.go +++ b/cmd/hidden_lake/service/pkg/client/requester.go @@ -9,6 +9,7 @@ import ( pkg_settings "github.com/number571/go-peer/cmd/hidden_lake/service/pkg/settings" "github.com/number571/go-peer/internal/api" "github.com/number571/go-peer/pkg/crypto/asymmetric" + "github.com/number571/go-peer/pkg/errors" ) var ( @@ -35,11 +36,11 @@ func (p *sRequester) GetIndex() (string, error) { nil, ) if err != nil { - return "", err + return "", errors.WrapError(err, "get index (requester)") } if res != pkg_settings.CTitlePattern { - return "", fmt.Errorf("incorrect title pattern") + return "", errors.NewError("incorrect title pattern") } return res, nil } @@ -51,7 +52,10 @@ func (p *sRequester) HandleMessage(pMsg pkg_settings.SMessage) error { fmt.Sprintf(pkg_settings.CHandleNetworkMessageTemplate, p.fHost), pMsg, ) - return err + if err != nil { + return errors.WrapError(err, "handle message (requester)") + } + return nil } func (p *sRequester) FetchRequest(pRequest *pkg_settings.SRequest) (response.IResponse, error) { @@ -62,9 +66,14 @@ func (p *sRequester) FetchRequest(pRequest *pkg_settings.SRequest) (response.IRe pRequest, ) if err != nil { - return nil, err + return nil, errors.WrapError(err, "fetch request (requester)") } - return response.LoadResponse([]byte(res)) + + resp, err := response.LoadResponse([]byte(res)) + if err != nil { + return nil, errors.WrapError(err, "load fetch response (requester)") + } + return resp, nil } func (p *sRequester) BroadcastRequest(pRequest *pkg_settings.SRequest) error { @@ -74,7 +83,10 @@ func (p *sRequester) BroadcastRequest(pRequest *pkg_settings.SRequest) error { fmt.Sprintf(pkg_settings.CHandleNetworkRequestTemplate, p.fHost), pRequest, ) - return err + if err != nil { + return errors.WrapError(err, "broadcast request (requester)") + } + return nil } func (p *sRequester) GetFriends() (map[string]asymmetric.IPubKey, error) { @@ -85,7 +97,7 @@ func (p *sRequester) GetFriends() (map[string]asymmetric.IPubKey, error) { nil, ) if err != nil { - return nil, err + return nil, errors.WrapError(err, "get friends (requester)") } listFriends := deleteVoidStrings(strings.Split(res, ",")) @@ -93,7 +105,7 @@ func (p *sRequester) GetFriends() (map[string]asymmetric.IPubKey, error) { for _, friend := range listFriends { splited := strings.Split(friend, ":") if len(splited) != 2 { - return nil, fmt.Errorf("length of splited != 2") + return nil, errors.NewError("length of splited != 2") } aliasName := splited[0] pubKeyStr := splited[1] @@ -109,7 +121,10 @@ func (p *sRequester) AddFriend(pFriend *pkg_settings.SFriend) error { fmt.Sprintf(pkg_settings.CHandleConfigFriendsTemplate, p.fHost), pFriend, ) - return err + if err != nil { + return errors.WrapError(err, "add friend (requester)") + } + return nil } func (p *sRequester) DelFriend(pFriend *pkg_settings.SFriend) error { @@ -119,7 +134,10 @@ func (p *sRequester) DelFriend(pFriend *pkg_settings.SFriend) error { fmt.Sprintf(pkg_settings.CHandleConfigFriendsTemplate, p.fHost), pFriend, ) - return err + if err != nil { + return errors.WrapError(err, "del friend (requester)") + } + return nil } func (p *sRequester) GetOnlines() ([]string, error) { @@ -130,7 +148,7 @@ func (p *sRequester) GetOnlines() ([]string, error) { nil, ) if err != nil { - return nil, err + return nil, errors.WrapError(err, "get onlines (requester)") } return deleteVoidStrings(strings.Split(res, ",")), nil } @@ -142,7 +160,10 @@ func (p *sRequester) DelOnline(pConnect pkg_settings.SConnect) error { fmt.Sprintf(pkg_settings.CHandleNetworkOnlineTemplate, p.fHost), pConnect, ) - return err + if err != nil { + return errors.WrapError(err, "del online (requester)") + } + return nil } func (p *sRequester) GetConnections() ([]string, error) { @@ -153,7 +174,7 @@ func (p *sRequester) GetConnections() ([]string, error) { nil, ) if err != nil { - return nil, err + return nil, errors.WrapError(err, "get connections (requester)") } return deleteVoidStrings(strings.Split(res, ",")), nil } @@ -165,7 +186,10 @@ func (p *sRequester) AddConnection(pConnect pkg_settings.SConnect) error { fmt.Sprintf(pkg_settings.CHandleConfigConnectsTemplate, p.fHost), pConnect, ) - return err + if err != nil { + return errors.WrapError(err, "add connection (requester)") + } + return nil } func (p *sRequester) DelConnection(pConnect pkg_settings.SConnect) error { @@ -175,7 +199,10 @@ func (p *sRequester) DelConnection(pConnect pkg_settings.SConnect) error { fmt.Sprintf(pkg_settings.CHandleConfigConnectsTemplate, p.fHost), pConnect, ) - return err + if err != nil { + return errors.WrapError(err, "del connection (requester)") + } + return nil } func (p *sRequester) SetPrivKey(pPrivKey pkg_settings.SPrivKey) error { @@ -185,7 +212,10 @@ func (p *sRequester) SetPrivKey(pPrivKey pkg_settings.SPrivKey) error { fmt.Sprintf(pkg_settings.CHandleNodeKeyTemplate, p.fHost), pPrivKey, ) - return err + if err != nil { + return errors.WrapError(err, "set private key (requester)") + } + return nil } func (p *sRequester) GetPubKey() (asymmetric.IPubKey, error) { @@ -196,9 +226,13 @@ func (p *sRequester) GetPubKey() (asymmetric.IPubKey, error) { nil, ) if err != nil { - return nil, err + return nil, errors.WrapError(err, "get public key (requester)") } - return asymmetric.LoadRSAPubKey(res), nil + pubKey := asymmetric.LoadRSAPubKey(res) + if pubKey == nil { + return nil, errors.NewError("got invalid public key") + } + return pubKey, nil } func deleteVoidStrings(pS []string) []string { diff --git a/cmd/hidden_lake/service/pkg/config/config.go b/cmd/hidden_lake/service/pkg/config/config.go index c820b932..2ad6fa4f 100644 --- a/cmd/hidden_lake/service/pkg/config/config.go +++ b/cmd/hidden_lake/service/pkg/config/config.go @@ -7,6 +7,7 @@ import ( pkg_settings "github.com/number571/go-peer/cmd/hidden_lake/service/pkg/settings" "github.com/number571/go-peer/pkg/crypto/asymmetric" "github.com/number571/go-peer/pkg/encoding" + "github.com/number571/go-peer/pkg/errors" "github.com/number571/go-peer/pkg/filesystem" "github.com/number571/go-peer/pkg/logger" ) @@ -48,15 +49,15 @@ type SAddress struct { func BuildConfig(pFilepath string, pCfg *SConfig) (IConfig, error) { configFile := filesystem.OpenFile(pFilepath) if configFile.IsExist() { - return nil, fmt.Errorf("config file '%s' already exist", pFilepath) + return nil, errors.NewError(fmt.Sprintf("config file '%s' already exist", pFilepath)) } if err := configFile.Write(encoding.Serialize(pCfg)); err != nil { - return nil, err + return nil, errors.WrapError(err, "write config") } if err := pCfg.initConfig(pFilepath); err != nil { - return nil, err + return nil, errors.WrapError(err, "init config") } return pCfg, nil } @@ -65,21 +66,21 @@ func LoadConfig(pFilepath string) (IConfig, error) { configFile := filesystem.OpenFile(pFilepath) if !configFile.IsExist() { - return nil, fmt.Errorf("config file '%s' does not exist", pFilepath) + return nil, errors.NewError(fmt.Sprintf("config file '%s' does not exist", pFilepath)) } bytes, err := configFile.Read() if err != nil { - return nil, err + return nil, errors.WrapError(err, "read config") } cfg := new(SConfig) if err := encoding.Deserialize(bytes, cfg); err != nil { - return nil, err + return nil, errors.WrapError(err, "deserialize config") } if err := cfg.initConfig(pFilepath); err != nil { - return nil, err + return nil, errors.WrapError(err, "init config") } return cfg, nil } @@ -88,11 +89,11 @@ func (p *SConfig) initConfig(filepath string) error { p.fFilepath = filepath if err := p.loadPubKeys(); err != nil { - return err + return errors.WrapError(err, "load public keys") } if err := p.loadLogging(); err != nil { - return err + return errors.WrapError(err, "load logging") } return nil @@ -111,7 +112,7 @@ func (p *SConfig) loadLogging() error { for _, v := range p.FLogging { logType, ok := mapping[v] if !ok { - return fmt.Errorf("undefined log type '%s'", v) + return errors.NewError(fmt.Sprintf("undefined log type '%s'", v)) } logging[logType] = true } @@ -130,11 +131,11 @@ func (p *SConfig) loadPubKeys() error { } pubKey := asymmetric.LoadRSAPubKey(val) if pubKey == nil { - return fmt.Errorf("public key is nil for '%s'", name) + return errors.NewError(fmt.Sprintf("public key is nil for '%s'", name)) } p.fFriends[name] = pubKey if pubKey.GetSize() != pkg_settings.CAKeySize { - return fmt.Errorf("not supported key size for '%s'", name) + return errors.NewError(fmt.Sprintf("not supported key size for '%s'", name)) } } diff --git a/cmd/hidden_lake/service/pkg/config/editor.go b/cmd/hidden_lake/service/pkg/config/editor.go index 3c7578df..9d5b07c0 100644 --- a/cmd/hidden_lake/service/pkg/config/editor.go +++ b/cmd/hidden_lake/service/pkg/config/editor.go @@ -7,6 +7,7 @@ import ( pkg_settings "github.com/number571/go-peer/cmd/hidden_lake/service/pkg/settings" "github.com/number571/go-peer/pkg/crypto/asymmetric" "github.com/number571/go-peer/pkg/encoding" + "github.com/number571/go-peer/pkg/errors" "github.com/number571/go-peer/pkg/filesystem" ) @@ -39,14 +40,14 @@ func (p *sEditor) UpdateConnections(pConns []string) error { filepath := p.fConfig.fFilepath icfg, err := LoadConfig(filepath) if err != nil { - return err + return errors.WrapError(err, "load config (update connections)") } cfg := icfg.(*SConfig) cfg.FConnections = deleteDuplicateStrings(pConns) err = filesystem.OpenFile(filepath).Write(encoding.Serialize(cfg)) if err != nil { - return err + return errors.WrapError(err, "write config (update connections)") } p.fConfig.fMutex.Lock() @@ -64,13 +65,13 @@ func (p *sEditor) UpdateFriends(pFriends map[string]asymmetric.IPubKey) error { if pubKey.GetSize() == pkg_settings.CAKeySize { continue } - return fmt.Errorf("not supported key size for '%s'", name) + return errors.NewError(fmt.Sprintf("not supported key size for '%s'", name)) } filepath := p.fConfig.fFilepath icfg, err := LoadConfig(filepath) if err != nil { - return err + return errors.WrapError(err, "load config (update friends)") } cfg := icfg.(*SConfig) @@ -78,7 +79,7 @@ func (p *sEditor) UpdateFriends(pFriends map[string]asymmetric.IPubKey) error { cfg.FFriends = pubKeysToStrings(pFriends) err = filesystem.OpenFile(filepath).Write(encoding.Serialize(cfg)) if err != nil { - return err + return errors.WrapError(err, "write config (update friends)") } p.fConfig.fMutex.Lock() diff --git a/cmd/hidden_lake/service/pkg/config/init.go b/cmd/hidden_lake/service/pkg/config/init.go index 33857fb7..91bbdcb5 100644 --- a/cmd/hidden_lake/service/pkg/config/init.go +++ b/cmd/hidden_lake/service/pkg/config/init.go @@ -2,12 +2,17 @@ package config import ( "github.com/number571/go-peer/internal/logger" + "github.com/number571/go-peer/pkg/errors" "github.com/number571/go-peer/pkg/filesystem" ) func InitConfig(cfgPath string, initCfg *SConfig) (IConfig, error) { if filesystem.OpenFile(cfgPath).IsExist() { - return LoadConfig(cfgPath) + cfg, err := LoadConfig(cfgPath) + if err != nil { + return nil, errors.WrapError(err, "load config by cfgPath") + } + return cfg, nil } if initCfg == nil { initCfg = &SConfig{ @@ -18,5 +23,9 @@ func InitConfig(cfgPath string, initCfg *SConfig) (IConfig, error) { }, } } - return BuildConfig(cfgPath, initCfg) + cfg, err := BuildConfig(cfgPath, initCfg) + if err != nil { + return nil, errors.WrapError(err, "build config by cfgPath") + } + return cfg, nil } diff --git a/cmd/hidden_lake/service/pkg/request/request.go b/cmd/hidden_lake/service/pkg/request/request.go index dc41a590..e5da6a3c 100644 --- a/cmd/hidden_lake/service/pkg/request/request.go +++ b/cmd/hidden_lake/service/pkg/request/request.go @@ -2,6 +2,7 @@ package request import ( "github.com/number571/go-peer/pkg/encoding" + "github.com/number571/go-peer/pkg/errors" ) var ( @@ -26,8 +27,10 @@ func NewRequest(pMethod, pHost, pPath string) IRequest { func LoadRequest(pData []byte) (IRequest, error) { request := new(sRequest) - err := encoding.Deserialize(pData, request) - return request, err + if err := encoding.Deserialize(pData, request); err != nil { + return nil, errors.WrapError(err, "load request") + } + return request, nil } func (p *sRequest) ToBytes() []byte { diff --git a/cmd/hidden_lake/service/pkg/response/response.go b/cmd/hidden_lake/service/pkg/response/response.go index 61cf0f13..d9b4fc26 100644 --- a/cmd/hidden_lake/service/pkg/response/response.go +++ b/cmd/hidden_lake/service/pkg/response/response.go @@ -1,6 +1,9 @@ package response -import "github.com/number571/go-peer/pkg/encoding" +import ( + "github.com/number571/go-peer/pkg/encoding" + "github.com/number571/go-peer/pkg/errors" +) var ( _ IResponse = &sResponse{} @@ -20,8 +23,10 @@ func NewResponse(pCode int) IResponse { func LoadResponse(pBytes []byte) (IResponse, error) { response := new(sResponse) - err := encoding.Deserialize(pBytes, response) - return response, err + if err := encoding.Deserialize(pBytes, response); err != nil { + return nil, errors.WrapError(err, "load response") + } + return response, nil } func (p *sResponse) ToBytes() []byte { diff --git a/cmd/hidden_lake/traffic/cmd/hlt/init_app.go b/cmd/hidden_lake/traffic/cmd/hlt/init_app.go index 7bf31015..b1cbc196 100644 --- a/cmd/hidden_lake/traffic/cmd/hlt/init_app.go +++ b/cmd/hidden_lake/traffic/cmd/hlt/init_app.go @@ -5,13 +5,14 @@ import ( "github.com/number571/go-peer/cmd/hidden_lake/traffic/internal/config" "github.com/number571/go-peer/cmd/hidden_lake/traffic/pkg/settings" + "github.com/number571/go-peer/pkg/errors" "github.com/number571/go-peer/pkg/types" ) func initApp() (types.ICommand, error) { cfg, err := config.InitConfig(settings.CPathCFG, nil) if err != nil { - return nil, err + return nil, errors.WrapError(err, "init config") } return app.NewApp(cfg, "."), nil diff --git a/cmd/hidden_lake/traffic/cmd/m_hlt/init_app.go b/cmd/hidden_lake/traffic/cmd/m_hlt/init_app.go index 767cd89f..f9ea8f07 100644 --- a/cmd/hidden_lake/traffic/cmd/m_hlt/init_app.go +++ b/cmd/hidden_lake/traffic/cmd/m_hlt/init_app.go @@ -4,6 +4,7 @@ import ( "fmt" "github.com/number571/go-peer/cmd/hidden_lake/traffic/internal/app" + "github.com/number571/go-peer/pkg/errors" "github.com/number571/go-peer/pkg/types" pkg_config "github.com/number571/go-peer/cmd/hidden_lake/traffic/internal/config" @@ -24,7 +25,7 @@ func initApp(pPathTo string) (types.ICommand, error) { }, ) if err != nil { - return nil, err + return nil, errors.WrapError(err, "init config") } return app.NewApp(cfg, pPathTo), nil } diff --git a/cmd/hidden_lake/traffic/internal/app/app.go b/cmd/hidden_lake/traffic/internal/app/app.go index 8dfb5521..b21e0f9d 100644 --- a/cmd/hidden_lake/traffic/internal/app/app.go +++ b/cmd/hidden_lake/traffic/internal/app/app.go @@ -15,6 +15,7 @@ import ( pkg_settings "github.com/number571/go-peer/cmd/hidden_lake/traffic/pkg/settings" internal_logger "github.com/number571/go-peer/internal/logger" + pkg_errors "github.com/number571/go-peer/pkg/errors" ) const ( @@ -58,7 +59,7 @@ func (p *sApp) Run() error { defer p.fMutex.Unlock() if p.fIsRun { - return errors.New("application already running") + return pkg_errors.NewError("application already running") } p.fIsRun = true @@ -90,8 +91,7 @@ func (p *sApp) Run() error { select { case err := <-res: - p.Stop() - return err + return pkg_errors.AppendError(pkg_errors.WrapError(err, "got run error"), p.Stop()) case <-time.After(cInitStart): p.fLogger.PushInfo(fmt.Sprintf("%s is running...", pkg_settings.CServiceName)) return nil @@ -103,23 +103,23 @@ func (p *sApp) Stop() error { defer p.fMutex.Unlock() if !p.fIsRun { - return errors.New("application already stopped or not started") + return pkg_errors.NewError("application already stopped or not started") } p.fIsRun = false p.fLogger.PushInfo(fmt.Sprintf("%s is shutting down...", pkg_settings.CServiceName)) - lastErr := types.StopAll([]types.ICommand{ - p.fConnKeeper, - p.fConnKeeper.GetNetworkNode(), - }) - - err := types.CloseAll([]types.ICloser{ - p.fServiceHTTP, - p.fWrapperDB, - }) + err := pkg_errors.AppendError( + types.StopAll([]types.ICommand{ + p.fConnKeeper, + p.fConnKeeper.GetNetworkNode(), + }), + types.CloseAll([]types.ICloser{ + p.fServiceHTTP, + p.fWrapperDB, + }), + ) if err != nil { - lastErr = err + return pkg_errors.WrapError(err, "close/stop all") } - - return lastErr + return nil } diff --git a/cmd/hidden_lake/traffic/internal/app/init_database.go b/cmd/hidden_lake/traffic/internal/app/init_database.go index 957a9b1f..ea787cb7 100644 --- a/cmd/hidden_lake/traffic/internal/app/init_database.go +++ b/cmd/hidden_lake/traffic/internal/app/init_database.go @@ -4,6 +4,7 @@ import ( "fmt" "github.com/number571/go-peer/cmd/hidden_lake/traffic/internal/database" + "github.com/number571/go-peer/pkg/errors" hls_settings "github.com/number571/go-peer/cmd/hidden_lake/service/pkg/settings" hlt_settings "github.com/number571/go-peer/cmd/hidden_lake/traffic/pkg/settings" @@ -19,7 +20,7 @@ func (p *sApp) initDatabase() error { }), ) if err != nil { - return err + return errors.WrapError(err, "init database") } p.fWrapperDB.Set(db) return nil diff --git a/cmd/hidden_lake/traffic/internal/config/config.go b/cmd/hidden_lake/traffic/internal/config/config.go index b26ea7aa..4befd641 100644 --- a/cmd/hidden_lake/traffic/internal/config/config.go +++ b/cmd/hidden_lake/traffic/internal/config/config.go @@ -4,6 +4,7 @@ import ( "fmt" "github.com/number571/go-peer/pkg/encoding" + "github.com/number571/go-peer/pkg/errors" "github.com/number571/go-peer/pkg/filesystem" "github.com/number571/go-peer/pkg/logger" ) @@ -29,15 +30,15 @@ func BuildConfig(pFilepath string, pCfg *SConfig) (IConfig, error) { configFile := filesystem.OpenFile(pFilepath) if configFile.IsExist() { - return nil, fmt.Errorf("config file '%s' already exist", pFilepath) + return nil, errors.NewError(fmt.Sprintf("config file '%s' already exist", pFilepath)) } if err := configFile.Write(encoding.Serialize(pCfg)); err != nil { - return nil, err + return nil, errors.WrapError(err, "write config") } if err := pCfg.loadLogging(); err != nil { - return nil, err + return nil, errors.WrapError(err, "load logging") } return pCfg, nil } @@ -46,21 +47,21 @@ func LoadConfig(pFilepath string) (IConfig, error) { configFile := filesystem.OpenFile(pFilepath) if !configFile.IsExist() { - return nil, fmt.Errorf("config file '%s' does not exist", pFilepath) + return nil, errors.NewError(fmt.Sprintf("config file '%s' does not exist", pFilepath)) } bytes, err := configFile.Read() if err != nil { - return nil, err + return nil, errors.WrapError(err, "read config") } cfg := new(SConfig) if err := encoding.Deserialize(bytes, cfg); err != nil { - return nil, err + return nil, errors.WrapError(err, "deserialize config") } if err := cfg.loadLogging(); err != nil { - return nil, err + return nil, errors.WrapError(err, "load logging") } return cfg, nil } @@ -78,7 +79,7 @@ func (p *SConfig) loadLogging() error { for _, v := range p.FLogging { logType, ok := mapping[v] if !ok { - return fmt.Errorf("undefined log type '%s'", v) + return errors.NewError(fmt.Sprintf("undefined log type '%s'", v)) } logging[logType] = true } diff --git a/cmd/hidden_lake/traffic/internal/config/init.go b/cmd/hidden_lake/traffic/internal/config/init.go index 62557720..ca97cb42 100644 --- a/cmd/hidden_lake/traffic/internal/config/init.go +++ b/cmd/hidden_lake/traffic/internal/config/init.go @@ -2,12 +2,17 @@ package config import ( "github.com/number571/go-peer/internal/logger" + "github.com/number571/go-peer/pkg/errors" "github.com/number571/go-peer/pkg/filesystem" ) func InitConfig(cfgPath string, initCfg *SConfig) (IConfig, error) { if filesystem.OpenFile(cfgPath).IsExist() { - return LoadConfig(cfgPath) + cfg, err := LoadConfig(cfgPath) + if err != nil { + return nil, errors.WrapError(err, "load config") + } + return cfg, nil } if initCfg == nil { initCfg = &SConfig{ @@ -16,5 +21,9 @@ func InitConfig(cfgPath string, initCfg *SConfig) (IConfig, error) { FConnection: "localhost:9571", } } - return BuildConfig(cfgPath, initCfg) + cfg, err := BuildConfig(cfgPath, initCfg) + if err != nil { + return nil, errors.WrapError(err, "build config") + } + return cfg, nil } diff --git a/cmd/hidden_lake/traffic/internal/database/database.go b/cmd/hidden_lake/traffic/internal/database/database.go index 8ada0fa5..15115148 100644 --- a/cmd/hidden_lake/traffic/internal/database/database.go +++ b/cmd/hidden_lake/traffic/internal/database/database.go @@ -1,12 +1,12 @@ package database import ( - "fmt" "sync" "github.com/number571/go-peer/pkg/client/message" "github.com/number571/go-peer/pkg/crypto/hashing" "github.com/number571/go-peer/pkg/encoding" + "github.com/number571/go-peer/pkg/errors" gp_database "github.com/number571/go-peer/pkg/storage/database" ) @@ -27,17 +27,17 @@ func NewKeyValueDB(pSett ISettings) (IKeyValueDB, error) { }), ) if err != nil { - return nil, err + return nil, errors.WrapError(err, "new sqlite") } if sqlDB == nil { - return nil, fmt.Errorf("storage (hashes) is nil") + return nil, errors.NewError("storage (hashes) is nil") } db := &sKeyValueDB{ fSettings: pSett, fDB: sqlDB, } db.fPointer = db.getPointer() - return db, err + return db, nil } func (p *sKeyValueDB) Settings() ISettings { @@ -56,7 +56,7 @@ func (p *sKeyValueDB) Hashes() ([]string, error) { break } if len(hash) != hashing.CSHA256Size { - return nil, fmt.Errorf("incorrect hash size") + return nil, errors.NewError("incorrect hash size") } res = append(res, encoding.HexEncode(hash)) } @@ -78,7 +78,7 @@ func (p *sKeyValueDB) Push(pMsg message.IMessage) error { FMessageSize: p.Settings().GetMessageSize(), }) if !pMsg.IsValid(params) { - return fmt.Errorf("invalid push message") + return errors.NewError("invalid push message") } // delete old message @@ -86,25 +86,25 @@ func (p *sKeyValueDB) Push(pMsg message.IMessage) error { if hash, err := p.fDB.Get(keyHash); err == nil { keyMsg := getKeyMessage(hash) if err := p.fDB.Del(keyMsg); err != nil { - return err + return errors.WrapError(err, "delete old key") } } // rewrite hash's field newHash := pMsg.GetBody().GetHash() if err := p.fDB.Set(keyHash, newHash); err != nil { - return err + return errors.WrapError(err, "rewrite key hash") } // write message keyMsg := getKeyMessage(newHash) if err := p.fDB.Set(keyMsg, pMsg.ToBytes()); err != nil { - return err + return errors.WrapError(err, "write message") } // update pointer if err := p.incPointer(); err != nil { - return err + return errors.WrapError(err, "increment pointer") } return nil @@ -116,12 +116,12 @@ func (p *sKeyValueDB) Load(pStrHash string) (message.IMessage, error) { hash := encoding.HexDecode(pStrHash) if len(hash) != hashing.CSHA256Size { - return nil, fmt.Errorf("key size invalid") + return nil, errors.NewError("key size invalid") } data, err := p.fDB.Get(getKeyMessage(hash)) if err != nil { - return nil, fmt.Errorf("message undefined") + return nil, errors.NewError("message undefined") } msg := message.LoadMessage( @@ -142,7 +142,10 @@ func (p *sKeyValueDB) Close() error { p.fMutex.Lock() defer p.fMutex.Unlock() - return p.fDB.Close() + if err := p.fDB.Close(); err != nil { + return errors.WrapError(err, "close KV database") + } + return nil } func (p *sKeyValueDB) getPointer() uint64 { @@ -159,5 +162,8 @@ func (p *sKeyValueDB) getPointer() uint64 { func (p *sKeyValueDB) incPointer() error { msgsLimit := p.Settings().GetCapacity() res := encoding.Uint64ToBytes((p.getPointer() + 1) % msgsLimit) - return p.fDB.Set(getKeyPointer(), res[:]) + if err := p.fDB.Set(getKeyPointer(), res[:]); err != nil { + return errors.WrapError(err, "set pointer into KV database") + } + return nil } diff --git a/cmd/hidden_lake/traffic/internal/database/wrapper.go b/cmd/hidden_lake/traffic/internal/database/wrapper.go index d91e6c18..0cb3a347 100644 --- a/cmd/hidden_lake/traffic/internal/database/wrapper.go +++ b/cmd/hidden_lake/traffic/internal/database/wrapper.go @@ -3,6 +3,7 @@ package database import ( "sync" + "github.com/number571/go-peer/pkg/errors" "github.com/number571/go-peer/pkg/wrapper" ) @@ -49,5 +50,8 @@ func (p *sWrapperDB) Close() error { } p.fWrapper.Set(nil) - return db.Close() + if err := db.Close(); err != nil { + return errors.WrapError(err, "close wrapped database") + } + return nil } diff --git a/cmd/hidden_lake/traffic/pkg/client/client.go b/cmd/hidden_lake/traffic/pkg/client/client.go index 5b21fa65..e8921028 100644 --- a/cmd/hidden_lake/traffic/pkg/client/client.go +++ b/cmd/hidden_lake/traffic/pkg/client/client.go @@ -2,6 +2,7 @@ package client import ( "github.com/number571/go-peer/pkg/client/message" + "github.com/number571/go-peer/pkg/errors" ) var ( @@ -21,21 +22,32 @@ func NewClient(pBuilder IBuilder, pRequester IRequester) IClient { } func (p *sClient) GetIndex() (string, error) { - return p.fRequester.GetIndex() + res, err := p.fRequester.GetIndex() + if err != nil { + return "", errors.WrapError(err, "get index (client)") + } + return res, nil } func (p *sClient) GetHashes() ([]string, error) { - return p.fRequester.GetHashes() + res, err := p.fRequester.GetHashes() + if err != nil { + return nil, errors.WrapError(err, "get hashes (client)") + } + return res, nil } func (p *sClient) GetMessage(pHash string) (message.IMessage, error) { msg, err := p.fRequester.GetMessage(p.fBuilder.GetMessage(pHash)) if err != nil { - return nil, err + return nil, errors.WrapError(err, "get message (client)") } return msg, nil } func (p *sClient) PutMessage(pMsg message.IMessage) error { - return p.fRequester.PutMessage(p.fBuilder.PutMessage(pMsg)) + if err := p.fRequester.PutMessage(p.fBuilder.PutMessage(pMsg)); err != nil { + return errors.WrapError(err, "put message (client)") + } + return nil } diff --git a/cmd/hidden_lake/traffic/pkg/client/requester.go b/cmd/hidden_lake/traffic/pkg/client/requester.go index ea2f841e..1bc5140a 100644 --- a/cmd/hidden_lake/traffic/pkg/client/requester.go +++ b/cmd/hidden_lake/traffic/pkg/client/requester.go @@ -9,6 +9,7 @@ import ( "github.com/number571/go-peer/internal/api" "github.com/number571/go-peer/pkg/client/message" "github.com/number571/go-peer/pkg/encoding" + "github.com/number571/go-peer/pkg/errors" ) var ( @@ -37,11 +38,10 @@ func (p *sRequester) GetIndex() (string, error) { nil, ) if err != nil { - return "", err + return "", errors.WrapError(err, "get index (requester)") } - if resp != pkg_settings.CTitlePattern { - return "", fmt.Errorf("incorrect title pattern") + return "", errors.NewError("incorrect title pattern") } return resp, nil } @@ -54,7 +54,7 @@ func (p *sRequester) GetHashes() ([]string, error) { nil, ) if err != nil { - return nil, err + return nil, errors.WrapError(err, "get hashes (requester)") } return strings.Split(resp, ";"), nil } @@ -67,7 +67,7 @@ func (p *sRequester) GetMessage(pRequest string) (message.IMessage, error) { nil, ) if err != nil { - return nil, err + return nil, errors.WrapError(err, "get message (requester)") } msg := message.LoadMessage( @@ -78,7 +78,7 @@ func (p *sRequester) GetMessage(pRequest string) (message.IMessage, error) { encoding.HexDecode(resp), ) if msg == nil { - return nil, fmt.Errorf("message is nil") + return nil, errors.NewError("load message") } return msg, nil @@ -91,5 +91,8 @@ func (p *sRequester) PutMessage(pRequest string) error { fmt.Sprintf(pkg_settings.CHandleMessageTemplate, p.fHost), pRequest, ) - return err + if err != nil { + return errors.WrapError(err, "put message (requester)") + } + return nil } diff --git a/internal/api/request.go b/internal/api/request.go index 2aacf83c..604ec472 100644 --- a/internal/api/request.go +++ b/internal/api/request.go @@ -6,6 +6,8 @@ import ( "fmt" "io" "net/http" + + "github.com/number571/go-peer/pkg/errors" ) func Request(pClient *http.Client, pMethod, pURL string, pData interface{}) (string, error) { @@ -19,7 +21,7 @@ func Request(pClient *http.Client, pMethod, pURL string, pData interface{}) (str default: jsonValue, err := json.Marshal(pData) if err != nil { - return "", err + return "", errors.WrapError(err, "marshal request") } requestBytes = jsonValue } @@ -30,28 +32,32 @@ func Request(pClient *http.Client, pMethod, pURL string, pData interface{}) (str bytes.NewBuffer(requestBytes), ) if err != nil { - return "", err + return "", errors.WrapError(err, "new request") } req.Header.Set("Content-Type", CContentType) resp, err := pClient.Do(req) if err != nil { - return "", err + return "", errors.WrapError(err, "do request") } defer resp.Body.Close() - return loadResponse(resp.StatusCode, resp.Body) + result, err := loadResponse(resp.StatusCode, resp.Body) + if err != nil { + return "", errors.WrapError(err, "load response") + } + return result, nil } func loadResponse(pStatusCode int, pReader io.ReadCloser) (string, error) { resp, err := io.ReadAll(pReader) if err != nil { - return "", err + return "", errors.WrapError(err, "read response") } result := string(resp) if pStatusCode != http.StatusOK { - return "", fmt.Errorf("error code = %d (%s)", pStatusCode, result) + return "", errors.NewError(fmt.Sprintf("error code = %d (%s)", pStatusCode, result)) } return result, nil diff --git a/internal/mobile/mobile.go b/internal/mobile/mobile.go index 308f709d..1464d57c 100644 --- a/internal/mobile/mobile.go +++ b/internal/mobile/mobile.go @@ -2,6 +2,7 @@ package mobile import ( "fyne.io/fyne/v2" + "github.com/number571/go-peer/pkg/errors" ) var ( @@ -70,13 +71,13 @@ func (p *sMobileState) doDefault() error { case true: if p.fConstructApp != nil { if err := p.fConstructApp(); err != nil { - return err + return errors.WrapError(err, "construct app") } } case false: if p.fDestructApp != nil { if err := p.fDestructApp(); err != nil { - return err + return errors.WrapError(err, "destruct app") } } } diff --git a/internal/mobile/openurl.go b/internal/mobile/openurl.go index 699ff949..dfeec711 100644 --- a/internal/mobile/openurl.go +++ b/internal/mobile/openurl.go @@ -4,12 +4,16 @@ import ( "net/url" "fyne.io/fyne/v2" + "github.com/number571/go-peer/pkg/errors" ) func OpenURL(pApp fyne.App, pPageURL string) error { u, err := url.Parse(pPageURL) if err != nil { - return err + return errors.WrapError(err, "parse url") } - return pApp.OpenURL(u) + if err := pApp.OpenURL(u); err != nil { + return errors.WrapError(err, "open url") + } + return nil } diff --git a/pkg/client/client.go b/pkg/client/client.go index b0d9fb92..64de8a05 100644 --- a/pkg/client/client.go +++ b/pkg/client/client.go @@ -11,6 +11,7 @@ import ( "github.com/number571/go-peer/pkg/crypto/random" "github.com/number571/go-peer/pkg/crypto/symmetric" "github.com/number571/go-peer/pkg/encoding" + "github.com/number571/go-peer/pkg/errors" "github.com/number571/go-peer/pkg/payload" ) @@ -64,7 +65,7 @@ func (p *sClient) GetSettings() message.ISettings { // The message can be decrypted only if private key is known. func (p *sClient) EncryptPayload(pRecv asymmetric.IPubKey, pPld payload.IPayload) (message.IMessage, error) { if pRecv.GetSize() != p.GetPubKey().GetSize() { - return nil, fmt.Errorf("size of public keys sender and receiver not equal") + return nil, errors.NewError("size of public keys sender and receiver not equal") } var ( @@ -73,11 +74,11 @@ func (p *sClient) EncryptPayload(pRecv asymmetric.IPubKey, pPld payload.IPayload ) if resultSize > maxMsgSize { - return nil, fmt.Errorf( + return nil, errors.NewError(fmt.Sprintf( "limit of message size without hex encoding = %d bytes < current payload size with additional padding = %d bytes", maxMsgSize, resultSize, - ) + )) } return p.encryptWithParams( @@ -137,57 +138,57 @@ func (p *sClient) encryptWithParams(pRecv asymmetric.IPubKey, pPld payload.IPayl // No one else except the sender will be able to decrypt the message. func (p *sClient) DecryptMessage(pMsg message.IMessage) (asymmetric.IPubKey, payload.IPayload, error) { if pMsg == nil { - return nil, nil, fmt.Errorf("msg is nil") + return nil, nil, errors.NewError("msg is nil") } // Initial check. if len(pMsg.GetBody().GetHash()) != hashing.CSHA256Size { - return nil, nil, fmt.Errorf("msg hash != sha256 size") + return nil, nil, errors.NewError("msg hash != sha256 size") } // Proof of work. Prevent spam. diff := p.GetSettings().GetWorkSize() puzzle := puzzle.NewPoWPuzzle(diff) if !puzzle.VerifyBytes(pMsg.GetBody().GetHash(), pMsg.GetBody().GetProof()) { - return nil, nil, fmt.Errorf("invalid proof of msg") + return nil, nil, errors.NewError("invalid proof of msg") } // Decrypt session key by private key of receiver. session := p.GetPrivKey().DecryptBytes(pMsg.GetHead().GetSession()) if session == nil { - return nil, nil, fmt.Errorf("failed decrypt session key") + return nil, nil, errors.NewError("failed decrypt session key") } // Decrypt public key of sender by decrypted session key. cipher := symmetric.NewAESCipher(session) publicBytes := cipher.DecryptBytes(pMsg.GetHead().GetSender()) if publicBytes == nil { - return nil, nil, fmt.Errorf("failed decrypt public key") + return nil, nil, errors.NewError("failed decrypt public key") } // Load public key and check standart size. pubKey := asymmetric.LoadRSAPubKey(publicBytes) if pubKey == nil { - return nil, nil, fmt.Errorf("failed load public key") + return nil, nil, errors.NewError("failed load public key") } if pubKey.GetSize() != p.GetPubKey().GetSize() { - return nil, nil, fmt.Errorf("invalid public key size") + return nil, nil, errors.NewError("invalid public key size") } // Decrypt main data of message by session key. doublePayloadBytes := cipher.DecryptBytes(pMsg.GetBody().GetPayload().ToBytes()) if doublePayloadBytes == nil { - return nil, nil, fmt.Errorf("failed decrypt double payload") + return nil, nil, errors.NewError("failed decrypt double payload") } doublePayload := payload.LoadPayload(doublePayloadBytes) if doublePayload == nil { - return nil, nil, fmt.Errorf("failed load double payload") + return nil, nil, errors.NewError("failed load double payload") } // Decrypt salt. salt := cipher.DecryptBytes(pMsg.GetHead().GetSalt()) if salt == nil { - return nil, nil, fmt.Errorf("failed decrypt salt") + return nil, nil, errors.NewError("failed decrypt salt") } // Check received hash and generated hash. @@ -200,27 +201,27 @@ func (p *sClient) DecryptMessage(pMsg message.IMessage) (asymmetric.IPubKey, pay []byte{}, )).ToBytes() if !bytes.Equal(check, pMsg.GetBody().GetHash()) { - return nil, nil, fmt.Errorf("invalid msg hash") + return nil, nil, errors.NewError("invalid msg hash") } // Decrypt sign of message and verify this // by public key of sender and hash of message. sign := cipher.DecryptBytes(pMsg.GetBody().GetSign()) if sign == nil { - return nil, nil, fmt.Errorf("failed decrypt sign") + return nil, nil, errors.NewError("failed decrypt sign") } if !pubKey.VerifyBytes(pMsg.GetBody().GetHash(), sign) { - return nil, nil, fmt.Errorf("invalid msg sign") + return nil, nil, errors.NewError("invalid msg sign") } // Remove random bytes and get main data mustLen := doublePayload.GetHead() if mustLen > uint64(len(doublePayload.GetBody())) { - return nil, nil, fmt.Errorf("invalid size of payload") + return nil, nil, errors.NewError("invalid size of payload") } pld := payload.LoadPayload(doublePayload.GetBody()[:mustLen]) if pld == nil { - return nil, nil, fmt.Errorf("invalid load payload") + return nil, nil, errors.NewError("invalid load payload") } // Return decrypted message with title diff --git a/pkg/client/queue/queue.go b/pkg/client/queue/queue.go index b74f572e..10140468 100644 --- a/pkg/client/queue/queue.go +++ b/pkg/client/queue/queue.go @@ -1,12 +1,12 @@ package queue import ( - "errors" "sync" "time" "github.com/number571/go-peer/pkg/client" "github.com/number571/go-peer/pkg/client/message" + "github.com/number571/go-peer/pkg/errors" "github.com/number571/go-peer/pkg/payload" ) @@ -63,7 +63,7 @@ func (p *sMessageQueue) Run() error { defer p.fMutex.Unlock() if p.fIsRun { - return errors.New("queue already running") + return errors.NewError("queue already running") } p.fIsRun = true @@ -91,7 +91,7 @@ func (p *sMessageQueue) Stop() error { defer p.fMutex.Unlock() if !p.fIsRun { - return errors.New("queue already closed or not started") + return errors.NewError("queue already closed or not started") } p.fIsRun = false @@ -104,7 +104,7 @@ func (p *sMessageQueue) EnqueueMessage(pMsg message.IMessage) error { defer p.fMutex.Unlock() if uint64(len(p.fQueue)) >= p.GetSettings().GetMainCapacity() { - return errors.New("queue already full, need wait and retry") + return errors.NewError("queue already full, need wait and retry") } p.fQueue <- pMsg diff --git a/pkg/encoding/serialize.go b/pkg/encoding/serialize.go index 2028e2df..ccaf3c5e 100644 --- a/pkg/encoding/serialize.go +++ b/pkg/encoding/serialize.go @@ -1,6 +1,10 @@ package encoding -import "encoding/json" +import ( + "encoding/json" + + "github.com/number571/go-peer/pkg/errors" +) func Serialize(pData interface{}) []byte { res, err := json.Marshal(pData) @@ -11,5 +15,8 @@ func Serialize(pData interface{}) []byte { } func Deserialize(pData []byte, pRes interface{}) error { - return json.Unmarshal(pData, pRes) + if err := json.Unmarshal(pData, pRes); err != nil { + return errors.WrapError(err, "unmarshal data") + } + return nil } diff --git a/pkg/errors/errors.go b/pkg/errors/errors.go new file mode 100644 index 00000000..2736520f --- /dev/null +++ b/pkg/errors/errors.go @@ -0,0 +1,83 @@ +package errors + +import ( + std_errors "errors" + "fmt" + "strings" +) + +var ( + _ error = &sError{} +) + +type sError struct { + fErrStack []error +} + +func (p *sError) Error() string { + s := "" + for i := len(p.fErrStack) - 1; i >= 0; i-- { + s += fmt.Sprintf("%s; ", p.fErrStack[i].Error()) + } + return strings.TrimSpace(s) +} + +func NewError(pMsg string) error { + return WrapError(nil, pMsg) +} + +func WrapError(pErr error, pMsg string) error { + return AppendError(pErr, std_errors.New(pMsg)) +} + +func AppendError(pErr, pErr2 error) error { + if pErr == nil && pErr2 == nil { + return nil + } + if pErr == nil { + if _, ok := pErr2.(*sError); ok { + return pErr2 + } + return &sError{[]error{pErr2}} + } + if pErr2 == nil { + if _, ok := pErr.(*sError); ok { + return pErr + } + return &sError{[]error{pErr}} + } + v, ok := pErr.(*sError) + if ok { + return &sError{copyAndAppend(v.fErrStack, pErr2)} + } + return &sError{[]error{pErr, pErr2}} +} + +func HasError(pErr, pErrType error) bool { + if pErr == nil { + return false + } + v, ok := pErr.(*sError) + if !ok { + return std_errors.Is(pErr, pErrType) + } + for i := len(v.fErrStack) - 1; i >= 0; i-- { + vErr, ok := v.fErrStack[i].(*sError) + if ok { + if exist := HasError(vErr, pErrType); exist { + return true + } + continue + } + if std_errors.Is(v.fErrStack[i], pErrType) { + return true + } + } + return false +} + +func copyAndAppend(slice []error, val error) []error { + newSlice := make([]error, len(slice)) + copy(newSlice[:], slice) + return append(newSlice, val) +} diff --git a/pkg/errors/errors_test.go b/pkg/errors/errors_test.go new file mode 100644 index 00000000..3a81216f --- /dev/null +++ b/pkg/errors/errors_test.go @@ -0,0 +1,70 @@ +package errors + +import ( + "fmt" + "testing" +) + +const ( + tcErrorResult = "test_3; test_2; test_1;" +) + +type tsErrType1 struct{} +type tsErrType2 struct{} +type tsErrType3 struct{} +type tsErrType4 struct{} + +func (p *tsErrType1) Error() string { + return "1" +} + +func (p *tsErrType2) Error() string { + return "2" +} + +func (p *tsErrType3) Error() string { + return "3" +} + +func (p *tsErrType4) Error() string { + return "4" +} + +func TestWrapError(t *testing.T) { + err := WrapError(WrapError(NewError("test_1"), "test_2"), "test_3") + if err.Error() != tcErrorResult { + t.Error("result .Error() is invalid") + } + + if WrapError(nil, "test_1").Error() != NewError("test_1").Error() { + fmt.Println(WrapError(nil, "test_1").Error()) + fmt.Println(NewError("test_1").Error()) + t.Error("wrap error not equal new error") + } +} + +func TestAppendError(t *testing.T) { + err1 := AppendError(AppendError(&tsErrType1{}, &tsErrType2{}), &tsErrType3{}) + if !HasError(err1, &tsErrType1{}) || !HasError(err1, &tsErrType2{}) || !HasError(err1, &tsErrType3{}) { + t.Error("has not error (1, 2 or 3)") + } + if HasError(err1, &tsErrType4{}) { + t.Error("has error (4)") + } + + if err := AppendError(nil, nil); err != nil { + t.Error("err2 is not nil") + } + if err := AppendError(&tsErrType1{}, nil); !HasError(err, &tsErrType1{}) { + t.Error("invalid error type") + } + if err := AppendError(nil, &tsErrType1{}); !HasError(err, &tsErrType1{}) { + t.Error("invalid error type") + } + + err2 := AppendError(nil, &tsErrType1{}) + err3 := AppendError(nil, &tsErrType2{}) + if err := AppendError(&tsErrType3{}, AppendError(err2, err3)); !HasError(err, &tsErrType2{}) { + t.Error("not found error in error stack") + } +} diff --git a/pkg/filesystem/file.go b/pkg/filesystem/file.go index 151d0b81..87a44f07 100644 --- a/pkg/filesystem/file.go +++ b/pkg/filesystem/file.go @@ -2,6 +2,8 @@ package filesystem import ( "os" + + "github.com/number571/go-peer/pkg/errors" ) var ( @@ -21,13 +23,16 @@ func OpenFile(pPath string) IFile { func (p *sFile) Read() ([]byte, error) { data, err := os.ReadFile(p.fPath) if err != nil { - return nil, err + return nil, errors.WrapError(err, "read file") } return data, nil } func (p *sFile) Write(pData []byte) error { - return os.WriteFile(p.fPath, pData, 0644) + if err := os.WriteFile(p.fPath, pData, 0644); err != nil { + return errors.WrapError(err, "write file") + } + return nil } func (p *sFile) IsExist() bool { diff --git a/pkg/network/anonymity/anonymity.go b/pkg/network/anonymity/anonymity.go index 932f6e98..f93d5925 100644 --- a/pkg/network/anonymity/anonymity.go +++ b/pkg/network/anonymity/anonymity.go @@ -1,7 +1,6 @@ package anonymity import ( - "errors" "fmt" "strings" "sync" @@ -11,6 +10,7 @@ import ( "github.com/number571/go-peer/pkg/client/queue" "github.com/number571/go-peer/pkg/crypto/asymmetric" "github.com/number571/go-peer/pkg/crypto/random" + "github.com/number571/go-peer/pkg/errors" "github.com/number571/go-peer/pkg/logger" "github.com/number571/go-peer/pkg/network" "github.com/number571/go-peer/pkg/network/conn" @@ -60,22 +60,24 @@ func NewNode( func (p *sNode) Run() error { logger := anon_logger.NewLogger(p.GetSettings().GetServiceName()) if err := p.runQueue(logger); err != nil { - return err + return errors.WrapError(err, "run node") } - p.GetNetworkNode().HandleFunc( p.GetSettings().GetNetworkMask(), p.handleWrapper(logger), ) - return nil } func (p *sNode) Stop() error { p.GetNetworkNode().HandleFunc(p.GetSettings().GetNetworkMask(), nil) - return types.StopAll([]types.ICommand{ + err := types.StopAll([]types.ICommand{ p.GetMessageQueue(), }) + if err != nil { + return errors.WrapError(err, "stop node") + } + return nil } func (p *sNode) GetLogger() logger.ILogger { @@ -118,12 +120,15 @@ func (p *sNode) HandleFunc(pHead uint32, pHandle IHandlerF) INode { // Send message without response waiting. func (p *sNode) BroadcastPayload(pRecv asymmetric.IPubKey, pPld adapters.IPayload) error { - return p.broadcastPayload(cIsRequest, pRecv, pPld.ToOrigin()) + if err := p.broadcastPayload(cIsRequest, pRecv, pPld.ToOrigin()); err != nil { + return errors.WrapError(err, "broadcast payload") + } + return nil } func (p *sNode) broadcastPayload(pType iDataType, pRecv asymmetric.IPubKey, pPld payload.IPayload) error { if len(p.GetNetworkNode().GetConnections()) == 0 { - return errors.New("length of connections = 0") + return errors.NewError("length of connections = 0") } var newBody []byte @@ -133,16 +138,19 @@ func (p *sNode) broadcastPayload(pType iDataType, pRecv asymmetric.IPubKey, pPld case cIsResponse: newBody = wrapResponse(pPld.GetBody()) default: - return fmt.Errorf("unknown format type") + return errors.NewError("unknown format type") } newPld := payload.NewPayload(pPld.GetHead(), newBody) msg, err := p.GetMessageQueue().GetClient().EncryptPayload(pRecv, newPld) if err != nil { - return err + return errors.WrapError(err, "encrypt payload") } - return p.send(msg) + if err := p.send(msg); err != nil { + return errors.WrapError(err, "send message") + } + return nil } // Send message with response waiting. @@ -160,9 +168,14 @@ func (p *sNode) FetchPayload(pRecv asymmetric.IPubKey, pPld adapters.IPayload) ( defer p.delAction(actionKey) if err := p.broadcastPayload(cIsRequest, pRecv, newPld); err != nil { - return nil, err + return nil, errors.WrapError(err, "fetch payload") } - return p.recv(actionKey) + + resp, err := p.recv(actionKey) + if err != nil { + return nil, errors.WrapError(err, "receive response from fetch") + } + return resp, nil } func (p *sNode) send(pMsg message.IMessage) error { @@ -173,28 +186,28 @@ func (p *sNode) send(pMsg message.IMessage) error { } return nil } - return fmt.Errorf("failed: enqueue message") + return errors.NewError("enqueue message as send") } func (p *sNode) recv(pActionKey string) ([]byte, error) { action, ok := p.getAction(pActionKey) if !ok { - return nil, errors.New("action undefined") + return nil, errors.NewError("action undefined") } select { case result, opened := <-action: if !opened { - return nil, errors.New("chan is closed") + return nil, errors.NewError("chan is closed") } return result, nil case <-time.After(p.GetSettings().GetFetchTimeWait()): - return nil, errors.New("time is over") + return nil, errors.NewError("recv time is over") } } func (p *sNode) runQueue(pLogger anon_logger.ILogger) error { if err := p.GetMessageQueue().Run(); err != nil { - return err + return errors.WrapError(err, "run queue") } go func() { @@ -363,12 +376,16 @@ func (p *sNode) storeHashWithBroadcast(pLogger anon_logger.ILogger, pConn conn.I func (p *sNode) networkBroadcast(pLogger anon_logger.ILogger, pMsg message.IMessage) error { // redirect message to another nodes - return p.GetNetworkNode().BroadcastPayload( + err := p.GetNetworkNode().BroadcastPayload( payload.NewPayload( p.GetSettings().GetNetworkMask(), pMsg.ToBytes(), ), ) + if err != nil { + return errors.WrapError(err, "network broadcast payload") + } + return nil } func (p *sNode) setRoute(pHead uint32, pHandle IHandlerF) { diff --git a/pkg/network/conn/conn.go b/pkg/network/conn/conn.go index 06dcf4bc..ad03815b 100644 --- a/pkg/network/conn/conn.go +++ b/pkg/network/conn/conn.go @@ -2,7 +2,6 @@ package conn import ( "bytes" - "fmt" "net" "sync" "time" @@ -10,6 +9,7 @@ import ( "github.com/number571/go-peer/pkg/crypto/random" "github.com/number571/go-peer/pkg/crypto/symmetric" "github.com/number571/go-peer/pkg/encoding" + "github.com/number571/go-peer/pkg/errors" "github.com/number571/go-peer/pkg/network/message" "github.com/number571/go-peer/pkg/payload" ) @@ -28,7 +28,7 @@ type sConn struct { func NewConn(pSett ISettings, pAddr string) (IConn, error) { conn, err := net.Dial("tcp", pAddr) if err != nil { - return nil, err + return nil, errors.WrapError(err, "tcp connect") } return LoadConn(pSett, conn), nil } @@ -51,7 +51,7 @@ func (p *sConn) GetSocket() net.Conn { func (p *sConn) FetchPayload(pPld payload.IPayload) (payload.IPayload, error) { if err := p.WritePayload(pPld); err != nil { - return nil, err + return nil, errors.WrapError(err, "write payload") } chPld := make(chan payload.IPayload) @@ -60,11 +60,11 @@ func (p *sConn) FetchPayload(pPld payload.IPayload) (payload.IPayload, error) { select { case rpld := <-chPld: if rpld == nil { - return nil, fmt.Errorf("failed: read payload") + return nil, errors.NewError("read payload") } return rpld, nil case <-time.After(p.fSettings.GetFetchTimeWait()): - return nil, fmt.Errorf("failed: time out") + return nil, errors.NewError("read payload (timeout)") } } @@ -88,18 +88,18 @@ func (p *sConn) WritePayload(pPld payload.IPayload) error { // send headers with length of blocks if err := p.sendBlockSize(encMsgBytes); err != nil { - return err + return errors.WrapError(err, "send block size (encrypted message bytes)") } if err := p.sendBlockSize(voidBytes); err != nil { - return err + return errors.WrapError(err, "send block size (void bytes)") } // send blocks if err := p.sendBytes(encMsgBytes); err != nil { - return err + return errors.WrapError(err, "send encrypted message bytes") } if err := p.sendBytes(voidBytes); err != nil { - return err + return errors.WrapError(err, "send void bytes") } return nil @@ -116,7 +116,7 @@ func (p *sConn) sendBytes(pBytes []byte) error { for { n, err := p.GetSocket().Write(pBytes[:bytesPtr]) if err != nil { - return err + return errors.WrapError(err, "write tcp bytes") } bytesPtr = bytesPtr - uint64(n) @@ -133,10 +133,10 @@ func (p *sConn) sendBlockSize(pBytes []byte) error { blockSize := encoding.Uint64ToBytes(uint64(len(pBytes))) n, err := p.GetSocket().Write(p.fCipher.EncryptBytes(blockSize[:])) if err != nil { - return err + return errors.WrapError(err, "write tcp block size") } if n != symmetric.CAESBlockSize+encoding.CSizeUint64 { - return fmt.Errorf("invalid size of sent package") + return errors.NewError("invalid size of sent package") } return nil } @@ -145,10 +145,10 @@ func (p *sConn) recvBlockSize() (uint64, error) { encBufLen := make([]byte, symmetric.CAESBlockSize+encoding.CSizeUint64) n, err := p.GetSocket().Read(encBufLen) if err != nil { - return 0, err + return 0, errors.WrapError(err, "read tcp block size") } if n != symmetric.CAESBlockSize+encoding.CSizeUint64 { - return 0, fmt.Errorf("block size is invalid") + return 0, errors.NewError("block size is invalid") } // mustLen = Size[u64] in uint64 diff --git a/pkg/network/conn_keeper/conn_keeper.go b/pkg/network/conn_keeper/conn_keeper.go index 44a528de..3ebb0646 100644 --- a/pkg/network/conn_keeper/conn_keeper.go +++ b/pkg/network/conn_keeper/conn_keeper.go @@ -1,10 +1,10 @@ package conn_keeper import ( - "errors" "sync" "time" + "github.com/number571/go-peer/pkg/errors" "github.com/number571/go-peer/pkg/network" ) @@ -40,7 +40,7 @@ func (p *sConnKeeper) Run() error { defer p.fMutex.Unlock() if p.fIsRun { - return errors.New("conn keeper already started") + return errors.NewError("conn keeper already started") } p.fIsRun = true @@ -66,7 +66,7 @@ func (p *sConnKeeper) Stop() error { defer p.fMutex.Unlock() if !p.fIsRun { - return errors.New("conn keeper already closed or not started") + return errors.NewError("conn keeper already closed or not started") } p.fIsRun = false diff --git a/pkg/network/network.go b/pkg/network/network.go index f180b499..6c512212 100644 --- a/pkg/network/network.go +++ b/pkg/network/network.go @@ -1,12 +1,12 @@ package network import ( - "fmt" "net" "sync" "github.com/number571/go-peer/pkg/crypto/hashing" "github.com/number571/go-peer/pkg/encoding" + "github.com/number571/go-peer/pkg/errors" "github.com/number571/go-peer/pkg/network/conn" "github.com/number571/go-peer/pkg/payload" "github.com/number571/go-peer/pkg/types" @@ -49,12 +49,8 @@ func (p *sNode) BroadcastPayload(pPld payload.IPayload) error { var err error for _, conn := range p.GetConnections() { - e := conn.WritePayload(pPld) - if e != nil { - err = e - } + err = errors.AppendError(err, conn.WritePayload(pPld)) } - return err } @@ -64,7 +60,7 @@ func (p *sNode) BroadcastPayload(pPld payload.IPayload) error { func (p *sNode) Run() error { listener, err := net.Listen("tcp", p.GetSettings().GetAddress()) if err != nil { - return err + return errors.WrapError(err, "run node") } go func(pListener net.Listener) { @@ -108,7 +104,10 @@ func (p *sNode) Stop() error { delete(p.fConnections, id) } - return types.CloseAll(toClose) + if err := types.CloseAll(toClose); err != nil { + return errors.WrapError(err, "stop node") + } + return nil } // Saves the function to the map by key for subsequent redirection. @@ -137,13 +136,13 @@ func (p *sNode) GetConnections() map[string]conn.IConn { // Checks the number of connections. func (p *sNode) AddConnect(pAddress string) error { if p.hasMaxConnSize() { - return fmt.Errorf("has max connections size") + return errors.NewError("has max connections size") } sett := p.GetSettings().GetConnSettings() conn, err := conn.NewConn(sett, pAddress) if err != nil { - return err + return errors.WrapError(err, "add connect") } p.setConnection(pAddress, conn) @@ -163,7 +162,10 @@ func (p *sNode) DelConnect(pAddress string) error { } delete(p.fConnections, pAddress) - return conn.Close() + if err := conn.Close(); err != nil { + return errors.WrapError(err, "del connect") + } + return nil } // Processes the received data from the connection. diff --git a/pkg/storage/database/encrypt.go b/pkg/storage/database/encrypt.go index c56dffd8..6d4eeb1a 100644 --- a/pkg/storage/database/encrypt.go +++ b/pkg/storage/database/encrypt.go @@ -2,10 +2,10 @@ package database import ( "bytes" - "fmt" "github.com/number571/go-peer/pkg/crypto/hashing" "github.com/number571/go-peer/pkg/crypto/symmetric" + "github.com/number571/go-peer/pkg/errors" ) func doEncrypt(pCipher symmetric.ICipher, pDataBytes []byte) []byte { @@ -23,12 +23,12 @@ func doEncrypt(pCipher symmetric.ICipher, pDataBytes []byte) []byte { func tryDecrypt(pCipher symmetric.ICipher, pEncBytes []byte) ([]byte, error) { if len(pEncBytes) < hashing.CSHA256Size+symmetric.CAESBlockSize { - return nil, fmt.Errorf("incorrect size of encrypted data") + return nil, errors.NewError("incorrect size of encrypted data") } decBytes := pCipher.DecryptBytes(pEncBytes[hashing.CSHA256Size:]) if decBytes == nil { - return nil, fmt.Errorf("failed decrypt message") + return nil, errors.NewError("failed decrypt message") } gotHashed := pEncBytes[:hashing.CSHA256Size] @@ -38,7 +38,7 @@ func tryDecrypt(pCipher symmetric.ICipher, pEncBytes []byte) ([]byte, error) { ).ToBytes() if !bytes.Equal(gotHashed, newHashed) { - return nil, fmt.Errorf("incorrect hash of decrypted data") + return nil, errors.NewError("incorrect hash of decrypted data") } return decBytes, nil diff --git a/pkg/storage/database/sqlite.go b/pkg/storage/database/sqlite.go index 92ef7f7f..a6f19871 100644 --- a/pkg/storage/database/sqlite.go +++ b/pkg/storage/database/sqlite.go @@ -8,6 +8,7 @@ import ( "github.com/number571/go-peer/pkg/crypto/random" "github.com/number571/go-peer/pkg/crypto/symmetric" "github.com/number571/go-peer/pkg/encoding" + "github.com/number571/go-peer/pkg/errors" _ "github.com/mattn/go-sqlite3" ) @@ -37,11 +38,11 @@ type sSQLiteDB struct { func NewSQLiteDB(pSett ISettings) (IKeyValueDB, error) { db, err := sql.Open("sqlite3", pSett.GetPath()) if err != nil { - return nil, err + return nil, errors.WrapError(err, "open database") } if _, err := db.Exec(cTabelKV); err != nil { - return nil, err + return nil, errors.WrapError(err, "insert KV table") } var saltValue string @@ -50,7 +51,7 @@ func NewSQLiteDB(pSett ISettings) (IKeyValueDB, error) { saltValue = encoding.HexEncode(random.NewStdPRNG().GetBytes(symmetric.CAESKeySize)) _, err := db.Exec("REPLACE INTO kv (key, value) VALUES ($1,$2)", cSaltKey, saltValue) if err != nil { - return nil, err + return nil, errors.WrapError(err, "insert salt into database") } } @@ -75,7 +76,10 @@ func (p *sSQLiteDB) Set(pKey []byte, pValue []byte) error { encoding.HexEncode(p.tryHash(pKey)), encoding.HexEncode(doEncrypt(p.fCipher, pValue)), ) - return err + if err != nil { + return errors.WrapError(err, "insert key/value to database") + } + return nil } func (p *sSQLiteDB) Get(pKey []byte) ([]byte, error) { @@ -85,7 +89,7 @@ func (p *sSQLiteDB) Get(pKey []byte) ([]byte, error) { var encValue string row := p.fDB.QueryRow("SELECT value FROM kv WHERE key = $1", encoding.HexEncode(p.tryHash(pKey))) if err := row.Scan(&encValue); err != nil { - return nil, err + return nil, errors.WrapError(err, "read value by key") } return tryDecrypt( @@ -102,14 +106,20 @@ func (p *sSQLiteDB) Del(pKey []byte) error { "DELETE FROM kv WHERE key = $1", encoding.HexEncode(p.tryHash(pKey)), ) - return err + if err != nil { + return errors.WrapError(err, "delete value by key") + } + return nil } func (p *sSQLiteDB) Close() error { p.fMutex.Lock() defer p.fMutex.Unlock() - return p.fDB.Close() + if err := p.fDB.Close(); err != nil { + return errors.WrapError(err, "close database") + } + return nil } func (p *sSQLiteDB) tryHash(pKey []byte) []byte { diff --git a/pkg/storage/memory.go b/pkg/storage/memory.go index 5f7f3ef3..5cff7592 100644 --- a/pkg/storage/memory.go +++ b/pkg/storage/memory.go @@ -1,10 +1,10 @@ package storage import ( - "fmt" "sync" "github.com/number571/go-peer/pkg/encoding" + "github.com/number571/go-peer/pkg/errors" ) var ( @@ -48,7 +48,7 @@ func (p *sMemoryStorage) Get(pKey []byte) ([]byte, error) { value, ok := p.fMapping[encoding.HexEncode(pKey)] if !ok { - return nil, fmt.Errorf("undefined value by key") + return nil, errors.NewError("undefined value by key") } return value, nil @@ -60,7 +60,7 @@ func (p *sMemoryStorage) Del(pKey []byte) error { _, ok := p.fMapping[encoding.HexEncode(pKey)] if !ok { - return fmt.Errorf("undefined value by key") + return errors.NewError("undefined value by key") } delete(p.fMapping, encoding.HexEncode(pKey)) diff --git a/pkg/storage/storage.go b/pkg/storage/storage.go index 8ce5da59..d045f7a7 100644 --- a/pkg/storage/storage.go +++ b/pkg/storage/storage.go @@ -3,13 +3,13 @@ package storage import ( "bytes" "encoding/json" - "fmt" "sync" "github.com/number571/go-peer/pkg/crypto/entropy" "github.com/number571/go-peer/pkg/crypto/hashing" "github.com/number571/go-peer/pkg/crypto/random" "github.com/number571/go-peer/pkg/crypto/symmetric" + "github.com/number571/go-peer/pkg/errors" "github.com/number571/go-peer/pkg/filesystem" ) @@ -69,7 +69,7 @@ func (p *sCryptoStorage) Set(pKey, pValue []byte) error { var err error mapping, err = p.decrypt() if err != nil { - return err + return errors.WrapError(err, "open & decrypt storage") } } @@ -86,20 +86,20 @@ func (p *sCryptoStorage) Get(pKey []byte) ([]byte, error) { // If storage not exists. if !p.isExist() { - return nil, fmt.Errorf("error: storage undefined") + return nil, errors.NewError("storage undefined") } // Open and decrypt storage mapping, err := p.decrypt() if err != nil { - return nil, err + return nil, errors.WrapError(err, "decrypt storage") } // Open and decrypt secret cipher, hash := p.newCipherWithKeyHash(pKey) encsecret, ok := mapping.FSecrets[hash] if !ok { - return nil, fmt.Errorf("error: key undefined") + return nil, errors.NewError("key undefined") } secret := cipher.DecryptBytes(encsecret) @@ -112,7 +112,7 @@ func (p *sCryptoStorage) Del(pKey []byte) error { // If storage not exists. if !p.isExist() { - return fmt.Errorf("error: storage undefined") + return errors.NewError("storage undefined") } // Open and decrypt storage @@ -125,7 +125,7 @@ func (p *sCryptoStorage) Del(pKey []byte) error { _, hash := p.newCipherWithKeyHash(pKey) _, ok := mapping.FSecrets[hash] if !ok { - return fmt.Errorf("error: key undefined") + return errors.NewError("key undefined") } delete(mapping.FSecrets, hash) @@ -140,7 +140,7 @@ func (p *sCryptoStorage) encrypt(pMapping *storageData) error { // Encrypt and save storage data, err := json.Marshal(pMapping) if err != nil { - return err + return errors.WrapError(err, "marshal decrypted map") } err = filesystem.OpenFile(p.fSettings.GetPath()).Write( @@ -150,7 +150,7 @@ func (p *sCryptoStorage) encrypt(pMapping *storageData) error { ), ) if err != nil { - return err + return errors.WrapError(err, "write to storage") } return nil @@ -161,13 +161,13 @@ func (p *sCryptoStorage) decrypt() (*storageData, error) { encdata, err := filesystem.OpenFile(p.fSettings.GetPath()).Read() if err != nil { - return nil, err + return nil, errors.WrapError(err, "open encrypted storage") } data := p.fCipher.DecryptBytes(encdata[cSaltSize:]) err = json.Unmarshal(data, &mapping) if err != nil { - return nil, err + return nil, errors.WrapError(err, "unmarshal decrypt map") } return &mapping, nil diff --git a/pkg/types/closer.go b/pkg/types/closer.go index 9264f0f5..c6adfbfb 100644 --- a/pkg/types/closer.go +++ b/pkg/types/closer.go @@ -1,12 +1,12 @@ package types +import "github.com/number571/go-peer/pkg/errors" + // returns last error from slice func CloseAll(pClosers []ICloser) error { - var lastErr error + var err error for _, c := range pClosers { - if err := c.Close(); err != nil { - lastErr = err - } + err = errors.AppendError(err, c.Close()) } - return lastErr + return err } diff --git a/pkg/types/stopper.go b/pkg/types/stopper.go index 482c2ba9..001574fb 100644 --- a/pkg/types/stopper.go +++ b/pkg/types/stopper.go @@ -1,12 +1,12 @@ package types +import "github.com/number571/go-peer/pkg/errors" + // returns last error from slice func StopAll(pCommands []ICommand) error { - var lastErr error + var err error for _, c := range pCommands { - if err := c.Stop(); err != nil { - lastErr = err - } + err = errors.AppendError(err, c.Stop()) } - return lastErr + return err }