-
Notifications
You must be signed in to change notification settings - Fork 0
/
module_service.go
106 lines (87 loc) · 3.17 KB
/
module_service.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
package keeper
import (
tmbytes "github.com/tendermint/tendermint/libs/bytes"
sdk "github.com/cosmos/cosmos-sdk/types"
sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
"github.com/furynet/furymod/modules/service/types"
)
// RegisterModuleService registers a module service
func (k Keeper) RegisterModuleService(moduleName string, moduleService *types.ModuleService) error {
if _, ok := k.moduleServices[moduleName]; ok {
return sdkerrors.Wrapf(types.ErrModuleServiceRegistered, "%s already registered for module %s", "module service", moduleName)
}
k.SetModuleService(moduleName, moduleService)
return nil
}
// SetModuleService sets the module service for the given module
func (k Keeper) SetModuleService(moduleName string, moduleService *types.ModuleService) {
k.moduleServices[moduleName] = moduleService
}
func (k Keeper) GetModuleServiceByModuleName(moduleName string) (*types.ModuleService, bool) {
if k.moduleServices[moduleName] == nil {
return &types.ModuleService{}, false
}
return k.moduleServices[moduleName], true
}
func (k Keeper) GetModuleServiceByServiceName(serviceName string) (string, *types.ModuleService, bool) {
for moduleName, mdouleSvc := range k.moduleServices {
if mdouleSvc.ServiceName == serviceName {
return moduleName, mdouleSvc, true
}
}
return "", nil, false
}
func (k Keeper) RequestModuleService(
ctx sdk.Context,
moduleService *types.ModuleService,
reqContextID tmbytes.HexBytes,
consumer sdk.AccAddress,
input string,
) error {
requestContext, found := k.GetRequestContext(ctx, reqContextID)
if !found {
return sdkerrors.Wrap(types.ErrUnknownRequestContext, reqContextID.String())
}
requestContextConsumer, _ := sdk.AccAddressFromBech32(requestContext.Consumer)
pds := make([]sdk.AccAddress, len(requestContext.Providers))
for i, provider := range requestContext.Providers {
pd, err := sdk.AccAddressFromBech32(provider)
if err != nil {
return sdkerrors.Wrapf(sdkerrors.ErrInvalidAddress, "invalid provider address: %s", provider)
}
pds[i] = pd
}
_, totalPrices, _, err := k.FilterServiceProviders(
ctx,
requestContext.ServiceName,
pds,
requestContext.Timeout,
requestContext.ServiceFeeCap,
requestContextConsumer,
)
if err != nil {
return err
}
if err := k.DeductServiceFees(ctx, consumer, totalPrices); err != nil {
return err
}
requestIDs := k.InitiateRequests(ctx, reqContextID, []sdk.AccAddress{moduleService.Provider}, make(map[string][]string))
result, output := moduleService.ReuquestService(ctx, input)
request, _, err := k.AddResponse(ctx, requestIDs[0], moduleService.Provider, result, output)
if err != nil {
return err
}
requestContext.State = types.COMPLETED
k.SetRequestContext(ctx, reqContextID, requestContext)
ctx.EventManager().EmitEvents(sdk.Events{
sdk.NewEvent(
types.EventTypeRespondService,
sdk.NewAttribute(types.AttributeKeyRequestContextID, request.RequestContextId),
sdk.NewAttribute(types.AttributeKeyRequestID, requestIDs[0].String()),
sdk.NewAttribute(types.AttributeKeyServiceName, request.ServiceName),
sdk.NewAttribute(types.AttributeKeyProvider, request.Provider),
sdk.NewAttribute(types.AttributeKeyConsumer, request.Consumer),
),
})
return nil
}