provider

Documentation

Overview

Package provider provides subcommands to manage the providers of the Grid.

USAGE:

dps provider command [command options] [arguments...]

COMMANDS:

list     List providers.
approve  Approve a provider.
remove   Remove a provider.
help, h  Shows a list of commands or help for one command

Index

• Variables

Variables

var Command = cli.Command{
	Name:  "provider",
	Usage: "Manage providers (need to use an admin smart-contract).",
	Subcommands: []*cli.Command{
		{
			Name:  "list",
			Usage: "List providers.",
			Flags: flags,
			Action: func(cCtx *cli.Context) error {
				ctx := cCtx.Context
				rpcClient, err := rpc.DialOptions(
					ctx,
					ethEndpointRPC,
					rpc.WithHTTPClient(http.DefaultClient),
				)
				if err != nil {
					return err
				}
				defer rpcClient.Close()
				ethClientRPC := ethclient.NewClient(rpcClient)
				chainID, err := ethClientRPC.ChainID(ctx)
				if err != nil {
					return err
				}
				clientset := metascheduler.NewRPCClientSet(metascheduler.Backend{
					EthereumBackend:      ethClientRPC,
					MetaschedulerAddress: common.HexToAddress(metaschedulerSmartContract),
					ChainID:              chainID,
				})
				providers, err := clientset.ProviderManager().GetProviders(ctx)
				if err != nil {
					return err
				}
				providersJSON, err := json.MarshalIndent(providers, "", "  ")
				if err != nil {
					return err
				}
				fmt.Println(string(providersJSON))
				return nil
			},
		},
		{
			Name:      "approve",
			Usage:     "Approve a provider.",
			ArgsUsage: "<0x>",
			Flags:     authFlags,
			Action: func(cCtx *cli.Context) error {
				if cCtx.NArg() < 1 {
					return errors.New("missing arguments")
				}
				ctx := cCtx.Context
				pk, err := crypto.HexToECDSA(ethHexPK)
				if err != nil {
					return err
				}
				providerAddress := common.HexToAddress(cCtx.Args().First())
				rpcClient, err := rpc.DialOptions(
					ctx,
					ethEndpointRPC,
					rpc.WithHTTPClient(http.DefaultClient),
				)
				if err != nil {
					return err
				}
				defer rpcClient.Close()
				ethClientRPC := ethclient.NewClient(rpcClient)
				chainID, err := ethClientRPC.ChainID(ctx)
				if err != nil {
					return err
				}
				clientset := metascheduler.NewRPCClientSet(metascheduler.Backend{
					EthereumBackend:      ethClientRPC,
					MetaschedulerAddress: common.HexToAddress(metaschedulerSmartContract),
					ChainID:              chainID,
					UserPrivateKey:       pk,
				})
				return clientset.ProviderManager().Approve(ctx, providerAddress)
			},
		},
		{
			Name:      "remove",
			Usage:     "Remove a provider.",
			ArgsUsage: "<0x>",
			Flags:     authFlags,
			Action: func(cCtx *cli.Context) error {
				if cCtx.NArg() < 1 {
					return errors.New("missing arguments")
				}
				ctx := cCtx.Context
				pk, err := crypto.HexToECDSA(ethHexPK)
				if err != nil {
					return err
				}
				providerAddress := common.HexToAddress(cCtx.Args().First())
				rpcClient, err := rpc.DialOptions(
					ctx,
					ethEndpointRPC,
					rpc.WithHTTPClient(http.DefaultClient),
				)
				if err != nil {
					return err
				}
				defer rpcClient.Close()
				ethClientRPC := ethclient.NewClient(rpcClient)
				chainID, err := ethClientRPC.ChainID(ctx)
				if err != nil {
					return err
				}
				clientset := metascheduler.NewRPCClientSet(metascheduler.Backend{
					EthereumBackend:      ethClientRPC,
					MetaschedulerAddress: common.HexToAddress(metaschedulerSmartContract),
					ChainID:              chainID,
					UserPrivateKey:       pk,
				})
				return clientset.ProviderManager().Remove(ctx, providerAddress)
			},
		},
	},
}

Command is the provider command used to manage providers.