Update API: PostWallet no longer returns a wallet
This commit is contained in:
Daniel Krol
parent
94114ec36d
commit
3d492d8b86
|
|
@ -78,6 +78,8 @@ func TestIntegrationWalletUpdates(t *testing.T) {
|
|||
`{"email": "abc@example.com", "password": "123"}`,
|
||||
)
|
||||
|
||||
checkStatusCode(t, statusCode, responseBody, http.StatusCreated)
|
||||
|
||||
////////////////////
|
||||
// Get auth token - device 1
|
||||
////////////////////
|
||||
|
|
@ -130,13 +132,13 @@ func TestIntegrationWalletUpdates(t *testing.T) {
|
|||
// Put first wallet - device 1
|
||||
////////////////////
|
||||
|
||||
var walletResponse WalletResponse
|
||||
var walletPostResponse struct{}
|
||||
responseBody, statusCode = request(
|
||||
t,
|
||||
http.MethodPost,
|
||||
s.postWallet,
|
||||
PathWallet,
|
||||
&walletResponse,
|
||||
&walletPostResponse,
|
||||
fmt.Sprintf(`{
|
||||
"token": "%s",
|
||||
"encryptedWallet": "my-encrypted-wallet-1",
|
||||
|
|
@ -147,34 +149,30 @@ func TestIntegrationWalletUpdates(t *testing.T) {
|
|||
|
||||
checkStatusCode(t, statusCode, responseBody)
|
||||
|
||||
////////////////////
|
||||
// Get wallet - device 2
|
||||
////////////////////
|
||||
|
||||
var walletGetResponse WalletResponse
|
||||
responseBody, statusCode = request(
|
||||
t,
|
||||
http.MethodGet,
|
||||
s.getWallet,
|
||||
fmt.Sprintf("%s?token=%s", PathWallet, authToken2.Token),
|
||||
&walletGetResponse,
|
||||
"",
|
||||
)
|
||||
|
||||
checkStatusCode(t, statusCode, responseBody)
|
||||
|
||||
expectedResponse := WalletResponse{
|
||||
EncryptedWallet: wallet.EncryptedWallet("my-encrypted-wallet-1"),
|
||||
Sequence: wallet.Sequence(1),
|
||||
Hmac: wallet.WalletHmac("my-hmac-1"),
|
||||
}
|
||||
|
||||
if !reflect.DeepEqual(walletResponse, expectedResponse) {
|
||||
t.Fatalf("Unexpected response values. want: %+v got: %+v", expectedResponse, walletResponse)
|
||||
}
|
||||
|
||||
////////////////////
|
||||
// Get wallet - device 2
|
||||
////////////////////
|
||||
|
||||
responseBody, statusCode = request(
|
||||
t,
|
||||
http.MethodGet,
|
||||
s.getWallet,
|
||||
fmt.Sprintf("%s?token=%s", PathWallet, authToken2.Token),
|
||||
&walletResponse,
|
||||
"",
|
||||
)
|
||||
|
||||
checkStatusCode(t, statusCode, responseBody)
|
||||
|
||||
// Expect the same response getting from device 2 as when posting from device 1
|
||||
if !reflect.DeepEqual(walletResponse, expectedResponse) {
|
||||
t.Fatalf("Unexpected response values. want: %+v got: %+v", expectedResponse, walletResponse)
|
||||
if !reflect.DeepEqual(walletGetResponse, expectedResponse) {
|
||||
t.Fatalf("Unexpected response values. want: %+v got: %+v", expectedResponse, walletGetResponse)
|
||||
}
|
||||
|
||||
////////////////////
|
||||
|
|
@ -186,7 +184,7 @@ func TestIntegrationWalletUpdates(t *testing.T) {
|
|||
http.MethodPost,
|
||||
s.postWallet,
|
||||
PathWallet,
|
||||
&walletResponse,
|
||||
&walletPostResponse,
|
||||
fmt.Sprintf(`{
|
||||
"token": "%s",
|
||||
"encryptedWallet": "my-encrypted-wallet-2",
|
||||
|
|
@ -197,16 +195,6 @@ func TestIntegrationWalletUpdates(t *testing.T) {
|
|||
|
||||
checkStatusCode(t, statusCode, responseBody)
|
||||
|
||||
expectedResponse = WalletResponse{
|
||||
EncryptedWallet: wallet.EncryptedWallet("my-encrypted-wallet-2"),
|
||||
Sequence: wallet.Sequence(2),
|
||||
Hmac: wallet.WalletHmac("my-hmac-2"),
|
||||
}
|
||||
|
||||
if !reflect.DeepEqual(walletResponse, expectedResponse) {
|
||||
t.Fatalf("Unexpected response values. want: %+v got: %+v", expectedResponse, walletResponse)
|
||||
}
|
||||
|
||||
////////////////////
|
||||
// Get wallet - device 1
|
||||
////////////////////
|
||||
|
|
@ -216,14 +204,20 @@ func TestIntegrationWalletUpdates(t *testing.T) {
|
|||
http.MethodGet,
|
||||
s.getWallet,
|
||||
fmt.Sprintf("%s?token=%s", PathWallet, authToken1.Token),
|
||||
&walletResponse,
|
||||
&walletGetResponse,
|
||||
"",
|
||||
)
|
||||
|
||||
checkStatusCode(t, statusCode, responseBody)
|
||||
|
||||
expectedResponse = WalletResponse{
|
||||
EncryptedWallet: wallet.EncryptedWallet("my-encrypted-wallet-2"),
|
||||
Sequence: wallet.Sequence(2),
|
||||
Hmac: wallet.WalletHmac("my-hmac-2"),
|
||||
}
|
||||
|
||||
// Expect the same response getting from device 2 as when posting from device 1
|
||||
if !reflect.DeepEqual(walletResponse, expectedResponse) {
|
||||
t.Fatalf("Unexpected response values. want: %+v got: %+v", expectedResponse, walletResponse)
|
||||
if !reflect.DeepEqual(walletGetResponse, expectedResponse) {
|
||||
t.Fatalf("Unexpected response values. want: %+v got: %+v", expectedResponse, walletGetResponse)
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -12,7 +12,7 @@ import (
|
|||
|
||||
// TODO proper doc comments!
|
||||
|
||||
const ApiVersion = "1"
|
||||
const ApiVersion = "2"
|
||||
const PathPrefix = "/api/" + ApiVersion
|
||||
|
||||
const PathAuthToken = PathPrefix + "/auth/full"
|
||||
|
|
|
|||
|
|
@ -67,7 +67,6 @@ type TestStore struct {
|
|||
TestEncryptedWallet wallet.EncryptedWallet
|
||||
TestSequence wallet.Sequence
|
||||
TestHmac wallet.WalletHmac
|
||||
TestSequenceCorrect bool
|
||||
}
|
||||
|
||||
func (s *TestStore) SaveToken(authToken *auth.AuthToken) error {
|
||||
|
|
@ -95,16 +94,9 @@ func (s *TestStore) SetWallet(
|
|||
encryptedWallet wallet.EncryptedWallet,
|
||||
sequence wallet.Sequence,
|
||||
hmac wallet.WalletHmac,
|
||||
) (latestEncryptedWallet wallet.EncryptedWallet, latestSequence wallet.Sequence, latestHmac wallet.WalletHmac, sequenceCorrect bool, err error) {
|
||||
) (err error) {
|
||||
s.Called.SetWallet = SetWalletCall{encryptedWallet, sequence, hmac}
|
||||
err = s.Errors.SetWallet
|
||||
if err == nil {
|
||||
latestEncryptedWallet = s.TestEncryptedWallet
|
||||
latestSequence = s.TestSequence
|
||||
latestHmac = s.TestHmac
|
||||
sequenceCorrect = s.TestSequenceCorrect
|
||||
}
|
||||
return
|
||||
return s.Errors.SetWallet
|
||||
}
|
||||
|
||||
func (s *TestStore) GetWallet(userId auth.UserId) (encryptedWallet wallet.EncryptedWallet, sequence wallet.Sequence, hmac wallet.WalletHmac, err error) {
|
||||
|
|
@ -229,7 +221,7 @@ func TestServerHelperGetGetDataSuccess(t *testing.T) {
|
|||
}
|
||||
}
|
||||
func TestServerHelperGetGetDataErrors(t *testing.T) {
|
||||
// Only error right now is if you do a POST request
|
||||
// Only error right now is if you do a POST request
|
||||
req := httptest.NewRequest(http.MethodPost, "/test", nil)
|
||||
w := httptest.NewRecorder()
|
||||
success := getGetData(w, req)
|
||||
|
|
|
|||
|
|
@ -27,7 +27,6 @@ type WalletResponse struct {
|
|||
EncryptedWallet wallet.EncryptedWallet `json:"encryptedWallet"`
|
||||
Sequence wallet.Sequence `json:"sequence"`
|
||||
Hmac wallet.WalletHmac `json:"hmac"`
|
||||
Error string `json:"error"` // in case of 409 Conflict responses. TODO - make field not show up if it's empty, to avoid confusion
|
||||
}
|
||||
|
||||
func (s *Server) handleWallet(w http.ResponseWriter, req *http.Request) {
|
||||
|
|
@ -103,6 +102,11 @@ func (s *Server) getWallet(w http.ResponseWriter, req *http.Request) {
|
|||
fmt.Fprintf(w, string(response))
|
||||
}
|
||||
|
||||
// Response Code:
|
||||
// 200: Update successful
|
||||
// 409: Update unsuccessful due to new wallet's sequence not being 1 +
|
||||
// current wallet's sequence
|
||||
// 500: Update unsuccessful for unanticipated reasons
|
||||
func (s *Server) postWallet(w http.ResponseWriter, req *http.Request) {
|
||||
var walletRequest WalletRequest
|
||||
if !getPostData(w, req, &walletRequest) {
|
||||
|
|
@ -114,21 +118,10 @@ func (s *Server) postWallet(w http.ResponseWriter, req *http.Request) {
|
|||
return
|
||||
}
|
||||
|
||||
latestEncryptedWallet, latestSequence, latestHmac, sequenceCorrect, err := s.store.SetWallet(
|
||||
authToken.UserId,
|
||||
walletRequest.EncryptedWallet,
|
||||
walletRequest.Sequence,
|
||||
walletRequest.Hmac,
|
||||
)
|
||||
err := s.store.SetWallet(authToken.UserId, walletRequest.EncryptedWallet, walletRequest.Sequence, walletRequest.Hmac)
|
||||
|
||||
var response []byte
|
||||
|
||||
if err == store.ErrNoWallet {
|
||||
// We failed to update, and when we tried pulling the latest wallet,
|
||||
// there was nothing there. This should only happen if the client sets
|
||||
// sequence != 1 for the first wallet, which would be a bug.
|
||||
// TODO - figure out better error messages and/or document this
|
||||
errorJson(w, http.StatusConflict, "Bad sequence number (No existing wallet)")
|
||||
if err == store.ErrWrongSequence {
|
||||
errorJson(w, http.StatusConflict, "Bad sequence number")
|
||||
return
|
||||
} else if err != nil {
|
||||
// Something other than sequence error
|
||||
|
|
@ -136,16 +129,8 @@ func (s *Server) postWallet(w http.ResponseWriter, req *http.Request) {
|
|||
return
|
||||
}
|
||||
|
||||
walletResponse := WalletResponse{
|
||||
EncryptedWallet: latestEncryptedWallet,
|
||||
Sequence: latestSequence,
|
||||
Hmac: latestHmac,
|
||||
}
|
||||
|
||||
if !sequenceCorrect {
|
||||
// TODO - should we even call this an error?
|
||||
walletResponse.Error = http.StatusText(http.StatusConflict) + ": " + "Bad sequence number"
|
||||
}
|
||||
var response []byte
|
||||
var walletResponse struct{}
|
||||
response, err = json.Marshal(walletResponse)
|
||||
|
||||
if err != nil {
|
||||
|
|
@ -153,18 +138,5 @@ func (s *Server) postWallet(w http.ResponseWriter, req *http.Request) {
|
|||
return
|
||||
}
|
||||
|
||||
// Response Code:
|
||||
// 200: Update successful
|
||||
// 409: Update unsuccessful, probably due to new wallet's
|
||||
// sequence not being 1 + current wallet's sequence
|
||||
//
|
||||
// Response Body:
|
||||
// Current wallet (if it exists). If update successful, we just return
|
||||
// the same one passed in. If update not successful, return the latest one
|
||||
// from the db for the client to merge.
|
||||
if sequenceCorrect {
|
||||
fmt.Fprintf(w, string(response))
|
||||
} else {
|
||||
http.Error(w, string(response), http.StatusConflict)
|
||||
}
|
||||
fmt.Fprintf(w, string(response))
|
||||
}
|
||||
|
|
|
|||
|
|
@ -131,10 +131,7 @@ func TestServerPostWallet(t *testing.T) {
|
|||
|
||||
expectedStatusCode int
|
||||
expectedErrorString string
|
||||
|
||||
// There is one case where we expect both the error field and the normal
|
||||
// body fields. So, this needs to be separate.
|
||||
expectWalletBody bool
|
||||
expectSetWalletCall bool
|
||||
|
||||
// This is getting messy, but in the case of validation failures, we don't
|
||||
// even get around to trying to get an auth token, since the token string is
|
||||
|
|
@ -144,93 +141,38 @@ func TestServerPostWallet(t *testing.T) {
|
|||
|
||||
// `new...` refers to what is being passed into the via POST request (and
|
||||
// what gets passed into SetWallet for the *non-error* cases below)
|
||||
// `returned...` refers to what the SetWallet function returns (and what
|
||||
// gets returned in the request response for the *non-error* cases below)
|
||||
newEncryptedWallet wallet.EncryptedWallet
|
||||
returnedEncryptedWallet wallet.EncryptedWallet
|
||||
newSequence wallet.Sequence
|
||||
returnedSequence wallet.Sequence
|
||||
newHmac wallet.WalletHmac
|
||||
returnedHmac wallet.WalletHmac
|
||||
|
||||
// Passed-in sequence was correct. No conflict.
|
||||
sequenceCorrect bool
|
||||
newEncryptedWallet wallet.EncryptedWallet
|
||||
newSequence wallet.Sequence
|
||||
newHmac wallet.WalletHmac
|
||||
|
||||
storeErrors TestStoreFunctionsErrors
|
||||
}{
|
||||
{
|
||||
name: "success",
|
||||
expectedStatusCode: http.StatusOK,
|
||||
expectWalletBody: true,
|
||||
name: "success",
|
||||
expectedStatusCode: http.StatusOK,
|
||||
expectSetWalletCall: true,
|
||||
|
||||
// Simulates a situation where the existing sequence is 1, the new
|
||||
// sequence is 2. We don't see the existing data in this case because it
|
||||
// successfully updates to and returns the new data. New and returned are
|
||||
// the same here.
|
||||
|
||||
sequenceCorrect: true,
|
||||
newEncryptedWallet: wallet.EncryptedWallet("my-encrypted-wallet"),
|
||||
returnedEncryptedWallet: wallet.EncryptedWallet("my-encrypted-wallet"),
|
||||
newSequence: wallet.Sequence(2),
|
||||
returnedSequence: wallet.Sequence(2),
|
||||
newHmac: wallet.WalletHmac("my-hmac"),
|
||||
returnedHmac: wallet.WalletHmac("my-hmac"),
|
||||
},
|
||||
{
|
||||
name: "conflict",
|
||||
expectedStatusCode: http.StatusConflict,
|
||||
// In the special case of "conflict" where there *is* a stored wallet, we
|
||||
// process the function in a normal way, but we still have the Error field.
|
||||
// So, we can't rely on `tc.expectedErrorString == ""` to indicate that it
|
||||
// is the type of error without a body. So, we need to specify this
|
||||
// separately. In this case we will check the error string along with the
|
||||
// body.
|
||||
expectWalletBody: true,
|
||||
|
||||
// Simulates a situation where the existing sequence is 3, the new sequence
|
||||
// is 2. This is a conflict, because the new sequence should be 4. A new
|
||||
// sequence of 3 would also be a conflict, but we want two different
|
||||
// sequence numbers for a clear test. We return the existing data in this
|
||||
// case for the client to merge in. Note that we're passing in a sequence
|
||||
// that makes sense for a conflict case, the actual behavior is triggered by
|
||||
// sequenceCorrect=false
|
||||
// sequence is 2.
|
||||
|
||||
newEncryptedWallet: wallet.EncryptedWallet("my-encrypted-wallet"),
|
||||
newSequence: wallet.Sequence(2),
|
||||
newHmac: wallet.WalletHmac("my-hmac"),
|
||||
}, {
|
||||
name: "conflict",
|
||||
expectedStatusCode: http.StatusConflict,
|
||||
expectedErrorString: http.StatusText(http.StatusConflict) + ": Bad sequence number",
|
||||
expectSetWalletCall: true,
|
||||
|
||||
sequenceCorrect: false,
|
||||
newEncryptedWallet: wallet.EncryptedWallet("my-encrypted-wallet-new"),
|
||||
returnedEncryptedWallet: wallet.EncryptedWallet("my-encrypted-wallet-existing"),
|
||||
newSequence: wallet.Sequence(2),
|
||||
returnedSequence: wallet.Sequence(3),
|
||||
newHmac: wallet.WalletHmac("my-hmac-new"),
|
||||
returnedHmac: wallet.WalletHmac("my-hmac-existing"),
|
||||
},
|
||||
{
|
||||
name: "conflict with no stored wallet",
|
||||
expectedStatusCode: http.StatusConflict,
|
||||
// Simulates a situation where the existing sequence is *not* 1, the new
|
||||
// proposed sequence is 2, and it thus fails with a conflict.
|
||||
|
||||
// Simulates a situation where there is no stored wallet. In such a case the
|
||||
// correct sequence would be 1, which implies the wallet should be inserted
|
||||
// (as opposed to updated). We will be passing in a sequence of 2 for
|
||||
// clarity, but what will actually trigger the desired error we are testing
|
||||
// for is SetWallet returning ErrNoWallet, which is what the store is
|
||||
// expected to return in this situation.
|
||||
newEncryptedWallet: wallet.EncryptedWallet("my-encrypted-wallet-new"),
|
||||
newSequence: wallet.Sequence(2),
|
||||
newHmac: wallet.WalletHmac("my-hmac-new"),
|
||||
|
||||
expectedErrorString: http.StatusText(http.StatusConflict) + ": Bad sequence number (No existing wallet)",
|
||||
|
||||
// In this case the "returned" values are blank because there will be
|
||||
// nothing to return
|
||||
sequenceCorrect: false,
|
||||
newEncryptedWallet: wallet.EncryptedWallet("my-encrypted-wallet"),
|
||||
returnedEncryptedWallet: wallet.EncryptedWallet(""),
|
||||
newSequence: wallet.Sequence(2),
|
||||
returnedSequence: wallet.Sequence(0),
|
||||
newHmac: wallet.WalletHmac("my-hmac"),
|
||||
returnedHmac: wallet.WalletHmac(""),
|
||||
|
||||
storeErrors: TestStoreFunctionsErrors{SetWallet: store.ErrNoWallet},
|
||||
},
|
||||
{
|
||||
storeErrors: TestStoreFunctionsErrors{SetWallet: store.ErrWrongSequence},
|
||||
}, {
|
||||
name: "validation error",
|
||||
expectedStatusCode: http.StatusBadRequest,
|
||||
expectedErrorString: http.StatusText(http.StatusBadRequest) + ": Request failed validation",
|
||||
|
|
@ -240,47 +182,33 @@ func TestServerPostWallet(t *testing.T) {
|
|||
// validate function is called. We'll check the rest of the validation
|
||||
// errors in the other test below.
|
||||
|
||||
sequenceCorrect: true,
|
||||
newEncryptedWallet: wallet.EncryptedWallet(""),
|
||||
returnedEncryptedWallet: wallet.EncryptedWallet("my-encrypted-wallet"),
|
||||
newSequence: wallet.Sequence(2),
|
||||
returnedSequence: wallet.Sequence(2),
|
||||
newHmac: wallet.WalletHmac("my-hmac"),
|
||||
returnedHmac: wallet.WalletHmac("my-hmac"),
|
||||
},
|
||||
|
||||
{
|
||||
newEncryptedWallet: wallet.EncryptedWallet(""),
|
||||
newSequence: wallet.Sequence(2),
|
||||
newHmac: wallet.WalletHmac("my-hmac"),
|
||||
}, {
|
||||
name: "auth error",
|
||||
expectedStatusCode: http.StatusUnauthorized,
|
||||
expectedErrorString: http.StatusText(http.StatusUnauthorized) + ": Token Not Found",
|
||||
|
||||
// Putting in valid data here so it's clear that this isn't what causes
|
||||
// the error
|
||||
sequenceCorrect: true,
|
||||
newEncryptedWallet: wallet.EncryptedWallet("my-encrypted-wallet"),
|
||||
returnedEncryptedWallet: wallet.EncryptedWallet("my-encrypted-wallet"),
|
||||
newSequence: wallet.Sequence(2),
|
||||
returnedSequence: wallet.Sequence(2),
|
||||
newHmac: wallet.WalletHmac("my-hmac"),
|
||||
returnedHmac: wallet.WalletHmac("my-hmac"),
|
||||
newEncryptedWallet: wallet.EncryptedWallet("my-encrypted-wallet"),
|
||||
newSequence: wallet.Sequence(2),
|
||||
newHmac: wallet.WalletHmac("my-hmac"),
|
||||
|
||||
// What causes the error
|
||||
storeErrors: TestStoreFunctionsErrors{GetToken: store.ErrNoToken},
|
||||
},
|
||||
{
|
||||
name: "db error setting or getting wallet",
|
||||
}, {
|
||||
name: "db error setting wallet",
|
||||
expectedStatusCode: http.StatusInternalServerError,
|
||||
expectedErrorString: http.StatusText(http.StatusInternalServerError),
|
||||
expectSetWalletCall: true,
|
||||
|
||||
// Putting in valid data here so it's clear that this isn't what causes
|
||||
// the error
|
||||
sequenceCorrect: true,
|
||||
newEncryptedWallet: wallet.EncryptedWallet("my-encrypted-wallet"),
|
||||
returnedEncryptedWallet: wallet.EncryptedWallet("my-encrypted-wallet"),
|
||||
newSequence: wallet.Sequence(2),
|
||||
returnedSequence: wallet.Sequence(2),
|
||||
newHmac: wallet.WalletHmac("my-hmac"),
|
||||
returnedHmac: wallet.WalletHmac("my-hmac"),
|
||||
newEncryptedWallet: wallet.EncryptedWallet("my-encrypted-wallet"),
|
||||
newSequence: wallet.Sequence(2),
|
||||
newHmac: wallet.WalletHmac("my-hmac"),
|
||||
|
||||
// What causes the error
|
||||
storeErrors: TestStoreFunctionsErrors{SetWallet: fmt.Errorf("Some random db problem")},
|
||||
|
|
@ -301,11 +229,6 @@ func TestServerPostWallet(t *testing.T) {
|
|||
Scope: auth.ScopeFull,
|
||||
},
|
||||
|
||||
TestEncryptedWallet: tc.returnedEncryptedWallet,
|
||||
TestSequence: tc.returnedSequence,
|
||||
TestHmac: tc.returnedHmac,
|
||||
TestSequenceCorrect: tc.sequenceCorrect,
|
||||
|
||||
Errors: tc.storeErrors,
|
||||
}
|
||||
|
||||
|
|
@ -338,21 +261,11 @@ func TestServerPostWallet(t *testing.T) {
|
|||
expectStatusCode(t, w, tc.expectedStatusCode)
|
||||
expectErrorString(t, body, tc.expectedErrorString)
|
||||
|
||||
if !tc.expectWalletBody {
|
||||
return // The rest of the test does not apply
|
||||
if tc.expectedErrorString == "" && string(body) != "{}" {
|
||||
t.Errorf("Expected post wallet response to be \"{}\": result: %+v", string(body))
|
||||
}
|
||||
|
||||
var result WalletResponse
|
||||
err := json.Unmarshal(body, &result)
|
||||
|
||||
if err != nil ||
|
||||
result.EncryptedWallet != tc.returnedEncryptedWallet ||
|
||||
result.Hmac != tc.returnedHmac ||
|
||||
result.Sequence != tc.returnedSequence {
|
||||
t.Errorf("Expected wallet response to have the test wallet values: result: %+v err: %+v", string(body), err)
|
||||
}
|
||||
|
||||
if want, got := (SetWalletCall{tc.newEncryptedWallet, tc.newSequence, tc.newHmac}), testStore.Called.SetWallet; want != got {
|
||||
if want, got := (SetWalletCall{tc.newEncryptedWallet, tc.newSequence, tc.newHmac}), testStore.Called.SetWallet; tc.expectSetWalletCall && want != got {
|
||||
t.Errorf("Store.SetWallet called with: expected %+v, got %+v", want, got)
|
||||
}
|
||||
})
|
||||
|
|
|
|||
|
|
@ -21,6 +21,8 @@ var (
|
|||
ErrDuplicateWallet = fmt.Errorf("Wallet already exists for this user")
|
||||
ErrNoWallet = fmt.Errorf("Wallet does not exist for this user at this sequence")
|
||||
|
||||
ErrWrongSequence = fmt.Errorf("Wallet could not be updated to this sequence")
|
||||
|
||||
ErrDuplicateEmail = fmt.Errorf("Email already exists for this user")
|
||||
ErrDuplicateAccount = fmt.Errorf("User already has an account")
|
||||
|
||||
|
|
@ -31,7 +33,7 @@ var (
|
|||
type StoreInterface interface {
|
||||
SaveToken(*auth.AuthToken) error
|
||||
GetToken(auth.TokenString) (*auth.AuthToken, error)
|
||||
SetWallet(auth.UserId, wallet.EncryptedWallet, wallet.Sequence, wallet.WalletHmac) (wallet.EncryptedWallet, wallet.Sequence, wallet.WalletHmac, bool, error)
|
||||
SetWallet(auth.UserId, wallet.EncryptedWallet, wallet.Sequence, wallet.WalletHmac) error
|
||||
GetWallet(auth.UserId) (wallet.EncryptedWallet, wallet.Sequence, wallet.WalletHmac, error)
|
||||
GetUserId(auth.Email, auth.Password) (auth.UserId, error)
|
||||
CreateAccount(auth.Email, auth.Password) (err error)
|
||||
|
|
@ -282,39 +284,17 @@ func (s *Store) updateWalletToSequence(
|
|||
}
|
||||
|
||||
// Assumption: Sequence has been validated (>=1)
|
||||
func (s *Store) SetWallet(
|
||||
userId auth.UserId,
|
||||
encryptedWallet wallet.EncryptedWallet,
|
||||
sequence wallet.Sequence,
|
||||
hmac wallet.WalletHmac,
|
||||
// TODO `sequenceCorrect` should probably be replaced with `status`, that can
|
||||
// equal `Updated` or `SequenceMismatch`. Maybe with a message for the API.
|
||||
// Like an error, but not, because the function still returns a value.
|
||||
// Right now, we have:
|
||||
// `sequenceCorrect==true` and `err==nil` implies it updated.
|
||||
// We could also have:
|
||||
// `sequenceMismatch==true` or `err!=nil` implying it didn't update.
|
||||
// Or:
|
||||
// `updated==false` and `err=nil` implying the sequence mismatched.
|
||||
// I don't like this implication stuff, the "status" should be explicit so
|
||||
// we don't make bugs.
|
||||
) (latestEncryptedWallet wallet.EncryptedWallet, latestSequence wallet.Sequence, latestHmac wallet.WalletHmac, sequenceCorrect bool, err error) {
|
||||
func (s *Store) SetWallet(userId auth.UserId, encryptedWallet wallet.EncryptedWallet, sequence wallet.Sequence, hmac wallet.WalletHmac) (err error) {
|
||||
if sequence == 1 {
|
||||
// If sequence == 1, the client assumed that this is our first
|
||||
// wallet. Try to insert. If we get a conflict, the client
|
||||
// assumed incorrectly and we proceed below to return the latest
|
||||
// wallet from the db.
|
||||
err = s.insertFirstWallet(userId, encryptedWallet, hmac)
|
||||
if err == nil {
|
||||
// Successful update
|
||||
latestEncryptedWallet = encryptedWallet
|
||||
latestSequence = sequence
|
||||
latestHmac = hmac
|
||||
sequenceCorrect = true
|
||||
return
|
||||
} else if err != ErrDuplicateWallet {
|
||||
// Unsuccessful update for reasons other than sequence conflict
|
||||
return
|
||||
if err == ErrDuplicateWallet {
|
||||
// A wallet already exists. That means the input sequence should not be 1.
|
||||
// To the caller, this means the sequence was wrong.
|
||||
err = ErrWrongSequence
|
||||
}
|
||||
} else {
|
||||
// If sequence > 1, the client assumed that it is replacing wallet
|
||||
|
|
@ -322,25 +302,12 @@ func (s *Store) SetWallet(
|
|||
// sequence - 1. If we updated no rows, the client assumed incorrectly
|
||||
// and we proceed below to return the latest wallet from the db.
|
||||
err = s.updateWalletToSequence(userId, encryptedWallet, sequence, hmac)
|
||||
if err == nil {
|
||||
latestEncryptedWallet = encryptedWallet
|
||||
latestSequence = sequence
|
||||
latestHmac = hmac
|
||||
sequenceCorrect = true
|
||||
return
|
||||
} else if err != ErrNoWallet {
|
||||
return
|
||||
if err == ErrNoWallet {
|
||||
// No wallet found to replace at the `sequence - 1`. To the caller, this
|
||||
// means the sequence they put in was wrong.
|
||||
err = ErrWrongSequence
|
||||
}
|
||||
}
|
||||
|
||||
// We failed to update above due to a sequence conflict. Perhaps the client
|
||||
// was unaware of an update done by another client. Let's send back the latest
|
||||
// version right away so the requesting client can take care of it.
|
||||
//
|
||||
// Note that this means that `err` will not be `nil` at this point, but we
|
||||
// already accounted for it with `sequenceCorrect=false`. Instead, we'll pass
|
||||
// on any errors from calling `GetWallet`.
|
||||
latestEncryptedWallet, latestSequence, latestHmac, err = s.GetWallet(userId)
|
||||
return
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -25,36 +25,34 @@ Now that the account exists, grab an auth token with both clients.
|
|||
|
||||
```
|
||||
>>> c1.get_auth_token()
|
||||
Got auth token: 2e1c00c0f2f205defc177bd21e64dd01c669e234cf23bbc19f73e720ac1ef12d
|
||||
Got auth token: 4a3d9b8569c3b06079ff26d60ebc56db6254305217602c19b0af6e02db6d95d7
|
||||
>>> c2.get_auth_token()
|
||||
Got auth token: 07ab32cfac3961d30570537d4082abdf08123de6e5a28670dbf680be45e442d5
|
||||
Got auth token: 33fd77031ccaec966018867e960446bf39d51a3c492c3d997d5f1aa13c75298d
|
||||
```
|
||||
|
||||
## Syncing
|
||||
|
||||
Create a new wallet + metadata (we'll wrap it in a struct we'll call `WalletState` in this client) using `init_wallet_state` and POST them to the server. The metadata (as of now) in the walletstate is only `sequence`. `sequence` is an integer that increments for every POSTed wallet. This is bookkeeping to prevent certain syncing errors.
|
||||
|
||||
_Note that after POSTing, it says it "got" a new wallet. This is because the POST endpoint also returns the latest version. The purpose of this will be explained in "Conflicts" below._
|
||||
|
||||
```
|
||||
>>> c1.init_wallet_state()
|
||||
Wallet not found
|
||||
No wallet found on the server for this account. Starting a new one.
|
||||
>>> c1.update_remote_wallet()
|
||||
Successfully updated wallet state on server
|
||||
Got new walletState:
|
||||
WalletState(sequence=1, encrypted_wallet='czo4MTkyOjE2OjE6CjZHlCv4ZyHiPKA7PoIOOkQ6Fh9fYUYPe9xwiZRYdLKHDgtEQCIcwkNldP1TN8TwTht4Qj5QEnApwQkd2Y20nVjdCUTKLzu4gmdP8QBz2EEGR+XmZgosX937E8bmmqgC55ttgt8fh0o62cTonF4h1LLI7DoWw1SvEcqIIAEn/dc=')
|
||||
Synced walletState:
|
||||
WalletState(sequence=1, encrypted_wallet='czo4MTkyOjE2OjE6/MNVSMrjIqPzrD/oaub++J3lc5qW+baxD0EI6n5/XqGgRsUND3G7fqRsn/riULM4zap+jI8XgW6l1rieJWGZXPQvIZJP8B7gQvBDfzlY0BxUgECeX38I5EtRFNWU3sTwmAaAaDuBpaBXvnf2hu4SEp5xl/OQVg9h+BluTZBdLSU=')
|
||||
'Success'
|
||||
```
|
||||
|
||||
Now, call `init_wallet_state` with the other client. This time, `init_wallet_state` will GET the wallet from the server. In general, `init_wallet_state` is used to set up a new client; first it checks the server, then failing that, it initializes it locally. (In a real client, it would save the walletstate to disk, and `init_wallet_state` would check there before checking the server).
|
||||
Now, call `init_wallet_state` with the other client. Then, we call `get_remote_wallet` to GET the wallet from the server. (In a real client, it would also save the walletstate to disk, and `init_wallet_state` would check there before checking the server).
|
||||
|
||||
(There are a few potential unresolved issues surrounding this related to sequence of events. Check comments on `init_wallet_state`. SDK again works around them with the timestamps.)
|
||||
|
||||
```
|
||||
>>> c2.init_wallet_state()
|
||||
Got latest walletState:
|
||||
WalletState(sequence=1, encrypted_wallet='czo4MTkyOjE2OjE6CjZHlCv4ZyHiPKA7PoIOOkQ6Fh9fYUYPe9xwiZRYdLKHDgtEQCIcwkNldP1TN8TwTht4Qj5QEnApwQkd2Y20nVjdCUTKLzu4gmdP8QBz2EEGR+XmZgosX937E8bmmqgC55ttgt8fh0o62cTonF4h1LLI7DoWw1SvEcqIIAEn/dc=')
|
||||
>>> c2.get_remote_wallet()
|
||||
Got (and maybe merged in) latest walletState:
|
||||
WalletState(sequence=1, encrypted_wallet='czo4MTkyOjE2OjE6/MNVSMrjIqPzrD/oaub++J3lc5qW+baxD0EI6n5/XqGgRsUND3G7fqRsn/riULM4zap+jI8XgW6l1rieJWGZXPQvIZJP8B7gQvBDfzlY0BxUgECeX38I5EtRFNWU3sTwmAaAaDuBpaBXvnf2hu4SEp5xl/OQVg9h+BluTZBdLSU=')
|
||||
'Success'
|
||||
```
|
||||
|
||||
## Updating
|
||||
|
|
@ -64,12 +62,12 @@ Push a new version, GET it with the other client. Even though we haven't edited
|
|||
```
|
||||
>>> c2.update_remote_wallet()
|
||||
Successfully updated wallet state on server
|
||||
Got new walletState:
|
||||
WalletState(sequence=2, encrypted_wallet='czo4MTkyOjE2OjE6LsWo7O3EQVw+buxGPuqJBBEn3oBM3/sAII2NjpbKi7tEvWxbWmKb+nNyr3fuvQ6YZZda0i0Rb7Veuq7ym+hYAn2pTt/8WrYR8K1HFnxs3y1m91HQIsXrl6NwxU5t+mZ6uInQUfEGEV6JLHfbt1NJ2pYlYvYTelusKZXq/kja8i4=')
|
||||
Synced walletState:
|
||||
WalletState(sequence=2, encrypted_wallet='czo4MTkyOjE2OjE6MIPxgbxNGbaZWboH6ci6wBT3izdpb/B3JYdl3nJdQn6EV54W4QaYUvuUxMa5XngiXlNLcLbmFRqeYj/mgAbEVXRKLyLQxjB7rIhGcRxsHbzGR8YDMVvP+m5dWaxevlZc7cEZkpRQKfFyuc+pnjPEk9SUvEgioN1Hxir6DonMqlA=')
|
||||
'Success'
|
||||
>>> c1.get_remote_wallet()
|
||||
Got latest walletState:
|
||||
WalletState(sequence=2, encrypted_wallet='czo4MTkyOjE2OjE6LsWo7O3EQVw+buxGPuqJBBEn3oBM3/sAII2NjpbKi7tEvWxbWmKb+nNyr3fuvQ6YZZda0i0Rb7Veuq7ym+hYAn2pTt/8WrYR8K1HFnxs3y1m91HQIsXrl6NwxU5t+mZ6uInQUfEGEV6JLHfbt1NJ2pYlYvYTelusKZXq/kja8i4=')
|
||||
Got (and maybe merged in) latest walletState:
|
||||
WalletState(sequence=2, encrypted_wallet='czo4MTkyOjE2OjE6MIPxgbxNGbaZWboH6ci6wBT3izdpb/B3JYdl3nJdQn6EV54W4QaYUvuUxMa5XngiXlNLcLbmFRqeYj/mgAbEVXRKLyLQxjB7rIhGcRxsHbzGR8YDMVvP+m5dWaxevlZc7cEZkpRQKfFyuc+pnjPEk9SUvEgioN1Hxir6DonMqlA=')
|
||||
'Success'
|
||||
```
|
||||
|
||||
|
|
@ -94,12 +92,12 @@ The wallet is synced between the clients. The client with the changed preference
|
|||
```
|
||||
>>> c1.update_remote_wallet()
|
||||
Successfully updated wallet state on server
|
||||
Got new walletState:
|
||||
WalletState(sequence=3, encrypted_wallet='czo4MTkyOjE2OjE6l5SVvs2yNDoC5j1316n0xQ5H6K1UEso/JpdpShfLW2bCY3lg9vOcwayO1v085RyItxEwtrtSnD3fnan3kr86GmSI8U6x5DxASHVdgceLBrclVkuCpFXllz6YNtWo5thjbf63PWSg4k6LHI8w50BT2tu9FUufCi67n7sTWnGb/0AjAFYU1sUTJ9aoeiZYrrur')
|
||||
Synced walletState:
|
||||
WalletState(sequence=3, encrypted_wallet='czo4MTkyOjE2OjE6YUEKfjxhUXeHrNbPuWpMt5o/6H5fSSKFZAMkb8YugMGEHzVAZDfGMdowwdycXkyTZtPRiMSs+kgOX8BLomcz/I+de8b1EsXribYR05sgySRJiPoW8VBRlmgbRapZ9iGaxvgJJWmVAO42beNWtnuE3bdpDtWtZjgcXWq6lnhNlETmKEEPthezGB8svHPHt/rJ')
|
||||
'Success'
|
||||
>>> c2.get_remote_wallet()
|
||||
Got latest walletState:
|
||||
WalletState(sequence=3, encrypted_wallet='czo4MTkyOjE2OjE6l5SVvs2yNDoC5j1316n0xQ5H6K1UEso/JpdpShfLW2bCY3lg9vOcwayO1v085RyItxEwtrtSnD3fnan3kr86GmSI8U6x5DxASHVdgceLBrclVkuCpFXllz6YNtWo5thjbf63PWSg4k6LHI8w50BT2tu9FUufCi67n7sTWnGb/0AjAFYU1sUTJ9aoeiZYrrur')
|
||||
Got (and maybe merged in) latest walletState:
|
||||
WalletState(sequence=3, encrypted_wallet='czo4MTkyOjE2OjE6YUEKfjxhUXeHrNbPuWpMt5o/6H5fSSKFZAMkb8YugMGEHzVAZDfGMdowwdycXkyTZtPRiMSs+kgOX8BLomcz/I+de8b1EsXribYR05sgySRJiPoW8VBRlmgbRapZ9iGaxvgJJWmVAO42beNWtnuE3bdpDtWtZjgcXWq6lnhNlETmKEEPthezGB8svHPHt/rJ')
|
||||
'Success'
|
||||
>>> c2.get_preferences()
|
||||
{'animal': 'cow', 'car': ''}
|
||||
|
|
@ -125,8 +123,8 @@ One client POSTs its change first.
|
|||
```
|
||||
>>> c1.update_remote_wallet()
|
||||
Successfully updated wallet state on server
|
||||
Got new walletState:
|
||||
WalletState(sequence=4, encrypted_wallet='czo4MTkyOjE2OjE66nridrsrXcL/DlcudUs7RaAIZ3jRYQJhaacRH3vPNx0TZqkJbDcjMiHbiHY6U2AVhoAsLPIf/zcU+uDTw4IRcOL9Gozupc8tCrIcgm/kwXjnQI9RNzIfDsFxalBKj0u7Xf0c+5f/ntr4Hs9Q/Y7qthseNbUBZKU12KxNlmDcE7knLOui6NQdsUvFpuI/Rzgr')
|
||||
Synced walletState:
|
||||
WalletState(sequence=4, encrypted_wallet='czo4MTkyOjE2OjE6ZAO02VSfc0UTNcKJosuTzdpB1GCRw+f1bCrR/1aFDGoK5Iq/OyKXygp3p2trj2EU1SUfp6m/FiWYdN920uzpaQnIbOlEs6anPpd3alNQmNfuT1s8bKnliO6so657VjZf0QdadDrCVa8WZMiuHY+wP2H5LpzDIrRYrzNyyUuhffbh8yk8cQhgRScFKczpAnu+')
|
||||
'Success'
|
||||
```
|
||||
|
||||
|
|
@ -136,8 +134,8 @@ Eventually, the client will be responsible (or at least more responsible) for me
|
|||
|
||||
```
|
||||
>>> c2.get_remote_wallet()
|
||||
Got latest walletState:
|
||||
WalletState(sequence=4, encrypted_wallet='czo4MTkyOjE2OjE66nridrsrXcL/DlcudUs7RaAIZ3jRYQJhaacRH3vPNx0TZqkJbDcjMiHbiHY6U2AVhoAsLPIf/zcU+uDTw4IRcOL9Gozupc8tCrIcgm/kwXjnQI9RNzIfDsFxalBKj0u7Xf0c+5f/ntr4Hs9Q/Y7qthseNbUBZKU12KxNlmDcE7knLOui6NQdsUvFpuI/Rzgr')
|
||||
Got (and maybe merged in) latest walletState:
|
||||
WalletState(sequence=4, encrypted_wallet='czo4MTkyOjE2OjE6ZAO02VSfc0UTNcKJosuTzdpB1GCRw+f1bCrR/1aFDGoK5Iq/OyKXygp3p2trj2EU1SUfp6m/FiWYdN920uzpaQnIbOlEs6anPpd3alNQmNfuT1s8bKnliO6so657VjZf0QdadDrCVa8WZMiuHY+wP2H5LpzDIrRYrzNyyUuhffbh8yk8cQhgRScFKczpAnu+')
|
||||
'Success'
|
||||
>>> c2.get_preferences()
|
||||
{'animal': 'horse', 'car': 'Audi'}
|
||||
|
|
@ -148,12 +146,12 @@ Finally, the client with the merged wallet pushes it to the server, and the othe
|
|||
```
|
||||
>>> c2.update_remote_wallet()
|
||||
Successfully updated wallet state on server
|
||||
Got new walletState:
|
||||
WalletState(sequence=5, encrypted_wallet='czo4MTkyOjE2OjE68NAahtUE4gg2M6Fam/E3brb4sv1TzcXJLvGRh4CY4416haOF1lxmKSdrvIPpOBvpNPS0B5qCbmpaKQ8Pm/WRCLj1yYUDVKgSZx0ru7AJBHiBLtpKA99Ia7XlWl129p6WtjJkbOoW8Ya+PEii72g4nrtM+j40Xe9UbVI463tlKYaRvmKr/BcoFGMJSB10Whh8')
|
||||
Synced walletState:
|
||||
WalletState(sequence=5, encrypted_wallet='czo4MTkyOjE2OjE6cat6gX80ib+t6bX9QlBw3jspj4jJ6U8AGULRDPNa8PbL4CX6ohZoXkt+duNYPxWDdyl8xqhwisWXTXkuGUBwP2zrVmZC3TNt5A9Pk/y/tNgMz50CY3JmNYcbCeZyoY+uV+cMfdO+n3p3hYriNKgn539NC6ug80U/2heevVax4NgMAF0lWEBM2E886+KkvfHG')
|
||||
'Success'
|
||||
>>> c1.get_remote_wallet()
|
||||
Got latest walletState:
|
||||
WalletState(sequence=5, encrypted_wallet='czo4MTkyOjE2OjE68NAahtUE4gg2M6Fam/E3brb4sv1TzcXJLvGRh4CY4416haOF1lxmKSdrvIPpOBvpNPS0B5qCbmpaKQ8Pm/WRCLj1yYUDVKgSZx0ru7AJBHiBLtpKA99Ia7XlWl129p6WtjJkbOoW8Ya+PEii72g4nrtM+j40Xe9UbVI463tlKYaRvmKr/BcoFGMJSB10Whh8')
|
||||
Got (and maybe merged in) latest walletState:
|
||||
WalletState(sequence=5, encrypted_wallet='czo4MTkyOjE2OjE6cat6gX80ib+t6bX9QlBw3jspj4jJ6U8AGULRDPNa8PbL4CX6ohZoXkt+duNYPxWDdyl8xqhwisWXTXkuGUBwP2zrVmZC3TNt5A9Pk/y/tNgMz50CY3JmNYcbCeZyoY+uV+cMfdO+n3p3hYriNKgn539NC6ug80U/2heevVax4NgMAF0lWEBM2E886+KkvfHG')
|
||||
'Success'
|
||||
>>> c1.get_preferences()
|
||||
{'animal': 'horse', 'car': 'Audi'}
|
||||
|
|
@ -178,29 +176,34 @@ So for example, let's say we create diverging changes in the wallets:
|
|||
{'animal': 'horse', 'car': 'Toyota'}
|
||||
```
|
||||
|
||||
We try to POST both of them to the server, but the second one fails because of the conflict. Instead, merges the two locally:
|
||||
We try to POST both of them to the server. The second one fails because of the conflict, and we see that its preferences don't change yet.
|
||||
|
||||
```
|
||||
>>> c2.update_remote_wallet()
|
||||
Successfully updated wallet state on server
|
||||
Got new walletState:
|
||||
WalletState(sequence=6, encrypted_wallet='czo4MTkyOjE2OjE6sh95Bt0OfcDY3QwUWaPgPWD1WPYCkN2yg1+XLD/5puONhNyjzVAnhINqVvPy52pxfkVgkIScLacMQFq4W19d+SC5LConu+fPchBzYj14Wvc3/IEQiQIxbmkv6N9USvYsjAzjGqK7szistRJY4MHC4/wRbWRprfIE7BFcDaisFSe18mRs8D2KlhEzjNJu+X8+')
|
||||
Synced walletState:
|
||||
WalletState(sequence=6, encrypted_wallet='czo4MTkyOjE2OjE6IQ+uyjKiGAIEjoNliOsANoq2h/exQpwordUQFVbbHVhj27UbJS7ykMV4or5avEwNo+aCYC8j7HEqqaPnhvNYeeyPbmpfZS0lU7MXBehoqvIPR3GyTLM002t7SUrB+KxdvUX8RAamjiahDI8OeTOBmYhgQLSZt/ZDtRL/3f5l1JgLCjEbVKJY6Pim0hk7AlpK')
|
||||
'Success'
|
||||
>>> c1.update_remote_wallet()
|
||||
Wallet state out of date. Getting updated wallet state. Try posting again after this.
|
||||
Got new walletState:
|
||||
WalletState(sequence=6, encrypted_wallet='czo4MTkyOjE2OjE6sh95Bt0OfcDY3QwUWaPgPWD1WPYCkN2yg1+XLD/5puONhNyjzVAnhINqVvPy52pxfkVgkIScLacMQFq4W19d+SC5LConu+fPchBzYj14Wvc3/IEQiQIxbmkv6N9USvYsjAzjGqK7szistRJY4MHC4/wRbWRprfIE7BFcDaisFSe18mRs8D2KlhEzjNJu+X8+')
|
||||
Submitted wallet is out of date.
|
||||
Could not update. Need to get new wallet and merge
|
||||
'Failure'
|
||||
>>> c1.get_preferences()
|
||||
{'animal': 'horse', 'car': 'Toyota'}
|
||||
```
|
||||
|
||||
The client that is out of date will then call `get_remote_wallet`, which GETs and automatically merges in the latest wallet. We see the preferences are now merged. Now it can make a second POST request containing the merged wallet.
|
||||
|
||||
```
|
||||
>>> c1.get_remote_wallet()
|
||||
Got (and maybe merged in) latest walletState:
|
||||
WalletState(sequence=6, encrypted_wallet='czo4MTkyOjE2OjE6IQ+uyjKiGAIEjoNliOsANoq2h/exQpwordUQFVbbHVhj27UbJS7ykMV4or5avEwNo+aCYC8j7HEqqaPnhvNYeeyPbmpfZS0lU7MXBehoqvIPR3GyTLM002t7SUrB+KxdvUX8RAamjiahDI8OeTOBmYhgQLSZt/ZDtRL/3f5l1JgLCjEbVKJY6Pim0hk7AlpK')
|
||||
'Success'
|
||||
>>> c1.get_preferences()
|
||||
{'animal': 'beaver', 'car': 'Toyota'}
|
||||
```
|
||||
|
||||
Now that the merge is complete, the client can make a second POST request containing the merged wallet.
|
||||
|
||||
```
|
||||
>>> c1.update_remote_wallet()
|
||||
Successfully updated wallet state on server
|
||||
Got new walletState:
|
||||
WalletState(sequence=7, encrypted_wallet='czo4MTkyOjE2OjE68J19IGGfoiRDm15Nb1sTj5yP9Mc3jpAeYarh206kLXKMKLKCIahmhLDMqBCXgwDe098uaIqB6IwKDfXbCVJHhWfqzu/5GoWPK1QZjhCu0rGxteFv4Tio0IYGg8CUYCvOhpQA319SXEf4sF9cyC32VwlL6qkJ2TzWTu9bTGUfZRGV3q9Rt9oL4OQHxuNIPEiE')
|
||||
Synced walletState:
|
||||
WalletState(sequence=7, encrypted_wallet='czo4MTkyOjE2OjE63OwBCfczOA+n0EMe0lHPwVvmrXsJwKJXGPYFSmdDseHbd3HRpOZ/Id5WeOuata5/dHJ4vdaaw8RNfpgR4KVzOkM5BUZNxzBaVf/BEYL8nJcbv7l5ZLs6Q15IqvlmZ3HBPVzxO/WYqm4aL9+CNeoYG2LzaIxsnzf31ZoG9I78B6wxK5JXCjDS+nuh/4NM+REE')
|
||||
'Success'
|
||||
```
|
||||
|
|
|
|||
|
|
@ -67,8 +67,6 @@ print("""
|
|||
## Syncing
|
||||
|
||||
Create a new wallet + metadata (we'll wrap it in a struct we'll call `WalletState` in this client) using `init_wallet_state` and POST them to the server. The metadata (as of now) in the walletstate is only `sequence`. `sequence` is an integer that increments for every POSTed wallet. This is bookkeeping to prevent certain syncing errors.
|
||||
|
||||
_Note that after POSTing, it says it "got" a new wallet. This is because the POST endpoint also returns the latest version. The purpose of this will be explained in "Conflicts" below._
|
||||
""")
|
||||
|
||||
code_block("""
|
||||
|
|
@ -77,13 +75,14 @@ c1.update_remote_wallet()
|
|||
""")
|
||||
|
||||
print("""
|
||||
Now, call `init_wallet_state` with the other client. This time, `init_wallet_state` will GET the wallet from the server. In general, `init_wallet_state` is used to set up a new client; first it checks the server, then failing that, it initializes it locally. (In a real client, it would save the walletstate to disk, and `init_wallet_state` would check there before checking the server).
|
||||
Now, call `init_wallet_state` with the other client. Then, we call `get_remote_wallet` to GET the wallet from the server. (In a real client, it would also save the walletstate to disk, and `init_wallet_state` would check there before checking the server).
|
||||
|
||||
(There are a few potential unresolved issues surrounding this related to sequence of events. Check comments on `init_wallet_state`. SDK again works around them with the timestamps.)
|
||||
""")
|
||||
|
||||
code_block("""
|
||||
c2.init_wallet_state()
|
||||
c2.get_remote_wallet()
|
||||
""")
|
||||
|
||||
print("""
|
||||
|
|
@ -183,7 +182,7 @@ c1.get_preferences()
|
|||
""")
|
||||
|
||||
print("""
|
||||
We try to POST both of them to the server, but the second one fails because of the conflict. Instead, merges the two locally:
|
||||
We try to POST both of them to the server. The second one fails because of the conflict, and we see that its preferences don't change yet.
|
||||
""")
|
||||
|
||||
code_block("""
|
||||
|
|
@ -193,9 +192,11 @@ c1.get_preferences()
|
|||
""")
|
||||
|
||||
print("""
|
||||
Now that the merge is complete, the client can make a second POST request containing the merged wallet.
|
||||
The client that is out of date will then call `get_remote_wallet`, which GETs and automatically merges in the latest wallet. We see the preferences are now merged. Now it can make a second POST request containing the merged wallet.
|
||||
""")
|
||||
|
||||
code_block("""
|
||||
c1.get_remote_wallet()
|
||||
c1.get_preferences()
|
||||
c1.update_remote_wallet()
|
||||
""")
|
||||
|
|
|
|||
|
|
@ -58,7 +58,7 @@ class LBRYSDK():
|
|||
|
||||
class WalletSync():
|
||||
def __init__(self, local):
|
||||
self.API_VERSION = 1
|
||||
self.API_VERSION = 2
|
||||
|
||||
if local:
|
||||
BASE_URL = 'http://localhost:8090'
|
||||
|
|
@ -131,24 +131,16 @@ class WalletSync():
|
|||
response = requests.post(self.WALLET_URL, body)
|
||||
|
||||
if response.status_code == 200:
|
||||
conflict = False
|
||||
print ('Successfully updated wallet state on server')
|
||||
return True
|
||||
elif response.status_code == 409:
|
||||
conflict = True
|
||||
print ('Wallet state out of date. Getting updated wallet state. Try posting again after this.')
|
||||
# Not an error! We still want to merge in the returned wallet.
|
||||
print ('Submitted wallet is out of date.')
|
||||
return False
|
||||
else:
|
||||
print ('Error', response.status_code)
|
||||
print (response.content)
|
||||
raise Exception("Unexpected status code")
|
||||
|
||||
wallet_state = WalletState(
|
||||
encrypted_wallet=response.json()['encryptedWallet'],
|
||||
sequence=response.json()['sequence'],
|
||||
)
|
||||
hmac = response.json()['hmac']
|
||||
return wallet_state, hmac, conflict
|
||||
|
||||
def derive_secrets(root_password, salt):
|
||||
# TODO - Audit me audit me audit me! I don't know if these values are
|
||||
# optimal.
|
||||
|
|
@ -256,31 +248,23 @@ class Client():
|
|||
# now, the SDK handles merges with timestamps and such so it's as safe as
|
||||
# always to just merge in.
|
||||
|
||||
# TODO - Be careful of cases where get_remote_wallet comes back with "Not
|
||||
# Found" even though a wallet is actually on the server. We would start with
|
||||
# sequence=0 with the local encrypted wallet. Then next time we
|
||||
# get_remote_wallet, it returns the actual wallet, let's say sequence=5, and
|
||||
# it would write over what's locally saved. With the SDK as it is using
|
||||
# sync_apply, that's okay because it has a decent way of merging it. However
|
||||
# when the Desktop is in charge of merging, this could be a hazard. Saving
|
||||
# the state to disk could help. Or perhaps pushing first before pulling. Or
|
||||
# maybe if we're writing over sequence=0, we can know we should be "merging"
|
||||
# the local encrypted wallet with whatever comes from the server.
|
||||
# TODO - Save wallet state to disk, and init by pulling from disk. That way,
|
||||
# we'll know what the merge base is, and we won't have to merge from 0 each
|
||||
# time the app restarts.
|
||||
|
||||
# TODO - what if two clients initialize, make changes, and then both push?
|
||||
# We'll need a way to "merge" from a merge base of an empty wallet.
|
||||
# TODO - Wrap this back into __init__, now that I got the empty encrypted
|
||||
# wallet right.
|
||||
def init_wallet_state(self):
|
||||
if self.get_remote_wallet() == "Not Found":
|
||||
print("No wallet found on the server for this account. Starting a new one.")
|
||||
|
||||
# Represents what's been synced to the wallet sync server. It starts with
|
||||
# sequence=0 which means nothing has been synced yet. We start with
|
||||
# whatever is in the SDK. Whether it's new or not, we (who choose to run
|
||||
# this method) are assuming it's not synced yet.
|
||||
self.synced_wallet_state = WalletState(
|
||||
sequence=0,
|
||||
encrypted_wallet=self.get_local_encrypted_wallet()
|
||||
)
|
||||
# Represents what's been synced to the wallet sync server. It starts with
|
||||
# sequence=0 which means nothing has been synced yet. As such, we start
|
||||
# with an empty encrypted_wallet here. Anything currently in the SDK is a
|
||||
# local-only change until it's pushed. If there's a merge conflict,
|
||||
# sequence=0, empty encrypted_wallet will be the merge base. That way we
|
||||
# won't lose any changes.
|
||||
self.synced_wallet_state = WalletState(
|
||||
sequence=0,
|
||||
encrypted_wallet="",
|
||||
)
|
||||
|
||||
def register(self):
|
||||
success = self.wallet_sync_api.register(
|
||||
|
|
@ -308,6 +292,29 @@ class Client():
|
|||
# we're talking about. Again, we should see how LBRY Desktop/SDK deal with
|
||||
# it.
|
||||
|
||||
def get_merged_wallet_state(self, new_wallet_state):
|
||||
# Eventually, we will look for local changes in
|
||||
# `get_local_encrypted_wallet()` by comparing it to
|
||||
# `self.synced_wallet_state.encrypted_wallet`.
|
||||
#
|
||||
# If there are no local changes, we can just return `new_wallet_state`.
|
||||
#
|
||||
# If there are local changes, we will merge between `new_wallet_state` and
|
||||
# `get_local_encrypted_wallet()`, using
|
||||
# `self.synced_wallet_state.encrypted_wallet` as our merge base.
|
||||
#
|
||||
# For really hairy cases, this could even be a whole interactive process,
|
||||
# not just a function.
|
||||
|
||||
# For now, the SDK handles merging (in a way that we hope to improve with
|
||||
# the above eventually) so we will just return `new_wallet_state`.
|
||||
#
|
||||
# It would be nice to have a little "we just merged in changes" log output
|
||||
# if there are local changes, just for demo purpoes. Unfortunately, the SDK
|
||||
# outputs a different encrypted blob each time we ask it for the encrypted
|
||||
# wallet, so there's no easy way to check if it actually changed.
|
||||
return new_wallet_state
|
||||
|
||||
# Returns: status
|
||||
def get_remote_wallet(self):
|
||||
new_wallet_state, hmac = self.wallet_sync_api.get_wallet(self.auth_token)
|
||||
|
|
@ -327,11 +334,14 @@ class Client():
|
|||
print ('got:', new_wallet_state)
|
||||
return "Error"
|
||||
|
||||
self.synced_wallet_state = new_wallet_state
|
||||
# TODO errors? sequence of events? This isn't gonna be quite right. Look at state diagrams.
|
||||
self.update_local_encrypted_wallet(new_wallet_state.encrypted_wallet)
|
||||
merged_wallet_state = self.get_merged_wallet_state(new_wallet_state)
|
||||
|
||||
print ("Got latest walletState:")
|
||||
# TODO error recovery between these two steps? sequence of events?
|
||||
# This isn't gonna be quite right. Look at state diagrams.
|
||||
self.synced_wallet_state = merged_wallet_state
|
||||
self.update_local_encrypted_wallet(merged_wallet_state.encrypted_wallet)
|
||||
|
||||
print ("Got (and maybe merged in) latest walletState:")
|
||||
pprint(self.synced_wallet_state)
|
||||
return "Success"
|
||||
|
||||
|
|
@ -351,31 +361,19 @@ class Client():
|
|||
)
|
||||
hmac = create_hmac(submitted_wallet_state, self.hmac_key)
|
||||
|
||||
# Submit our wallet, get the latest wallet back as a response
|
||||
new_wallet_state, new_hmac, conflict = self.wallet_sync_api.update_wallet(submitted_wallet_state, hmac, self.auth_token)
|
||||
# Submit our wallet.
|
||||
updated = self.wallet_sync_api.update_wallet(submitted_wallet_state, hmac, self.auth_token)
|
||||
|
||||
# TODO - there's some code in common here with the get_remote_wallet function. factor it out.
|
||||
if updated:
|
||||
# We updated it. Now it's synced and we mark it as such.
|
||||
self.synced_wallet_state = submitted_wallet_state
|
||||
|
||||
if not check_hmac(new_wallet_state, self.hmac_key, new_hmac):
|
||||
print ('Error - bad hmac on new wallet')
|
||||
print (new_wallet_state, hmac)
|
||||
return "Error"
|
||||
print ("Synced walletState:")
|
||||
pprint(self.synced_wallet_state)
|
||||
return "Success"
|
||||
|
||||
if submitted_wallet_state != new_wallet_state and not self._validate_new_wallet_state(new_wallet_state):
|
||||
print ('Error - new wallet does not validate')
|
||||
print ('current:', self.synced_wallet_state)
|
||||
print ('got:', new_wallet_state)
|
||||
return "Error"
|
||||
|
||||
# TODO - `concflict` determines whether we need to a smart merge here.
|
||||
# However for now the SDK handles all of that.
|
||||
self.synced_wallet_state = new_wallet_state
|
||||
# TODO errors? sequence of events? This isn't gonna be quite right. Look at state diagrams.
|
||||
self.update_local_encrypted_wallet(new_wallet_state.encrypted_wallet)
|
||||
|
||||
print ("Got new walletState:")
|
||||
pprint(self.synced_wallet_state)
|
||||
return "Success"
|
||||
print ("Could not update. Need to get new wallet and merge")
|
||||
return "Failure"
|
||||
|
||||
def set_preference(self, key, value):
|
||||
# TODO - error checking
|
||||
|
|
|
|||
Loading…
Reference in a new issue