/
promises.go
92 lines (79 loc) · 2.52 KB
/
promises.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
package sign
import (
"encoding/hex"
"errors"
cAPI "dfss/dfssc/api"
dAPI "dfss/dfssd/api"
pAPI "dfss/dfssp/api"
"dfss/net"
"golang.org/x/net/context"
)
func (m *SignatureManager) createContext(from, to uint32) (*cAPI.Context, error) {
if int(from) >= len(m.keyHash) || int(to) >= len(m.keyHash) {
return nil, errors.New("Invalid id for context creation")
}
h, _ := hex.DecodeString(m.contract.File.Hash)
return &cAPI.Context{
RecipientKeyHash: m.keyHash[to],
SenderKeyHash: m.keyHash[from],
Sequence: m.sequence,
Signers: m.keyHash,
ContractDocumentHash: h,
SignatureUUID: m.uuid,
TtpAddrPort: m.ttpData.Addrport,
TtpHash: m.ttpData.Hash,
Seal: m.seal,
}, nil
}
// CreatePromise creates a promise from 'from' to 'to', in the context of the SignatureManager
// provided that the specified sequence indexes are valid
func (m *SignatureManager) CreatePromise(from, to, at uint32) (*cAPI.Promise, error) {
context, err := m.createContext(from, to)
if err != nil {
return nil, err
}
if m.currentIndex < 0 {
return nil, errors.New("Invalid currentIndex for promise creation")
}
return &cAPI.Promise{
Index: at,
Context: context,
Payload: []byte{0x41},
}, nil
}
// SendEvidence factorizes the send code between promises and signatures.
// You can use it by setting either promise or signature to `nil`.
// The successfully sent evidence is then added to the archives.
func (m *SignatureManager) SendEvidence(promise *cAPI.Promise, signature *cAPI.Signature, to uint32) (err error) {
connection, mail := m.GetClient(to)
if connection == nil {
return
}
ctx, cancel := context.WithTimeout(context.Background(), net.DefaultTimeout)
defer cancel()
var result *pAPI.ErrorCode
if promise != nil {
result, err = (*connection).TreatPromise(ctx, promise)
} else if signature != nil {
result, err = (*connection).TreatSignature(ctx, signature)
} else {
err = errors.New("both promise and signature are nil, cannot send anything")
}
if err == nil && result != nil && result.Code == pAPI.ErrorCode_SUCCESS {
m.archives.mutex.Lock()
if promise != nil {
dAPI.DLog("successfully sent promise to " + mail)
} else {
dAPI.DLog("successfully sent signature to " + mail)
m.archives.sentSignatures = append(m.archives.sentSignatures, signature)
}
m.archives.mutex.Unlock()
} else {
dAPI.DLog("was unable to send evidence to " + mail)
if err != nil {
return
}
err = errors.New("received wrong error code")
}
return
}