Mirroristas/planetmint-go
2
0
Fork 0
mirror of https://github.com/planetmint/planetmint-go.git synced 2025-03-30 15:08:28 +00:00
Code Issues Packages Projects Releases Wiki Activity

add GetMachineByAddress capabilities

Browse Source 
Signed-off-by: Lorenz Herzberger <lorenzherzberger@gmail.com>
This commit is contained in:
Lorenz Herzberger 2023-09-21 11:36:01 +02:00
parent d4eed021c8
commit 86a85913cf
No known key found for this signature in database
GPG Key ID: FA5EE906EB55316A
29 changed files with 1052 additions and 82 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
app/ante/ante.go
View File

@ -29,7 +29,7 @@ func (cm CheckMachineDecorator) AnteHandle(ctx sdk.Context, tx sdk.Tx, simulate
case "/planetmintgo.asset.MsgNotarizeAsset":
notarizeMsg, ok := msg.(*assettypes.MsgNotarizeAsset)
if ok {
_, found := cm.mk.GetMachineIndex(ctx, notarizeMsg.PubKey)
_, found := cm.mk.GetMachineIndexByPubKey(ctx, notarizeMsg.PubKey)
if !found {
return ctx, errorsmod.Wrapf(machinetypes.ErrMachineNotFound, "error during CheckTx or ReCheckTx")
}

2
app/ante/expected_keepers.go
View File

@ -8,7 +8,7 @@ import (
)
type MachineKeeper interface {
GetMachineIndex(ctx sdk.Context, pubKey string) (val types.MachineIndex, found bool)
GetMachineIndexByPubKey(ctx sdk.Context, pubKey string) (val types.MachineIndex, found bool)
GetTrustAnchor(ctx sdk.Context, pubKey string) (val types.TrustAnchor, activated bool, found bool)
}

3
app/app.go
View File

@ -313,7 +313,7 @@ func New(
feegrant.StoreKey, evidencetypes.StoreKey, ibctransfertypes.StoreKey, icahosttypes.StoreKey,
capabilitytypes.StoreKey, group.StoreKey, icacontrollertypes.StoreKey, consensusparamtypes.StoreKey,
machinemoduletypes.StoreKey, machinemoduletypes.TAIndexKey, machinemoduletypes.IssuerPlanetmintIndexKey, machinemoduletypes.IssuerLiquidIndexKey,
machinemoduletypes.TrustAnchorKey,
machinemoduletypes.TrustAnchorKey, machinemoduletypes.AddressIndexKey,
assetmoduletypes.StoreKey,
daomoduletypes.StoreKey,
// this line is used by starport scaffolding # stargate/app/storeKey
@ -545,6 +545,7 @@ func New(
keys[machinemoduletypes.IssuerPlanetmintIndexKey],
keys[machinemoduletypes.IssuerLiquidIndexKey],
keys[machinemoduletypes.TrustAnchorKey],
keys[machinemoduletypes.AddressIndexKey],
keys[machinemoduletypes.MemStoreKey],
app.GetSubspace(machinemoduletypes.ModuleName),
)

10
config/config.go
View File

@ -2,6 +2,8 @@ package config
import (
"encoding/json"
"os/user"
"path/filepath"
"sync"
)
@ -17,6 +19,7 @@ watchmen-port = {{ .PlmntConfig.WatchmenPort }}
token-denom = "{{ .PlmntConfig.TokenDenom }}"
stake-denom = "{{ .PlmntConfig.StakeDenom }}"
fee-denom = "{{ .PlmntConfig.FeeDenom }}"
config-root-dir = "{{ .PlmntConfig.ConfigRootDir }}"
`
// Config defines Planetmint's top level configuration
@ -27,6 +30,7 @@ type Config struct {
TokenDenom string `mapstructure:"token-denom" json:"token-denom"`
StakeDenom string `mapstructure:"stake-denom" json:"stake-denom"`
FeeDenom string `mapstructure:"fee-denom" json:"fee-denom"`
ConfigRootDir string `mapstructure:"config-root-dir" json:"config-root-dir"`
}
// cosmos-sdk wide global singleton
@ -37,6 +41,11 @@ var (
// DefaultConfig returns planetmint's default configuration.
func DefaultConfig() *Config {
currentUser, err := user.Current()
if err != nil {
panic(err)
}
return &Config{
OSCServicePort: 8766,
WatchmenEndpoint: "lab.r3c.network",
@ -44,6 +53,7 @@ func DefaultConfig() *Config {
TokenDenom: "plmnt",
StakeDenom: "plmntstake",
FeeDenom: "plmnt",
ConfigRootDir: filepath.Join(currentUser.HomeDir, ".planetmint-go"),
}
}

126
docs/static/openapi.yml vendored
View File

@ -46558,6 +46558,8 @@ paths:
format: int64
machineIdSignature:
type: string
address:
type: string
default:
description: An unexpected error response.
schema:
@ -46658,6 +46660,82 @@ paths:
additionalProperties: {}
tags:
- Query
/planetmint-go/machine/get_machine_by_address/{address}:
get:
summary: Queries a list of GetMachineByAddress items.
operationId: PlanetmintgoMachineGetMachineByAddress
responses:
'200':
description: A successful response.
schema:
type: object
properties:
machine:
type: object
properties:
name:
type: string
ticker:
type: string
domain:
type: string
reissue:
type: boolean
amount:
type: string
format: uint64
precision:
type: string
format: uint64
issuerPlanetmint:
type: string
issuerLiquid:
type: string
machineId:
type: string
metadata:
type: object
properties:
gps:
type: string
device:
type: string
assetDefinition:
type: string
additionalDataCID:
type: string
type:
type: integer
format: int64
machineIdSignature:
type: string
address:
type: string
default:
description: An unexpected error response.
schema:
type: object
properties:
code:
type: integer
format: int32
message:
type: string
details:
type: array
items:
type: object
properties:
'@type':
type: string
additionalProperties: {}
parameters:
- name: address
in: path
required: true
type: string
tags:
- Query
definitions:
cosmos.auth.v1beta1.AddressBytesToStringResponse:
type: object
@ -75458,6 +75536,8 @@ definitions:
format: int64
machineIdSignature:
type: string
address:
type: string
planetmintgo.machine.Metadata:
type: object
properties:
@ -75476,6 +75556,50 @@ definitions:
planetmintgo.machine.Params:
type: object
description: Params defines the parameters for the module.
planetmintgo.machine.QueryGetMachineByAddressResponse:
type: object
properties:
machine:
type: object
properties:
name:
type: string
ticker:
type: string
domain:
type: string
reissue:
type: boolean
amount:
type: string
format: uint64
precision:
type: string
format: uint64
issuerPlanetmint:
type: string
issuerLiquid:
type: string
machineId:
type: string
metadata:
type: object
properties:
gps:
type: string
device:
type: string
assetDefinition:
type: string
additionalDataCID:
type: string
type:
type: integer
format: int64
machineIdSignature:
type: string
address:
type: string
planetmintgo.machine.QueryGetMachineByPublicKeyResponse:
type: object
properties:
@ -75518,6 +75642,8 @@ definitions:
format: int64
machineIdSignature:
type: string
address:
type: string
planetmintgo.machine.QueryGetTrustAnchorStatusResponse:
type: object
properties:

2
proto/planetmintgo/machine/machine.proto
View File

@ -17,6 +17,7 @@ message Machine {
Metadata metadata = 10;
uint32 type = 11;
string machineIdSignature = 12;
string address = 13;
}
message Metadata {
@ -31,4 +32,5 @@ message MachineIndex {
string machineId = 1;
string issuerPlanetmint = 2;
string issuerLiquid = 3;
string address = 4;
}

14
proto/planetmintgo/machine/query.proto
View File

@ -30,6 +30,12 @@ service Query {
option (google.api.http).get = "/github.com/planetmint/planetmint-go/machine/get_trust_anchor_status/{machineid}";
}
// Queries a list of GetMachineByAddress items.
rpc GetMachineByAddress (QueryGetMachineByAddressRequest) returns (QueryGetMachineByAddressResponse) {
option (google.api.http).get = "/planetmint-go/machine/get_machine_by_address/{address}";
}
}
// QueryParamsRequest is request type for the Query/Params RPC method.
message QueryParamsRequest {}
@ -58,3 +64,11 @@ message QueryGetTrustAnchorStatusResponse {
bool isactivated = 2;
}
message QueryGetMachineByAddressRequest {
string address = 1;
}
message QueryGetMachineByAddressResponse {
Machine machine = 1;
}

1
tests/e2e/machine/rest.go
View File

@ -38,6 +38,7 @@ func (s *E2ETestSuite) TestAttestMachineREST() {
// Create Attest Machine TX
machine := sample.Machine(sample.Name, pubKey, prvKey)
machine.Address = addr.String()
msg := machinetypes.MsgAttestMachine{
Creator: addr.String(),
Machine: &machine,

6
testutil/keeper/asset.go
View File

@ -52,9 +52,9 @@ func AssetKeeper(t testing.TB) (*keeper.Keeper, sdk.Context) {
_, ppk := sample.ExtendedKeyPair(config.PlmntNetParams)
_, lpk := sample.ExtendedKeyPair(config.LiquidNetParams)
id := sample.MachineIndex(pk, ppk, lpk)
mk.EXPECT().GetMachineIndex(ctx, pk).Return(id, true).AnyTimes()
mk.EXPECT().GetMachineIndex(ctx, ppk).Return(id, true).AnyTimes()
mk.EXPECT().GetMachineIndex(ctx, sk).Return(id, false).AnyTimes()
mk.EXPECT().GetMachineIndexByPubKey(ctx, pk).Return(id, true).AnyTimes()
mk.EXPECT().GetMachineIndexByPubKey(ctx, ppk).Return(id, true).AnyTimes()
mk.EXPECT().GetMachineIndexByPubKey(ctx, sk).Return(id, false).AnyTimes()
mk.EXPECT().GetMachine(ctx, id).Return(sample.Machine(pk, pk, sk), true).AnyTimes()
mk.EXPECT().GetMachine(ctx, sk).Return(sample.Machine(pk, pk, sk), false).AnyTimes()

3
testutil/keeper/machine.go
View File

@ -24,6 +24,7 @@ func MachineKeeper(t testing.TB) (*keeper.Keeper, sdk.Context) {
issuerPlanetmintIndexStoreKey := sdk.NewKVStoreKey(types.IssuerPlanetmintIndexKey)
issuerLiquidIndexStoreKey := sdk.NewKVStoreKey(types.IssuerLiquidIndexKey)
trustAnchorStoreKey := sdk.NewKVStoreKey(types.TrustAnchorKey)
addressStoreKey := sdk.NewKVStoreKey(types.AddressIndexKey)
memStoreKey := storetypes.NewMemoryStoreKey(types.MemStoreKey)
db := tmdb.NewMemDB()
@ -33,6 +34,7 @@ func MachineKeeper(t testing.TB) (*keeper.Keeper, sdk.Context) {
stateStore.MountStoreWithDB(issuerPlanetmintIndexStoreKey, storetypes.StoreTypeIAVL, db)
stateStore.MountStoreWithDB(issuerLiquidIndexStoreKey, storetypes.StoreTypeIAVL, db)
stateStore.MountStoreWithDB(trustAnchorStoreKey, storetypes.StoreTypeIAVL, db)
stateStore.MountStoreWithDB(addressStoreKey, storetypes.StoreTypeIAVL, db)
stateStore.MountStoreWithDB(memStoreKey, storetypes.StoreTypeMemory, nil)
require.NoError(t, stateStore.LoadLatestVersion())
@ -53,6 +55,7 @@ func MachineKeeper(t testing.TB) (*keeper.Keeper, sdk.Context) {
issuerPlanetmintIndexStoreKey,
issuerLiquidIndexStoreKey,
trustAnchorStoreKey,
addressStoreKey,
memStoreKey,
paramsSubspace,
)

4
testutil/sample/sample.go
View File

@ -59,6 +59,7 @@ func Secp256k1AccAddress() sdk.AccAddress {
return sdk.AccAddress(addr)
}
// TODO: make address deterministic for test cases
func Machine(name, pubKey string, prvKey string) machinetypes.Machine {
metadata := Metadata()
_, liquidPubKey := ExtendedKeyPair(config.LiquidNetParams)
@ -70,6 +71,8 @@ func Machine(name, pubKey string, prvKey string) machinetypes.Machine {
sign, _ := sk.Sign(pubKeyBytes)
signatureHex := hex.EncodeToString(sign)
addr := Secp256k1AccAddress()
m := machinetypes.Machine{
Name: name,
Ticker: name + "_ticker",
@ -83,6 +86,7 @@ func Machine(name, pubKey string, prvKey string) machinetypes.Machine {
Metadata: &metadata,
Type: 1,
MachineIdSignature: signatureHex,
Address: addr.String(),
}
return m
}

2
x/asset/keeper/msg_server_notarize_asset.go
View File

@ -13,7 +13,7 @@ import (
func (k msgServer) NotarizeAsset(goCtx context.Context, msg *types.MsgNotarizeAsset) (*types.MsgNotarizeAssetResponse, error) {
ctx := sdk.UnwrapSDKContext(goCtx)
_, found := k.machineKeeper.GetMachineIndex(ctx, msg.PubKey)
_, found := k.machineKeeper.GetMachineIndexByPubKey(ctx, msg.PubKey)
if !found {
return nil, errors.New("machine not found")

12
x/asset/testutil/expected_keepers_mock.go
View File

@ -125,17 +125,17 @@ func (mr *MockMachineKeeperMockRecorder) GetMachine(ctx, index interface{}) *gom
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMachine", reflect.TypeOf((*MockMachineKeeper)(nil).GetMachine), ctx, index)
}
// GetMachineIndex mocks base method.
func (m *MockMachineKeeper) GetMachineIndex(ctx types.Context, pubKey string) (types1.MachineIndex, bool) {
// GetMachineIndexByPubKey mocks base method.
func (m *MockMachineKeeper) GetMachineIndexByPubKey(ctx types.Context, pubKey string) (types1.MachineIndex, bool) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetMachineIndex", ctx, pubKey)
ret := m.ctrl.Call(m, "GetMachineIndexByPubKey", ctx, pubKey)
ret0, _ := ret[0].(types1.MachineIndex)
ret1, _ := ret[1].(bool)
return ret0, ret1
}
// GetMachineIndex indicates an expected call of GetMachineIndex.
func (mr *MockMachineKeeperMockRecorder) GetMachineIndex(ctx, pubKey interface{}) *gomock.Call {
// GetMachineIndexByPubKey indicates an expected call of GetMachineIndexByPubKey.
func (mr *MockMachineKeeperMockRecorder) GetMachineIndexByPubKey(ctx, pubKey interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMachineIndex", reflect.TypeOf((*MockMachineKeeper)(nil).GetMachineIndex), ctx, pubKey)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMachineIndexByPubKey", reflect.TypeOf((*MockMachineKeeper)(nil).GetMachineIndexByPubKey), ctx, pubKey)
}

2
x/asset/types/expected_keepers.go
View File

@ -10,7 +10,7 @@ import (
type MachineKeeper interface {
// Methods imported from machine should be defined here
GetMachine(ctx sdk.Context, index machinetypes.MachineIndex) (val machinetypes.Machine, found bool)
GetMachineIndex(ctx sdk.Context, pubKey string) (val machinetypes.MachineIndex, found bool)
GetMachineIndexByPubKey(ctx sdk.Context, pubKey string) (val machinetypes.MachineIndex, found bool)
}
// AccountKeeper defines the expected account keeper used for simulations (noalias)

55
x/dao/abci.go
View File

@ -1,12 +1,67 @@
package dao
import (
"encoding/hex"
"encoding/json"
"fmt"
"io"
"os"
"path/filepath"
"strings"
"github.com/planetmint/planetmint-go/config"
"github.com/planetmint/planetmint-go/x/dao/keeper"
abci "github.com/cometbft/cometbft/abci/types"
cometcfg "github.com/cometbft/cometbft/config"
sdk "github.com/cosmos/cosmos-sdk/types"
)
type Key struct {
Type string `json:"type"`
Value string `json:"value"`
}
type KeyFile struct {
Address string `json:"address"`
PubKey Key `json:"pub_key"`
PrivKey Key `json:"priv_key"`
}
func BeginBlocker(ctx sdk.Context, req abci.RequestBeginBlock, k keeper.Keeper) {
proposerAddress := req.Header.GetProposerAddress()
// Check if node is block proposer
if isValidatorBlockProposer(ctx, proposerAddress) {
// TODO: implement PoP trigger
fmt.Println("TODO: implement PoP trigger")
}
}
func isValidatorBlockProposer(ctx sdk.Context, proposerAddress []byte) bool {
logger := ctx.Logger()
conf := config.GetConfig()
cfg := cometcfg.DefaultConfig()
jsonFilePath := filepath.Join(conf.ConfigRootDir, cfg.PrivValidatorKey)
hexProposerAddress := hex.EncodeToString(proposerAddress)
jsonFile, err := os.Open(jsonFilePath)
if err != nil {
logger.Error("error while opening config", err)
}
jsonBytes, err := io.ReadAll(jsonFile)
if err != nil {
logger.Error("error while reading file", err)
}
var keyFile KeyFile
json.Unmarshal(jsonBytes, &keyFile)
return hexProposerAddress == strings.ToLower(keyFile.Address)
}
func EndBlocker(ctx sdk.Context, req abci.RequestEndBlock, k keeper.Keeper) {
k.DistributeCollectedFees(ctx)
}

4
x/dao/module.go
View File

@ -143,7 +143,9 @@ func (am AppModule) ExportGenesis(ctx sdk.Context, cdc codec.JSONCodec) json.Raw
func (AppModule) ConsensusVersion() uint64 { return 1 }
// BeginBlock contains the logic that is automatically triggered at the beginning of each block
func (am AppModule) BeginBlock(_ sdk.Context, _ abci.RequestBeginBlock) {}
func (am AppModule) BeginBlock(ctx sdk.Context, req abci.RequestBeginBlock) {
BeginBlocker(ctx, req, am.keeper)
}
// EndBlock contains the logic that is automatically triggered at the end of each block
func (am AppModule) EndBlock(ctx sdk.Context, req abci.RequestEndBlock) []abci.ValidatorUpdate {

1
x/dao/types/expected_keepers.go
View File

@ -18,5 +18,6 @@ type BankKeeper interface {
SpendableCoins(ctx sdk.Context, addr sdk.AccAddress) sdk.Coins
SendCoinsFromModuleToAccount(ctx sdk.Context, senderModule string, recipientAddr sdk.AccAddress, amt sdk.Coins) error
BlockedAddr(addr sdk.AccAddress) bool
MintCoins(ctx sdk.Context, moduleName string, amt sdk.Coins) error
// Methods imported from bank should be defined here
}

1
x/machine/client/cli/query.go
View File

@ -28,6 +28,7 @@ func GetQueryCmd(queryRoute string) *cobra.Command {
cmd.AddCommand(CmdGetMachineByPublicKey())
cmd.AddCommand(CmdGetTrustAnchorStatus())
cmd.AddCommand(CmdGetMachineByAddress())
// this line is used by starport scaffolding # 1

46
x/machine/client/cli/query_get_machine_by_address.go Normal file
View File

@ -0,0 +1,46 @@
package cli
import (
"strconv"
"github.com/cosmos/cosmos-sdk/client"
"github.com/cosmos/cosmos-sdk/client/flags"
"github.com/planetmint/planetmint-go/x/machine/types"
"github.com/spf13/cobra"
)
var _ = strconv.Itoa(0)
func CmdGetMachineByAddress() *cobra.Command {
cmd := &cobra.Command{
Use: "get-machine-by-address [address]",
Short: "Query get-machine-by-address",
Args: cobra.ExactArgs(1),
RunE: func(cmd *cobra.Command, args []string) (err error) {
reqAddress := args[0]
clientCtx, err := client.GetClientQueryContext(cmd)
if err != nil {
return err
}
queryClient := types.NewQueryClient(clientCtx)
params := &types.QueryGetMachineByAddressRequest{
Address: reqAddress,
}
res, err := queryClient.GetMachineByAddress(cmd.Context(), params)
if err != nil {
return err
}
return clientCtx.PrintProto(res)
},
}
flags.AddQueryFlagsToCmd(cmd)
return cmd
}

3
x/machine/keeper/keeper.go
View File

@ -20,6 +20,7 @@ type (
issuerPlanetmintIndexStoreKey storetypes.StoreKey
issuerLiquidIndexStoreKey storetypes.StoreKey
taStoreKey storetypes.StoreKey
addressIndexStoreKey storetypes.StoreKey
memKey storetypes.StoreKey
paramstore paramtypes.Subspace
}
@ -32,6 +33,7 @@ func NewKeeper(
issuerPlanetmintIndexStoreKey,
issuerLiquidIndexStoreKey,
taStoreKey,
addressIndexStoreKey,
memKey storetypes.StoreKey,
ps paramtypes.Subspace,
) *Keeper {
@ -47,6 +49,7 @@ func NewKeeper(
issuerPlanetmintIndexStoreKey: issuerPlanetmintIndexStoreKey,
issuerLiquidIndexStoreKey: issuerLiquidIndexStoreKey,
taStoreKey: taStoreKey,
addressIndexStoreKey: addressIndexStoreKey,
memKey: memKey,
paramstore: ps,
}

22
x/machine/keeper/machine.go
View File

@ -30,23 +30,27 @@ func (k Keeper) StoreMachineIndex(ctx sdk.Context, machine types.Machine) {
taIndexStore := prefix.NewStore(ctx.KVStore(k.taIndexStoreKey), types.KeyPrefix(types.TAIndexKey))
issuerPlanetmintIndexStore := prefix.NewStore(ctx.KVStore(k.issuerPlanetmintIndexStoreKey), types.KeyPrefix(types.IssuerPlanetmintIndexKey))
issuerLiquidIndexStore := prefix.NewStore(ctx.KVStore(k.issuerLiquidIndexStoreKey), types.KeyPrefix(types.IssuerLiquidIndexKey))
addressIndexStore := prefix.NewStore(ctx.KVStore(k.addressIndexStoreKey), types.KeyPrefix(types.AddressIndexKey))
index := types.MachineIndex{
MachineId: machine.MachineId,
IssuerPlanetmint: machine.IssuerPlanetmint,
IssuerLiquid: machine.IssuerLiquid,
Address: machine.Address,
}
machineIdIndexKey := GetMachineBytes(machine.MachineId)
issuerPlanetmintIndexKey := GetMachineBytes(machine.IssuerPlanetmint)
issuerLiquidIndexKey := GetMachineBytes(machine.IssuerLiquid)
addressIndexKey := GetMachineBytes(machine.Address)
indexAppendValue := k.cdc.MustMarshal(&index)
taIndexStore.Set(machineIdIndexKey, indexAppendValue)
issuerPlanetmintIndexStore.Set(issuerPlanetmintIndexKey, indexAppendValue)
issuerLiquidIndexStore.Set(issuerLiquidIndexKey, indexAppendValue)
addressIndexStore.Set(addressIndexKey, indexAppendValue)
}
func (k Keeper) GetMachineIndex(ctx sdk.Context, pubKey string) (val types.MachineIndex, found bool) {
func (k Keeper) GetMachineIndexByPubKey(ctx sdk.Context, pubKey string) (val types.MachineIndex, found bool) {
taIndexStore := prefix.NewStore(ctx.KVStore(k.taIndexStoreKey), types.KeyPrefix(types.TAIndexKey))
issuerPlanetmintIndexStore := prefix.NewStore(ctx.KVStore(k.issuerPlanetmintIndexStoreKey), types.KeyPrefix(types.IssuerPlanetmintIndexKey))
issuerLiquidIndexStore := prefix.NewStore(ctx.KVStore(k.issuerLiquidIndexStoreKey), types.KeyPrefix(types.IssuerLiquidIndexKey))
@ -80,6 +84,22 @@ func (k Keeper) GetMachineIndex(ctx sdk.Context, pubKey string) (val types.Machi
return val, false
}
func (k Keeper) GetMachineIndexByAddress(ctx sdk.Context, address string) (val types.MachineIndex, found bool) {
addressIndexStore := prefix.NewStore(ctx.KVStore(k.addressIndexStoreKey), types.KeyPrefix(types.AddressIndexKey))
keyBytes := GetMachineBytes(address)
adIndex := addressIndexStore.Get(keyBytes)
if adIndex != nil {
if err := k.cdc.Unmarshal(adIndex, &val); err != nil {
return val, false
}
return val, true
}
return val, false
}
func GetMachineBytes(pubKey string) []byte {
return []byte(pubKey)
}

7
x/machine/keeper/machine_test.go
View File

@ -18,6 +18,7 @@ func createNMachine(keeper *keeper.Keeper, ctx sdk.Context, n int) []types.Machi
items[i].MachineId = fmt.Sprintf("machineId%v", i)
items[i].IssuerPlanetmint = fmt.Sprintf("issuerPlanetmint%v", i)
items[i].IssuerLiquid = fmt.Sprintf("issuerLiquid%v", i)
items[i].Address = fmt.Sprintf("address%v", i)
keeper.StoreMachine(ctx, items[i])
keeper.StoreMachineIndex(ctx, items[i])
}
@ -32,6 +33,7 @@ func TestGetMachine(t *testing.T) {
MachineId: item.MachineId,
IssuerPlanetmint: item.IssuerPlanetmint,
IssuerLiquid: item.IssuerLiquid,
Address: item.Address,
}
machineById, found := keeper.GetMachine(ctx, index)
assert.True(t, found)
@ -39,7 +41,7 @@ func TestGetMachine(t *testing.T) {
}
}
func TestGetMachineIndex(t *testing.T) {
func TestGetMachineIndexByPubKey(t *testing.T) {
keeper, ctx := keepertest.MachineKeeper(t)
items := createNMachine(keeper, ctx, 10)
for _, item := range items {
@ -47,8 +49,9 @@ func TestGetMachineIndex(t *testing.T) {
MachineId: item.MachineId,
IssuerPlanetmint: item.IssuerPlanetmint,
IssuerLiquid: item.IssuerLiquid,
Address: item.Address,
}
index, found := keeper.GetMachineIndex(ctx, item.MachineId)
index, found := keeper.GetMachineIndexByPubKey(ctx, item.MachineId)
assert.True(t, found)
assert.Equal(t, expectedIndex, index)
}

31
x/machine/keeper/query_get_machine_by_address.go Normal file
View File

@ -0,0 +1,31 @@
package keeper
import (
"context"
"github.com/planetmint/planetmint-go/x/machine/types"
sdk "github.com/cosmos/cosmos-sdk/types"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/status"
)
func (k Keeper) GetMachineByAddress(goCtx context.Context, req *types.QueryGetMachineByAddressRequest) (*types.QueryGetMachineByAddressResponse, error) {
if req == nil {
return nil, status.Error(codes.InvalidArgument, "invalid request")
}
ctx := sdk.UnwrapSDKContext(goCtx)
machineIndex, found := k.GetMachineIndexByAddress(ctx, req.Address)
if !found {
return nil, status.Error(codes.NotFound, "machine not found")
}
machine, found := k.GetMachine(ctx, machineIndex)
if !found {
return nil, status.Error(codes.Internal, "error while fetching machine")
}
return &types.QueryGetMachineByAddressResponse{Machine: &machine}, nil
}

46
x/machine/keeper/query_get_machine_by_address_test.go Normal file
View File

@ -0,0 +1,46 @@
package keeper_test
import (
"fmt"
"testing"
keepertest "github.com/planetmint/planetmint-go/testutil/keeper"
"github.com/planetmint/planetmint-go/x/machine/types"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/stretchr/testify/require"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/status"
)
func TestGetMachineByAddress(t *testing.T) {
keeper, ctx := keepertest.MachineKeeper(t)
wctx := sdk.WrapSDKContext(ctx)
msgs := createNMachine(keeper, ctx, 1)
fmt.Println(msgs[0].Amount)
for _, tc := range []struct {
desc string
request *types.QueryGetMachineByAddressRequest
response *types.QueryGetMachineByAddressResponse
err error
}{
{
desc: "GetMachineByAddress",
request: &types.QueryGetMachineByAddressRequest{Address: msgs[0].Address},
response: &types.QueryGetMachineByAddressResponse{Machine: &msgs[0]},
}, {
desc: "MachineNotFound",
request: &types.QueryGetMachineByAddressRequest{Address: "invalid address"},
err: status.Error(codes.NotFound, "machine not found"),
},
} {
t.Run(tc.desc, func(t *testing.T) {
response, err := keeper.GetMachineByAddress(wctx, tc.request)
if tc.err != nil {
require.ErrorIs(t, err, tc.err)
} else {
require.Equal(t, tc.response, response)
}
})
}
}

7
x/machine/keeper/query_get_machine_by_public_key.go
View File

@ -17,12 +17,15 @@ func (k Keeper) GetMachineByPublicKey(goCtx context.Context, req *types.QueryGet
ctx := sdk.UnwrapSDKContext(goCtx)
machineIndex, found := k.GetMachineIndex(ctx, req.PublicKey)
machineIndex, found := k.GetMachineIndexByPubKey(ctx, req.PublicKey)
if !found {
return nil, status.Error(codes.NotFound, "machine not found")
}
machine, _ := k.GetMachine(ctx, machineIndex)
machine, found := k.GetMachine(ctx, machineIndex)
if !found {
return nil, status.Error(codes.Internal, "error while fetching machine")
}
return &types.QueryGetMachineByPublicKeyResponse{Machine: &machine}, nil
}

2
x/machine/types/keys.go
View File

@ -22,6 +22,8 @@ const (
IssuerLiquidIndexKey = "Machine/IssuerLiquidIndex/"
TrustAnchorKey = "Machine/trustAnchor/"
AddressIndexKey = "Machine/address"
)
func KeyPrefix(p string) []byte {

159
x/machine/types/machine.pb.go
View File

@ -35,6 +35,7 @@ type Machine struct {
Metadata *Metadata `protobuf:"bytes,10,opt,name=metadata,proto3" json:"metadata,omitempty"`
Type uint32 `protobuf:"varint,11,opt,name=type,proto3" json:"type,omitempty"`
MachineIdSignature string `protobuf:"bytes,12,opt,name=machineIdSignature,proto3" json:"machineIdSignature,omitempty"`
Address string `protobuf:"bytes,13,opt,name=address,proto3" json:"address,omitempty"`
}
func (m *Machine) Reset() { *m = Machine{} }
@ -154,6 +155,13 @@ func (m *Machine) GetMachineIdSignature() string {
return ""
}
func (m *Machine) GetAddress() string {
if m != nil {
return m.Address
}
return ""
}
type Metadata struct {
Gps string `protobuf:"bytes,1,opt,name=gps,proto3" json:"gps,omitempty"`
Device string `protobuf:"bytes,2,opt,name=device,proto3" json:"device,omitempty"`
@ -226,6 +234,7 @@ type MachineIndex struct {
MachineId string `protobuf:"bytes,1,opt,name=machineId,proto3" json:"machineId,omitempty"`
IssuerPlanetmint string `protobuf:"bytes,2,opt,name=issuerPlanetmint,proto3" json:"issuerPlanetmint,omitempty"`
IssuerLiquid string `protobuf:"bytes,3,opt,name=issuerLiquid,proto3" json:"issuerLiquid,omitempty"`
Address string `protobuf:"bytes,4,opt,name=address,proto3" json:"address,omitempty"`
}
func (m *MachineIndex) Reset() { *m = MachineIndex{} }
@ -282,6 +291,13 @@ func (m *MachineIndex) GetIssuerLiquid() string {
return ""
}
func (m *MachineIndex) GetAddress() string {
if m != nil {
return m.Address
}
return ""
}
func init() {
proto.RegisterType((*Machine)(nil), "planetmintgo.machine.Machine")
proto.RegisterType((*Metadata)(nil), "planetmintgo.machine.Metadata")
@ -293,34 +309,35 @@ func init() {
}
var fileDescriptor_1bb279745bef7c4b = []byte{
// 423 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x53, 0x3f, 0x8f, 0xd3, 0x30,
0x1c, 0xad, 0x9b, 0xd2, 0x26, 0xbf, 0x16, 0x51, 0x2c, 0x84, 0x3c, 0xa0, 0x28, 0xca, 0x14, 0x21,
0x48, 0x25, 0xba, 0x31, 0x42, 0x97, 0x4a, 0x54, 0x42, 0x61, 0x63, 0x73, 0x13, 0x93, 0x5a, 0x34,
0x76, 0x48, 0x1c, 0x54, 0x24, 0xbe, 0xc1, 0xdd, 0x70, 0x1f, 0xeb, 0xc6, 0x8e, 0x37, 0x9e, 0xda,
0x2f, 0x72, 0x8a, 0xf3, 0xa7, 0x7f, 0x87, 0x9b, 0xf2, 0xde, 0xfb, 0x3d, 0xdb, 0xc9, 0x7b, 0x31,
0xb8, 0xe9, 0x9a, 0x0a, 0xa6, 0x12, 0x2e, 0x54, 0x2c, 0x27, 0x09, 0x0d, 0x57, 0x5c, 0xb0, 0xe6,
0xe9, 0xa7, 0x99, 0x54, 0x12, 0xbf, 0x39, 0xf6, 0xf8, 0xf5, 0xcc, 0xbd, 0x31, 0x60, 0xb0, 0xa8,
0x30, 0xc6, 0xd0, 0x13, 0x34, 0x61, 0x04, 0x39, 0xc8, 0xb3, 0x02, 0x8d, 0xf1, 0x5b, 0xe8, 0x2b,
0x1e, 0xfe, 0x66, 0x19, 0xe9, 0x6a, 0xb5, 0x66, 0xa5, 0x1e, 0xc9, 0x84, 0x72, 0x41, 0x8c, 0x4a,
0xaf, 0x18, 0x26, 0x30, 0xc8, 0x18, 0xcf, 0xf3, 0x82, 0x91, 0x9e, 0x83, 0x3c, 0x33, 0x68, 0x68,
0xb9, 0x82, 0x26, 0xb2, 0x10, 0x8a, 0xbc, 0x70, 0x90, 0xd7, 0x0b, 0x6a, 0x86, 0xdf, 0x81, 0x95,
0x66, 0x2c, 0xe4, 0x39, 0x97, 0x82, 0xf4, 0xf5, 0xe8, 0x20, 0xe0, 0xf7, 0x30, 0xd6, 0xcb, 0xb3,
0xef, 0xed, 0xdb, 0x93, 0x81, 0x3e, 0xf1, 0x42, 0xc7, 0x2e, 0x8c, 0x2a, 0xed, 0x1b, 0xff, 0x53,
0xf0, 0x88, 0x98, 0xda, 0x77, 0xa2, 0x95, 0xa7, 0xd5, 0x9f, 0x3e, 0x8f, 0x88, 0xa5, 0x0d, 0x07,
0x01, 0x7f, 0x06, 0x33, 0x61, 0x8a, 0x46, 0x54, 0x51, 0x02, 0x0e, 0xf2, 0x86, 0x9f, 0x6c, 0xff,
0x5a, 0x6c, 0xfe, 0xa2, 0x76, 0x05, 0xad, 0xbf, 0x4c, 0x4f, 0xfd, 0x4b, 0x19, 0x19, 0x3a, 0xc8,
0x7b, 0x19, 0x68, 0x8c, 0x7d, 0xc0, 0xed, 0xe6, 0x3f, 0x78, 0x2c, 0xa8, 0x2a, 0x32, 0x46, 0x46,
0xfa, 0xd8, 0x2b, 0x13, 0xf7, 0x16, 0x81, 0xd9, 0x6c, 0x8d, 0xc7, 0x60, 0xc4, 0x69, 0x5e, 0xb7,
0x51, 0x42, 0x1d, 0x3a, 0xfb, 0xcb, 0x43, 0xd6, 0x94, 0x51, 0x31, 0xec, 0xc1, 0x2b, 0x9a, 0xe7,
0x4c, 0xcd, 0xd8, 0x2f, 0x2e, 0xb8, 0x2a, 0x83, 0xac, 0x5a, 0x39, 0x97, 0xf1, 0x07, 0x78, 0x4d,
0xa3, 0x48, 0x63, 0xba, 0x9e, 0x51, 0x45, 0xbf, 0xce, 0x67, 0xba, 0x28, 0x2b, 0xb8, 0x1c, 0xb8,
0xff, 0x61, 0x54, 0xff, 0x1b, 0x73, 0x11, 0xb1, 0xcd, 0x69, 0x78, 0xe8, 0x3c, 0xbc, 0x6b, 0x55,
0x75, 0x9f, 0x59, 0x95, 0x71, 0x59, 0xd5, 0x97, 0xc5, 0xfd, 0xce, 0x46, 0xdb, 0x9d, 0x8d, 0x1e,
0x77, 0x36, 0xba, 0xdb, 0xdb, 0x9d, 0xed, 0xde, 0xee, 0x3c, 0xec, 0xed, 0xce, 0xcf, 0x69, 0xcc,
0xd5, 0xaa, 0x58, 0xfa, 0xa1, 0x4c, 0x26, 0x87, 0x7a, 0x8e, 0xe0, 0xc7, 0x58, 0x4e, 0x36, 0xed,
0x3d, 0x28, 0xab, 0xc8, 0x97, 0x7d, 0x7d, 0x0d, 0xa6, 0x4f, 0x01, 0x00, 0x00, 0xff, 0xff, 0xe7,
0xdd, 0x90, 0x62, 0x2c, 0x03, 0x00, 0x00,
// 443 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x53, 0xbd, 0x8e, 0xd3, 0x40,
0x18, 0xcc, 0x5e, 0x42, 0x7e, 0xbe, 0xcb, 0x89, 0x63, 0x85, 0xd0, 0x16, 0xc8, 0xb2, 0x5c, 0x59,
0x08, 0x1c, 0x89, 0xeb, 0x28, 0x21, 0x4d, 0x24, 0x22, 0x21, 0xd3, 0xd1, 0xed, 0x79, 0x3f, 0x7c,
0x2b, 0xce, 0xbb, 0xc6, 0xbb, 0x46, 0xc7, 0x3b, 0x50, 0x50, 0xf1, 0x06, 0xbc, 0x0b, 0xe5, 0x95,
0x94, 0x28, 0x79, 0x11, 0xb4, 0x6b, 0x3b, 0x3f, 0x77, 0x2e, 0xae, 0xca, 0xcc, 0x7c, 0xb3, 0xf9,
0xec, 0x19, 0x2f, 0x44, 0xe5, 0x35, 0x57, 0x68, 0x0b, 0xa9, 0x6c, 0xae, 0x17, 0x05, 0xcf, 0xae,
0xa4, 0xc2, 0xee, 0x37, 0x29, 0x2b, 0x6d, 0x35, 0x7d, 0x7a, 0xe8, 0x49, 0xda, 0x59, 0xf4, 0x7b,
0x08, 0x93, 0x75, 0x83, 0x29, 0x85, 0x91, 0xe2, 0x05, 0x32, 0x12, 0x92, 0x78, 0x96, 0x7a, 0x4c,
0x9f, 0xc1, 0xd8, 0xca, 0xec, 0x0b, 0x56, 0xec, 0xc4, 0xab, 0x2d, 0x73, 0xba, 0xd0, 0x05, 0x97,
0x8a, 0x0d, 0x1b, 0xbd, 0x61, 0x94, 0xc1, 0xa4, 0x42, 0x69, 0x4c, 0x8d, 0x6c, 0x14, 0x92, 0x78,
0x9a, 0x76, 0xd4, 0x9d, 0xe0, 0x85, 0xae, 0x95, 0x65, 0x8f, 0x42, 0x12, 0x8f, 0xd2, 0x96, 0xd1,
0xe7, 0x30, 0x2b, 0x2b, 0xcc, 0xa4, 0x91, 0x5a, 0xb1, 0xb1, 0x1f, 0xed, 0x05, 0xfa, 0x02, 0xce,
0xfd, 0xf1, 0xea, 0xc3, 0xee, 0xe9, 0xd9, 0xc4, 0x6f, 0xbc, 0xa7, 0xd3, 0x08, 0xe6, 0x8d, 0xf6,
0x5e, 0x7e, 0xad, 0xa5, 0x60, 0x53, 0xef, 0x3b, 0xd2, 0xdc, 0xb6, 0xf6, 0xd5, 0x57, 0x82, 0xcd,
0xbc, 0x61, 0x2f, 0xd0, 0x37, 0x30, 0x2d, 0xd0, 0x72, 0xc1, 0x2d, 0x67, 0x10, 0x92, 0xf8, 0xf4,
0x75, 0x90, 0xf4, 0xc5, 0x96, 0xac, 0x5b, 0x57, 0xba, 0xf3, 0xbb, 0xf4, 0xec, 0xf7, 0x12, 0xd9,
0x69, 0x48, 0xe2, 0xb3, 0xd4, 0x63, 0x9a, 0x00, 0xdd, 0xfd, 0xf9, 0x47, 0x99, 0x2b, 0x6e, 0xeb,
0x0a, 0xd9, 0xdc, 0xaf, 0xed, 0x99, 0xb8, 0xf4, 0xb8, 0x10, 0x15, 0x1a, 0xc3, 0xce, 0xbc, 0xa9,
0xa3, 0xd1, 0x0f, 0x02, 0xd3, 0x6e, 0x29, 0x3d, 0x87, 0x61, 0x5e, 0x9a, 0xb6, 0x27, 0x07, 0x7d,
0x1d, 0xf8, 0x4d, 0x66, 0xd8, 0xd5, 0xd4, 0x30, 0x1a, 0xc3, 0x63, 0x6e, 0x0c, 0xda, 0x25, 0x7e,
0x96, 0x4a, 0x5a, 0x17, 0x71, 0xd3, 0xd7, 0x5d, 0x99, 0xbe, 0x84, 0x27, 0x5c, 0x08, 0x8f, 0xf9,
0xf5, 0x92, 0x5b, 0xfe, 0x6e, 0xb5, 0xf4, 0x15, 0xce, 0xd2, 0xfb, 0x83, 0xe8, 0x17, 0x81, 0x79,
0xfb, 0xd9, 0xac, 0x94, 0xc0, 0x9b, 0xe3, 0x5c, 0xc9, 0xdd, 0x5c, 0xfb, 0x5a, 0x3c, 0x79, 0x60,
0x8b, 0xc3, 0x9e, 0x16, 0x0f, 0x72, 0x1a, 0x1d, 0xe5, 0xf4, 0x76, 0xfd, 0x67, 0x13, 0x90, 0xdb,
0x4d, 0x40, 0xfe, 0x6d, 0x02, 0xf2, 0x73, 0x1b, 0x0c, 0x6e, 0xb7, 0xc1, 0xe0, 0xef, 0x36, 0x18,
0x7c, 0xba, 0xc8, 0xa5, 0xbd, 0xaa, 0x2f, 0x93, 0x4c, 0x17, 0x8b, 0x7d, 0xa7, 0x07, 0xf0, 0x55,
0xae, 0x17, 0x37, 0xbb, 0xcb, 0xe3, 0xfa, 0x33, 0x97, 0x63, 0x7f, 0x77, 0x2e, 0xfe, 0x07, 0x00,
0x00, 0xff, 0xff, 0x44, 0x7f, 0xea, 0x9d, 0x61, 0x03, 0x00, 0x00,
}
func (m *Machine) Marshal() (dAtA []byte, err error) {
@ -343,6 +360,13 @@ func (m *Machine) MarshalToSizedBuffer(dAtA []byte) (int, error) {
_ = i
var l int
_ = l
if len(m.Address) > 0 {
i -= len(m.Address)
copy(dAtA[i:], m.Address)
i = encodeVarintMachine(dAtA, i, uint64(len(m.Address)))
i--
dAtA[i] = 0x6a
}
if len(m.MachineIdSignature) > 0 {
i -= len(m.MachineIdSignature)
copy(dAtA[i:], m.MachineIdSignature)
@ -503,6 +527,13 @@ func (m *MachineIndex) MarshalToSizedBuffer(dAtA []byte) (int, error) {
_ = i
var l int
_ = l
if len(m.Address) > 0 {
i -= len(m.Address)
copy(dAtA[i:], m.Address)
i = encodeVarintMachine(dAtA, i, uint64(len(m.Address)))
i--
dAtA[i] = 0x22
}
if len(m.IssuerLiquid) > 0 {
i -= len(m.IssuerLiquid)
copy(dAtA[i:], m.IssuerLiquid)
@ -588,6 +619,10 @@ func (m *Machine) Size() (n int) {
if l > 0 {
n += 1 + l + sovMachine(uint64(l))
}
l = len(m.Address)
if l > 0 {
n += 1 + l + sovMachine(uint64(l))
}
return n
}
@ -634,6 +669,10 @@ func (m *MachineIndex) Size() (n int) {
if l > 0 {
n += 1 + l + sovMachine(uint64(l))
}
l = len(m.Address)
if l > 0 {
n += 1 + l + sovMachine(uint64(l))
}
return n
}
@ -1009,6 +1048,38 @@ func (m *Machine) Unmarshal(dAtA []byte) error {
}
m.MachineIdSignature = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 13:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowMachine
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthMachine
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthMachine
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Address = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipMachine(dAtA[iNdEx:])
@ -1333,6 +1404,38 @@ func (m *MachineIndex) Unmarshal(dAtA []byte) error {
}
m.IssuerLiquid = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 4:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowMachine
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthMachine
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthMachine
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Address = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipMachine(dAtA[iNdEx:])

460
x/machine/types/query.pb.go
View File

@ -297,6 +297,94 @@ func (m *QueryGetTrustAnchorStatusResponse) GetIsactivated() bool {
return false
}
type QueryGetMachineByAddressRequest struct {
Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
}
func (m *QueryGetMachineByAddressRequest) Reset() { *m = QueryGetMachineByAddressRequest{} }
func (m *QueryGetMachineByAddressRequest) String() string { return proto.CompactTextString(m) }
func (*QueryGetMachineByAddressRequest) ProtoMessage() {}
func (*QueryGetMachineByAddressRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_bf7841d43d757203, []int{6}
}
func (m *QueryGetMachineByAddressRequest) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *QueryGetMachineByAddressRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_QueryGetMachineByAddressRequest.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
return b[:n], nil
}
}
func (m *QueryGetMachineByAddressRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_QueryGetMachineByAddressRequest.Merge(m, src)
}
func (m *QueryGetMachineByAddressRequest) XXX_Size() int {
return m.Size()
}
func (m *QueryGetMachineByAddressRequest) XXX_DiscardUnknown() {
xxx_messageInfo_QueryGetMachineByAddressRequest.DiscardUnknown(m)
}
var xxx_messageInfo_QueryGetMachineByAddressRequest proto.InternalMessageInfo
func (m *QueryGetMachineByAddressRequest) GetAddress() string {
if m != nil {
return m.Address
}
return ""
}
type QueryGetMachineByAddressResponse struct {
Machine *Machine `protobuf:"bytes,1,opt,name=machine,proto3" json:"machine,omitempty"`
}
func (m *QueryGetMachineByAddressResponse) Reset() { *m = QueryGetMachineByAddressResponse{} }
func (m *QueryGetMachineByAddressResponse) String() string { return proto.CompactTextString(m) }
func (*QueryGetMachineByAddressResponse) ProtoMessage() {}
func (*QueryGetMachineByAddressResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_bf7841d43d757203, []int{7}
}
func (m *QueryGetMachineByAddressResponse) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *QueryGetMachineByAddressResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_QueryGetMachineByAddressResponse.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
return b[:n], nil
}
}
func (m *QueryGetMachineByAddressResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_QueryGetMachineByAddressResponse.Merge(m, src)
}
func (m *QueryGetMachineByAddressResponse) XXX_Size() int {
return m.Size()
}
func (m *QueryGetMachineByAddressResponse) XXX_DiscardUnknown() {
xxx_messageInfo_QueryGetMachineByAddressResponse.DiscardUnknown(m)
}
var xxx_messageInfo_QueryGetMachineByAddressResponse proto.InternalMessageInfo
func (m *QueryGetMachineByAddressResponse) GetMachine() *Machine {
if m != nil {
return m.Machine
}
return nil
}
func init() {
proto.RegisterType((*QueryParamsRequest)(nil), "planetmintgo.machine.QueryParamsRequest")
proto.RegisterType((*QueryParamsResponse)(nil), "planetmintgo.machine.QueryParamsResponse")
@ -304,45 +392,52 @@ func init() {
proto.RegisterType((*QueryGetMachineByPublicKeyResponse)(nil), "planetmintgo.machine.QueryGetMachineByPublicKeyResponse")
proto.RegisterType((*QueryGetTrustAnchorStatusRequest)(nil), "planetmintgo.machine.QueryGetTrustAnchorStatusRequest")
proto.RegisterType((*QueryGetTrustAnchorStatusResponse)(nil), "planetmintgo.machine.QueryGetTrustAnchorStatusResponse")
proto.RegisterType((*QueryGetMachineByAddressRequest)(nil), "planetmintgo.machine.QueryGetMachineByAddressRequest")
proto.RegisterType((*QueryGetMachineByAddressResponse)(nil), "planetmintgo.machine.QueryGetMachineByAddressResponse")
}
func init() { proto.RegisterFile("planetmintgo/machine/query.proto", fileDescriptor_bf7841d43d757203) }
var fileDescriptor_bf7841d43d757203 = []byte{
// 524 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x54, 0xcf, 0x6a, 0xd4, 0x40,
0x1c, 0xde, 0x94, 0x5a, 0xed, 0xf4, 0x36, 0xae, 0x50, 0xc2, 0x1a, 0xd3, 0x39, 0xad, 0x82, 0x19,
0xda, 0x45, 0x57, 0xf4, 0x62, 0xf7, 0xe2, 0x41, 0x0a, 0xdb, 0xd8, 0x83, 0x14, 0x24, 0x4c, 0xd2,
0x21, 0x3b, 0xb8, 0x99, 0x49, 0x33, 0x93, 0x62, 0x28, 0xbd, 0xf8, 0x04, 0x82, 0x37, 0x9f, 0xa8,
0xc7, 0x82, 0x17, 0x4f, 0xa2, 0xbb, 0xe2, 0xdd, 0x37, 0x90, 0x9d, 0x4c, 0x76, 0x57, 0x1a, 0x43,
0xf7, 0x94, 0xe1, 0x97, 0xef, 0xf7, 0xfd, 0xc9, 0x7c, 0x04, 0xb8, 0xe9, 0x98, 0x70, 0xaa, 0x12,
0xc6, 0x55, 0x2c, 0x70, 0x42, 0xa2, 0x11, 0xe3, 0x14, 0x9f, 0xe6, 0x34, 0x2b, 0xbc, 0x34, 0x13,
0x4a, 0xc0, 0xf6, 0x32, 0xc2, 0x33, 0x08, 0xbb, 0x1d, 0x8b, 0x58, 0x68, 0x00, 0x9e, 0x9d, 0x4a,
0xac, 0xdd, 0x89, 0x85, 0x88, 0xc7, 0x14, 0x93, 0x94, 0x61, 0xc2, 0xb9, 0x50, 0x44, 0x31, 0xc1,
0xa5, 0x79, 0xfb, 0x28, 0x12, 0x32, 0x11, 0x12, 0x87, 0x44, 0x1a, 0x09, 0x7c, 0xb6, 0x1b, 0x52,
0x45, 0x76, 0x71, 0x4a, 0x62, 0xc6, 0x35, 0xd8, 0x60, 0x77, 0x6a, 0x7d, 0xa5, 0x24, 0x23, 0x49,
0x45, 0x87, 0x6a, 0x21, 0xe6, 0x59, 0x62, 0x50, 0x1b, 0xc0, 0xc3, 0x99, 0xd0, 0x50, 0x2f, 0xfa,
0xf4, 0x34, 0xa7, 0x52, 0xa1, 0x43, 0x70, 0xf7, 0x9f, 0xa9, 0x4c, 0x05, 0x97, 0x14, 0x3e, 0x07,
0x1b, 0xa5, 0xc0, 0xb6, 0xe5, 0x5a, 0xdd, 0xad, 0xbd, 0x8e, 0x57, 0x17, 0xdd, 0x2b, 0xb7, 0x06,
0xeb, 0x97, 0xdf, 0x1f, 0xb4, 0x7c, 0xb3, 0x81, 0xf6, 0xc1, 0x8e, 0xa6, 0x7c, 0x45, 0xd5, 0x41,
0x89, 0x1b, 0x14, 0xc3, 0x3c, 0x1c, 0xb3, 0xe8, 0x35, 0x2d, 0x8c, 0x2e, 0xec, 0x80, 0xcd, 0xb4,
0x9a, 0x69, 0x8d, 0x4d, 0x7f, 0x31, 0x40, 0xef, 0x00, 0x6a, 0xa2, 0x30, 0x26, 0xfb, 0xe0, 0xb6,
0x31, 0x62, 0x5c, 0xde, 0xaf, 0x77, 0x69, 0x28, 0xfc, 0x0a, 0x8d, 0x5e, 0x02, 0xb7, 0xa2, 0x3f,
0xca, 0x72, 0xa9, 0xf6, 0x79, 0x34, 0x12, 0xd9, 0x1b, 0x45, 0x54, 0x2e, 0x97, 0x0c, 0x1a, 0x38,
0x3b, 0xa9, 0x0c, 0xce, 0x07, 0x28, 0x5a, 0x64, 0xac, 0x61, 0x30, 0xfe, 0x1a, 0x29, 0xa0, 0x0b,
0xb6, 0x98, 0x24, 0x91, 0x62, 0x67, 0x44, 0xd1, 0x93, 0xed, 0x35, 0xd7, 0xea, 0xde, 0xf1, 0x97,
0x47, 0x7b, 0x7f, 0xd6, 0xc1, 0x2d, 0xad, 0x02, 0xbf, 0x58, 0x60, 0xa3, 0xfc, 0xd6, 0xb0, 0x5b,
0x9f, 0xf1, 0xfa, 0xd5, 0xda, 0x0f, 0x6f, 0x80, 0x2c, 0x9d, 0xa2, 0x17, 0x1f, 0xbf, 0xfe, 0xfa,
0xbc, 0xf6, 0x04, 0xf6, 0x70, 0xcc, 0xd4, 0x28, 0x0f, 0xbd, 0x48, 0x24, 0x78, 0xb1, 0xbd, 0x74,
0x7c, 0x7c, 0xad, 0x82, 0xf0, 0xb7, 0x05, 0xee, 0xd5, 0x5e, 0x14, 0xec, 0x37, 0x38, 0x68, 0x6a,
0x87, 0xfd, 0x6c, 0xf5, 0x45, 0x93, 0xe4, 0x58, 0x27, 0x39, 0x82, 0xfe, 0x4a, 0x49, 0x62, 0xaa,
0x02, 0x73, 0x0e, 0xc2, 0x22, 0x28, 0x8b, 0x18, 0xbc, 0xa7, 0x05, 0x3e, 0x9f, 0x97, 0xf2, 0x02,
0xfe, 0xb4, 0x40, 0xbb, 0xee, 0xc2, 0xe1, 0xd3, 0x66, 0xbb, 0xff, 0xeb, 0x98, 0xdd, 0x5f, 0x79,
0xcf, 0xa4, 0x7c, 0xab, 0x53, 0xfa, 0x70, 0xb8, 0x72, 0x4a, 0x35, 0xe3, 0x0c, 0x88, 0x26, 0x0d,
0xa4, 0x66, 0xc5, 0xe7, 0xf3, 0x52, 0x5e, 0x0c, 0x0e, 0x2e, 0x27, 0x8e, 0x75, 0x35, 0x71, 0xac,
0x1f, 0x13, 0xc7, 0xfa, 0x34, 0x75, 0x5a, 0x57, 0x53, 0xa7, 0xf5, 0x6d, 0xea, 0xb4, 0x8e, 0x7b,
0x37, 0x91, 0xfa, 0x30, 0x17, 0x53, 0x45, 0x4a, 0x65, 0xb8, 0xa1, 0xff, 0x3d, 0xbd, 0xbf, 0x01,
0x00, 0x00, 0xff, 0xff, 0xc0, 0xb6, 0xdb, 0x5a, 0x5c, 0x05, 0x00, 0x00,
// 593 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x54, 0x41, 0x6b, 0x13, 0x41,
0x18, 0xcd, 0x16, 0x4d, 0xed, 0xf4, 0x36, 0x8d, 0x10, 0x96, 0xb8, 0x4d, 0xe7, 0x14, 0x05, 0x33,
0xb4, 0xa1, 0x8d, 0xda, 0x83, 0x26, 0x17, 0x0f, 0x52, 0x48, 0xd7, 0x1e, 0xa4, 0x22, 0xcb, 0xec,
0x66, 0xd8, 0x2c, 0x26, 0x3b, 0xdb, 0x9d, 0xd9, 0xe2, 0x12, 0x72, 0xf1, 0x17, 0x08, 0xde, 0xfc,
0x27, 0xfe, 0x00, 0xa1, 0xc7, 0x82, 0x17, 0x4f, 0xa2, 0x89, 0xf8, 0x3b, 0x24, 0xb3, 0xb3, 0x49,
0x4a, 0xd6, 0x90, 0xa5, 0xa7, 0x4c, 0xbe, 0xbc, 0xf7, 0xbe, 0xf7, 0x66, 0xbe, 0x2f, 0xa0, 0x1a,
0xf4, 0x89, 0x4f, 0xc5, 0xc0, 0xf3, 0x85, 0xcb, 0xf0, 0x80, 0x38, 0x3d, 0xcf, 0xa7, 0xf8, 0x22,
0xa2, 0x61, 0x5c, 0x0f, 0x42, 0x26, 0x18, 0x2c, 0x2d, 0x22, 0xea, 0x0a, 0xa1, 0x97, 0x5c, 0xe6,
0x32, 0x09, 0xc0, 0xd3, 0x53, 0x82, 0xd5, 0x2b, 0x2e, 0x63, 0x6e, 0x9f, 0x62, 0x12, 0x78, 0x98,
0xf8, 0x3e, 0x13, 0x44, 0x78, 0xcc, 0xe7, 0xea, 0xd7, 0x47, 0x0e, 0xe3, 0x03, 0xc6, 0xb1, 0x4d,
0xb8, 0x6a, 0x81, 0x2f, 0xf7, 0x6d, 0x2a, 0xc8, 0x3e, 0x0e, 0x88, 0xeb, 0xf9, 0x12, 0xac, 0xb0,
0x7b, 0x99, 0xbe, 0x02, 0x12, 0x92, 0x41, 0x2a, 0x87, 0x32, 0x21, 0xea, 0x33, 0xc1, 0xa0, 0x12,
0x80, 0xa7, 0xd3, 0x46, 0x1d, 0x49, 0x34, 0xe9, 0x45, 0x44, 0xb9, 0x40, 0xa7, 0x60, 0xe7, 0x46,
0x95, 0x07, 0xcc, 0xe7, 0x14, 0x3e, 0x03, 0xc5, 0xa4, 0x41, 0x59, 0xab, 0x6a, 0xb5, 0xed, 0x83,
0x4a, 0x3d, 0x2b, 0x7a, 0x3d, 0x61, 0xb5, 0xef, 0x5c, 0xfd, 0xdc, 0x2d, 0x98, 0x8a, 0x81, 0x5a,
0x60, 0x4f, 0x4a, 0xbe, 0xa4, 0xe2, 0x24, 0xc1, 0xb5, 0xe3, 0x4e, 0x64, 0xf7, 0x3d, 0xe7, 0x15,
0x8d, 0x55, 0x5f, 0x58, 0x01, 0x5b, 0x41, 0x5a, 0x93, 0x3d, 0xb6, 0xcc, 0x79, 0x01, 0xbd, 0x03,
0x68, 0x95, 0x84, 0x32, 0xd9, 0x04, 0x9b, 0xca, 0x88, 0x72, 0xf9, 0x20, 0xdb, 0xa5, 0x92, 0x30,
0x53, 0x34, 0x7a, 0x01, 0xaa, 0xa9, 0xfc, 0x59, 0x18, 0x71, 0xd1, 0xf2, 0x9d, 0x1e, 0x0b, 0x5f,
0x0b, 0x22, 0x22, 0xbe, 0x60, 0x50, 0xc1, 0xbd, 0x6e, 0x6a, 0x70, 0x56, 0x40, 0xce, 0x3c, 0x63,
0x86, 0x82, 0xf2, 0xb7, 0x52, 0x02, 0x56, 0xc1, 0xb6, 0xc7, 0x89, 0x23, 0xbc, 0x4b, 0x22, 0x68,
0xb7, 0xbc, 0x51, 0xd5, 0x6a, 0xf7, 0xcc, 0xc5, 0x12, 0x3a, 0x06, 0xbb, 0x4b, 0xb7, 0xd0, 0xea,
0x76, 0x43, 0xca, 0x67, 0x2e, 0xcb, 0x60, 0x93, 0x24, 0x15, 0xd5, 0x20, 0xfd, 0x8a, 0xde, 0xce,
0x33, 0x2e, 0x93, 0x6f, 0x79, 0x81, 0x07, 0x5f, 0x8b, 0xe0, 0xae, 0x54, 0x87, 0x5f, 0x34, 0x50,
0x4c, 0xa6, 0x00, 0xd6, 0xb2, 0xc9, 0xcb, 0x43, 0xa7, 0x3f, 0x5c, 0x03, 0x99, 0x58, 0x44, 0xc7,
0x1f, 0xbf, 0xff, 0xf9, 0xbc, 0x71, 0x08, 0x1b, 0xd8, 0xf5, 0x44, 0x2f, 0xb2, 0xeb, 0x0e, 0x1b,
0xe0, 0x39, 0x7b, 0xe1, 0xf8, 0x78, 0x69, 0x39, 0xe0, 0x5f, 0x0d, 0xdc, 0xcf, 0x1c, 0x21, 0xd8,
0x5c, 0xe1, 0x60, 0xd5, 0xdc, 0xea, 0x4f, 0xf2, 0x13, 0x55, 0x92, 0x73, 0x99, 0xe4, 0x0c, 0x9a,
0xb9, 0x92, 0xb8, 0x54, 0x58, 0xea, 0x6c, 0xd9, 0xb1, 0x95, 0xac, 0x88, 0xf5, 0x9e, 0xc6, 0x78,
0x38, 0x5b, 0x97, 0x11, 0xfc, 0xad, 0x81, 0x52, 0xd6, 0x28, 0xc2, 0xa3, 0xd5, 0x76, 0xff, 0x37,
0xfd, 0x7a, 0x33, 0x37, 0x4f, 0xa5, 0x7c, 0x23, 0x53, 0x9a, 0xb0, 0x93, 0x3b, 0xa5, 0x98, 0x6a,
0x5a, 0x44, 0x8a, 0x5a, 0x5c, 0xaa, 0xe2, 0xe1, 0x6c, 0x5d, 0x46, 0xf0, 0x9b, 0x06, 0x76, 0x32,
0x86, 0x19, 0x1e, 0xae, 0xf9, 0x22, 0x37, 0x37, 0x47, 0x3f, 0xca, 0x4b, 0x53, 0x01, 0x9f, 0xcb,
0x80, 0x4f, 0x61, 0x73, 0xbd, 0x07, 0x53, 0xeb, 0x88, 0x87, 0xea, 0x30, 0x6a, 0x9f, 0x5c, 0x8d,
0x0d, 0xed, 0x7a, 0x6c, 0x68, 0xbf, 0xc6, 0x86, 0xf6, 0x69, 0x62, 0x14, 0xae, 0x27, 0x46, 0xe1,
0xc7, 0xc4, 0x28, 0x9c, 0x37, 0xd6, 0xb9, 0xb2, 0x0f, 0xb3, 0x4e, 0x22, 0x0e, 0x28, 0xb7, 0x8b,
0xf2, 0xdf, 0xbd, 0xf1, 0x2f, 0x00, 0x00, 0xff, 0xff, 0x26, 0xcc, 0xd3, 0xe4, 0xbe, 0x06, 0x00,
0x00,
}
// Reference imports to suppress errors if they are not otherwise used.
@ -363,6 +458,8 @@ type QueryClient interface {
GetMachineByPublicKey(ctx context.Context, in *QueryGetMachineByPublicKeyRequest, opts ...grpc.CallOption) (*QueryGetMachineByPublicKeyResponse, error)
// Queries a list of GetTrustAnchorStatus items.
GetTrustAnchorStatus(ctx context.Context, in *QueryGetTrustAnchorStatusRequest, opts ...grpc.CallOption) (*QueryGetTrustAnchorStatusResponse, error)
// Queries a list of GetMachineByAddress items.
GetMachineByAddress(ctx context.Context, in *QueryGetMachineByAddressRequest, opts ...grpc.CallOption) (*QueryGetMachineByAddressResponse, error)
}
type queryClient struct {
@ -400,6 +497,15 @@ func (c *queryClient) GetTrustAnchorStatus(ctx context.Context, in *QueryGetTrus
return out, nil
}
func (c *queryClient) GetMachineByAddress(ctx context.Context, in *QueryGetMachineByAddressRequest, opts ...grpc.CallOption) (*QueryGetMachineByAddressResponse, error) {
out := new(QueryGetMachineByAddressResponse)
err := c.cc.Invoke(ctx, "/planetmintgo.machine.Query/GetMachineByAddress", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// QueryServer is the server API for Query service.
type QueryServer interface {
// Parameters queries the parameters of the module.
@ -408,6 +514,8 @@ type QueryServer interface {
GetMachineByPublicKey(context.Context, *QueryGetMachineByPublicKeyRequest) (*QueryGetMachineByPublicKeyResponse, error)
// Queries a list of GetTrustAnchorStatus items.
GetTrustAnchorStatus(context.Context, *QueryGetTrustAnchorStatusRequest) (*QueryGetTrustAnchorStatusResponse, error)
// Queries a list of GetMachineByAddress items.
GetMachineByAddress(context.Context, *QueryGetMachineByAddressRequest) (*QueryGetMachineByAddressResponse, error)
}
// UnimplementedQueryServer can be embedded to have forward compatible implementations.
@ -423,6 +531,9 @@ func (*UnimplementedQueryServer) GetMachineByPublicKey(ctx context.Context, req
func (*UnimplementedQueryServer) GetTrustAnchorStatus(ctx context.Context, req *QueryGetTrustAnchorStatusRequest) (*QueryGetTrustAnchorStatusResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetTrustAnchorStatus not implemented")
}
func (*UnimplementedQueryServer) GetMachineByAddress(ctx context.Context, req *QueryGetMachineByAddressRequest) (*QueryGetMachineByAddressResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetMachineByAddress not implemented")
}
func RegisterQueryServer(s grpc1.Server, srv QueryServer) {
s.RegisterService(&_Query_serviceDesc, srv)
@ -482,6 +593,24 @@ func _Query_GetTrustAnchorStatus_Handler(srv interface{}, ctx context.Context, d
return interceptor(ctx, in, info, handler)
}
func _Query_GetMachineByAddress_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(QueryGetMachineByAddressRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(QueryServer).GetMachineByAddress(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/planetmintgo.machine.Query/GetMachineByAddress",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(QueryServer).GetMachineByAddress(ctx, req.(*QueryGetMachineByAddressRequest))
}
return interceptor(ctx, in, info, handler)
}
var _Query_serviceDesc = grpc.ServiceDesc{
ServiceName: "planetmintgo.machine.Query",
HandlerType: (*QueryServer)(nil),
@ -498,6 +627,10 @@ var _Query_serviceDesc = grpc.ServiceDesc{
MethodName: "GetTrustAnchorStatus",
Handler: _Query_GetTrustAnchorStatus_Handler,
},
{
MethodName: "GetMachineByAddress",
Handler: _Query_GetMachineByAddress_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "planetmintgo/machine/query.proto",
@ -694,6 +827,71 @@ func (m *QueryGetTrustAnchorStatusResponse) MarshalToSizedBuffer(dAtA []byte) (i
return len(dAtA) - i, nil
}
func (m *QueryGetMachineByAddressRequest) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *QueryGetMachineByAddressRequest) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *QueryGetMachineByAddressRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
if len(m.Address) > 0 {
i -= len(m.Address)
copy(dAtA[i:], m.Address)
i = encodeVarintQuery(dAtA, i, uint64(len(m.Address)))
i--
dAtA[i] = 0xa
}
return len(dAtA) - i, nil
}
func (m *QueryGetMachineByAddressResponse) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *QueryGetMachineByAddressResponse) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *QueryGetMachineByAddressResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
if m.Machine != nil {
{
size, err := m.Machine.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintQuery(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0xa
}
return len(dAtA) - i, nil
}
func encodeVarintQuery(dAtA []byte, offset int, v uint64) int {
offset -= sovQuery(v)
base := offset
@ -780,6 +978,32 @@ func (m *QueryGetTrustAnchorStatusResponse) Size() (n int) {
return n
}
func (m *QueryGetMachineByAddressRequest) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
l = len(m.Address)
if l > 0 {
n += 1 + l + sovQuery(uint64(l))
}
return n
}
func (m *QueryGetMachineByAddressResponse) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
if m.Machine != nil {
l = m.Machine.Size()
n += 1 + l + sovQuery(uint64(l))
}
return n
}
func sovQuery(x uint64) (n int) {
return (math_bits.Len64(x|1) + 6) / 7
}
@ -1271,6 +1495,174 @@ func (m *QueryGetTrustAnchorStatusResponse) Unmarshal(dAtA []byte) error {
}
return nil
}
func (m *QueryGetMachineByAddressRequest) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowQuery
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: QueryGetMachineByAddressRequest: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: QueryGetMachineByAddressRequest: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowQuery
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthQuery
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthQuery
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Address = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipQuery(dAtA[iNdEx:])
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthQuery
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *QueryGetMachineByAddressResponse) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowQuery
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: QueryGetMachineByAddressResponse: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: QueryGetMachineByAddressResponse: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Machine", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowQuery
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthQuery
}
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthQuery
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Machine == nil {
m.Machine = &Machine{}
}
if err := m.Machine.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipQuery(dAtA[iNdEx:])
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthQuery
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func skipQuery(dAtA []byte) (n int, err error) {
l := len(dAtA)
iNdEx := 0

101
x/machine/types/query.pb.gw.go
View File

@ -159,6 +159,60 @@ func local_request_Query_GetTrustAnchorStatus_0(ctx context.Context, marshaler r
}
func request_Query_GetMachineByAddress_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq QueryGetMachineByAddressRequest
var metadata runtime.ServerMetadata
var (
val string
ok bool
err error
_ = err
)
val, ok = pathParams["address"]
if !ok {
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "address")
}
protoReq.Address, err = runtime.String(val)
if err != nil {
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "address", err)
}
msg, err := client.GetMachineByAddress(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
return msg, metadata, err
}
func local_request_Query_GetMachineByAddress_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq QueryGetMachineByAddressRequest
var metadata runtime.ServerMetadata
var (
val string
ok bool
err error
_ = err
)
val, ok = pathParams["address"]
if !ok {
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "address")
}
protoReq.Address, err = runtime.String(val)
if err != nil {
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "address", err)
}
msg, err := server.GetMachineByAddress(ctx, &protoReq)
return msg, metadata, err
}
// RegisterQueryHandlerServer registers the http handlers for service Query to "mux".
// UnaryRPC :call QueryServer directly.
// StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906.
@ -234,6 +288,29 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv
})
mux.Handle("GET", pattern_Query_GetMachineByAddress_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
ctx, cancel := context.WithCancel(req.Context())
defer cancel()
var stream runtime.ServerTransportStream
ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
resp, md, err := local_request_Query_GetMachineByAddress_0(rctx, inboundMarshaler, server, req, pathParams)
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
ctx = runtime.NewServerMetadataContext(ctx, md)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
forward_Query_GetMachineByAddress_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
})
return nil
}
@ -335,6 +412,26 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie
})
mux.Handle("GET", pattern_Query_GetMachineByAddress_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
ctx, cancel := context.WithCancel(req.Context())
defer cancel()
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
rctx, err := runtime.AnnotateContext(ctx, mux, req)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
resp, md, err := request_Query_GetMachineByAddress_0(rctx, inboundMarshaler, client, req, pathParams)
ctx = runtime.NewServerMetadataContext(ctx, md)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
forward_Query_GetMachineByAddress_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
})
return nil
}
@ -344,6 +441,8 @@ var (
pattern_Query_GetMachineByPublicKey_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4, 1, 0, 4, 1, 5, 5}, []string{"github.com", "planetmint", "planetmint-go", "machine", "get_machine_by_public_key", "publicKey"}, "", runtime.AssumeColonVerbOpt(true)))
pattern_Query_GetTrustAnchorStatus_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4, 1, 0, 4, 1, 5, 5}, []string{"github.com", "planetmint", "planetmint-go", "machine", "get_trust_anchor_status", "machineid"}, "", runtime.AssumeColonVerbOpt(true)))
pattern_Query_GetMachineByAddress_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3}, []string{"planetmint-go", "machine", "get_machine_by_address", "address"}, "", runtime.AssumeColonVerbOpt(true)))
)
var (
@ -352,4 +451,6 @@ var (
forward_Query_GetMachineByPublicKey_0 = runtime.ForwardResponseMessage
forward_Query_GetTrustAnchorStatus_0 = runtime.ForwardResponseMessage
forward_Query_GetMachineByAddress_0 = runtime.ForwardResponseMessage
)