-
Notifications
You must be signed in to change notification settings - Fork 0
/
accessors.go
124 lines (106 loc) · 3.02 KB
/
accessors.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
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
/*
* Copyright 2019 Insolar Technologies
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package logicrunner
import (
"context"
"github.com/insolar/insolar/core"
"github.com/pkg/errors"
)
// RegisterExecutor registers an executor for particular `MachineType`
func (lr *LogicRunner) RegisterExecutor(t core.MachineType, e core.MachineLogicExecutor) error {
lr.Executors[int(t)] = e
return nil
}
// GetExecutor returns an executor for the `MachineType` if it was registered (`RegisterExecutor`),
// returns error otherwise
func (lr *LogicRunner) GetExecutor(t core.MachineType) (core.MachineLogicExecutor, error) {
if res := lr.Executors[int(t)]; res != nil {
return res, nil
}
return nil, errors.Errorf("No executor registered for machine %d", int(t))
}
func (lr *LogicRunner) GetObjectState(ref Ref) *ObjectState {
lr.stateMutex.RLock()
res, ok := lr.state[ref]
lr.stateMutex.RUnlock()
if !ok {
return nil
}
return res
}
func (lr *LogicRunner) UpsertObjectState(ref Ref) *ObjectState {
lr.stateMutex.RLock()
if res, ok := lr.state[ref]; ok {
lr.stateMutex.RUnlock()
return res
}
lr.stateMutex.RUnlock()
lr.stateMutex.Lock()
defer lr.stateMutex.Unlock()
if _, ok := lr.state[ref]; !ok {
lr.state[ref] = &ObjectState{}
}
return lr.state[ref]
}
func (lr *LogicRunner) MustObjectState(ref Ref) *ObjectState {
res := lr.GetObjectState(ref)
if res == nil {
panic("No requested object state. ref: " + ref.String())
}
return res
}
func (lr *LogicRunner) pulse(ctx context.Context) *core.Pulse {
pulse, err := lr.PulseStorage.Current(ctx)
if err != nil {
panic(err)
}
return pulse
}
func (lr *LogicRunner) GetConsensus(ctx context.Context, ref Ref) *Consensus {
state := lr.UpsertObjectState(ref)
state.Lock()
defer state.Unlock()
if state.Consensus == nil {
validators, err := lr.JetCoordinator.QueryRole(
ctx,
core.DynamicRoleVirtualValidator,
*ref.Record(),
lr.pulse(ctx).PulseNumber,
)
if err != nil {
panic("cannot QueryRole")
}
// TODO INS-732 check pulse of message and ensure we deal with right validator
state.Consensus = newConsensus(lr, validators)
}
return state.Consensus
}
func (st *ObjectState) RefreshConsensus() {
if st.Consensus == nil {
return
}
st.Consensus.ready = true
st.Consensus = nil
}
func (st *ObjectState) StartValidation(ref Ref) *ExecutionState {
st.Lock()
defer st.Unlock()
if st.Validation != nil {
panic("Unexpected. Validation already in progress")
}
st.Validation = &ExecutionState{Ref: ref}
return st.Validation
}