/
op_ExecuteTransaction.go
146 lines (114 loc) · 4.93 KB
/
op_ExecuteTransaction.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
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
package dyno
import (
"context"
ddb "github.com/aws/aws-sdk-go-v2/service/dynamodb"
"sync"
)
// ExecuteTransaction executes ExecuteTransaction operation and returns a ExecuteTransaction operation
func (s *Session) ExecuteTransaction(input *ddb.ExecuteTransactionInput, mw ...ExecuteTransactionMiddleWare) *ExecuteTransaction {
return NewExecuteTransaction(input, mw...).Invoke(s.ctx, s.ddb)
}
// ExecuteTransaction executes a ExecuteTransaction operation with a ExecuteTransactionInput in this pool and returns the ExecuteTransaction operation
func (p *Pool) ExecuteTransaction(input *ddb.ExecuteTransactionInput, mw ...ExecuteTransactionMiddleWare) *ExecuteTransaction {
op := NewExecuteTransaction(input, mw...)
p.Do(op) // run the operation in the pool
return op
}
// ExecuteTransactionContext represents an exhaustive ExecuteTransaction operation request context
type ExecuteTransactionContext struct {
context.Context
Input *ddb.ExecuteTransactionInput
Client *ddb.Client
}
// ExecuteTransactionOutput represents the output for the ExecuteTransaction operation
type ExecuteTransactionOutput struct {
out *ddb.ExecuteTransactionOutput
err error
mu sync.RWMutex
}
// Set sets the output
func (o *ExecuteTransactionOutput) Set(out *ddb.ExecuteTransactionOutput, err error) {
o.mu.Lock()
o.out = out
o.err = err
o.mu.Unlock()
}
// Get gets the output
func (o *ExecuteTransactionOutput) Get() (out *ddb.ExecuteTransactionOutput, err error) {
o.mu.Lock()
out = o.out
err = o.err
o.mu.Unlock()
return
}
// ExecuteTransactionHandler represents a handler for ExecuteTransaction requests
type ExecuteTransactionHandler interface {
HandleExecuteTransaction(ctx *ExecuteTransactionContext, output *ExecuteTransactionOutput)
}
// ExecuteTransactionHandlerFunc is a ExecuteTransactionHandler function
type ExecuteTransactionHandlerFunc func(ctx *ExecuteTransactionContext, output *ExecuteTransactionOutput)
// HandleExecuteTransaction implements ExecuteTransactionHandler
func (h ExecuteTransactionHandlerFunc) HandleExecuteTransaction(ctx *ExecuteTransactionContext, output *ExecuteTransactionOutput) {
h(ctx, output)
}
// ExecuteTransactionFinalHandler is the final ExecuteTransactionHandler that executes a dynamodb ExecuteTransaction operation
type ExecuteTransactionFinalHandler struct{}
// HandleExecuteTransaction implements the ExecuteTransactionHandler
func (h *ExecuteTransactionFinalHandler) HandleExecuteTransaction(ctx *ExecuteTransactionContext, output *ExecuteTransactionOutput) {
output.Set(ctx.Client.ExecuteTransaction(ctx, ctx.Input))
}
// ExecuteTransactionMiddleWare is a middleware function use for wrapping ExecuteTransactionHandler requests
type ExecuteTransactionMiddleWare interface {
ExecuteTransactionMiddleWare(next ExecuteTransactionHandler) ExecuteTransactionHandler
}
// ExecuteTransactionMiddleWareFunc is a functional ExecuteTransactionMiddleWare
type ExecuteTransactionMiddleWareFunc func(next ExecuteTransactionHandler) ExecuteTransactionHandler
// ExecuteTransactionMiddleWare implements the ExecuteTransactionMiddleWare interface
func (mw ExecuteTransactionMiddleWareFunc) ExecuteTransactionMiddleWare(next ExecuteTransactionHandler) ExecuteTransactionHandler {
return mw(next)
}
// ExecuteTransaction represents a ExecuteTransaction operation
type ExecuteTransaction struct {
*BaseOperation
input *ddb.ExecuteTransactionInput
middleWares []ExecuteTransactionMiddleWare
}
// NewExecuteTransaction creates a new ExecuteTransaction operation
func NewExecuteTransaction(input *ddb.ExecuteTransactionInput, mws ...ExecuteTransactionMiddleWare) *ExecuteTransaction {
return &ExecuteTransaction{
BaseOperation: NewOperation(),
input: input,
middleWares: mws,
}
}
// Invoke invokes the ExecuteTransaction operation in a goroutine and returns a ExecuteTransaction operation
func (op *ExecuteTransaction) Invoke(ctx context.Context, client *ddb.Client) *ExecuteTransaction {
op.SetRunning() // operation now waiting for a response
go op.InvokeDynoOperation(ctx, client)
return op
}
// InvokeDynoOperation invokes the ExecuteTransaction operation
func (op *ExecuteTransaction) InvokeDynoOperation(ctx context.Context, client *ddb.Client) {
output := new(ExecuteTransactionOutput)
defer func() { op.SetResponse(output.Get()) }()
var h ExecuteTransactionHandler
h = new(ExecuteTransactionFinalHandler)
// loop in reverse to preserve middleware order
for i := len(op.middleWares) - 1; i >= 0; i-- {
h = op.middleWares[i].ExecuteTransactionMiddleWare(h)
}
requestCtx := &ExecuteTransactionContext{
Context: ctx,
Client: client,
Input: op.input,
}
h.HandleExecuteTransaction(requestCtx, output)
}
// Await waits for the ExecuteTransaction operation to be fulfilled and then returns a ExecuteTransactionOutput and error
func (op *ExecuteTransaction) Await() (*ddb.ExecuteTransactionOutput, error) {
out, err := op.BaseOperation.Await()
if out == nil {
return nil, err
}
return out.(*ddb.ExecuteTransactionOutput), err
}