github.com/linapex/ethereum-dpos-chinese@v0.0.0-20190316121959-b78b3a4a1ece/cmd/swarm/mru.go (about)

     1  
     2  //<developer>
     3  //    <name>linapex 曹一峰</name>
     4  //    <email>linapex@163.com</email>
     5  //    <wx>superexc</wx>
     6  //    <qqgroup>128148617</qqgroup>
     7  //    <url>https://jsq.ink</url>
     8  //    <role>pku engineer</role>
     9  //    <date>2019-03-16 12:09:31</date>
    10  //</624342606167412736>
    11  
    12  
    13  //
    14  package main
    15  
    16  import (
    17  	"fmt"
    18  	"strconv"
    19  	"strings"
    20  
    21  	"github.com/ethereum/go-ethereum/common/hexutil"
    22  
    23  	"github.com/ethereum/go-ethereum/cmd/utils"
    24  	swarm "github.com/ethereum/go-ethereum/swarm/api/client"
    25  	"github.com/ethereum/go-ethereum/swarm/storage/mru"
    26  	"gopkg.in/urfave/cli.v1"
    27  )
    28  
    29  func NewGenericSigner(ctx *cli.Context) mru.Signer {
    30  	return mru.NewGenericSigner(getPrivKey(ctx))
    31  }
    32  
    33  //Swarm资源创建
    34  //
    35  //swarm resource info<manifest address or ens domain>
    36  
    37  func resourceCreate(ctx *cli.Context) {
    38  	args := ctx.Args()
    39  
    40  	var (
    41  		bzzapi      = strings.TrimRight(ctx.GlobalString(SwarmApiFlag.Name), "/")
    42  		client      = swarm.NewClient(bzzapi)
    43  		multihash   = ctx.Bool(SwarmResourceMultihashFlag.Name)
    44  		initialData = ctx.String(SwarmResourceDataOnCreateFlag.Name)
    45  		name        = ctx.String(SwarmResourceNameFlag.Name)
    46  	)
    47  
    48  	if len(args) < 1 {
    49  		fmt.Println("Incorrect number of arguments")
    50  		cli.ShowCommandHelpAndExit(ctx, "create", 1)
    51  		return
    52  	}
    53  	signer := NewGenericSigner(ctx)
    54  	frequency, err := strconv.ParseUint(args[0], 10, 64)
    55  	if err != nil {
    56  		fmt.Printf("Frequency formatting error: %s\n", err.Error())
    57  		cli.ShowCommandHelpAndExit(ctx, "create", 1)
    58  		return
    59  	}
    60  
    61  	metadata := mru.ResourceMetadata{
    62  		Name:      name,
    63  		Frequency: frequency,
    64  		Owner:     signer.Address(),
    65  	}
    66  
    67  	var newResourceRequest *mru.Request
    68  	if initialData != "" {
    69  		initialDataBytes, err := hexutil.Decode(initialData)
    70  		if err != nil {
    71  			fmt.Printf("Error parsing data: %s\n", err.Error())
    72  			cli.ShowCommandHelpAndExit(ctx, "create", 1)
    73  			return
    74  		}
    75  		newResourceRequest, err = mru.NewCreateUpdateRequest(&metadata)
    76  		if err != nil {
    77  			utils.Fatalf("Error creating new resource request: %s", err)
    78  		}
    79  		newResourceRequest.SetData(initialDataBytes, multihash)
    80  		if err = newResourceRequest.Sign(signer); err != nil {
    81  			utils.Fatalf("Error signing resource update: %s", err.Error())
    82  		}
    83  	} else {
    84  		newResourceRequest, err = mru.NewCreateRequest(&metadata)
    85  		if err != nil {
    86  			utils.Fatalf("Error creating new resource request: %s", err)
    87  		}
    88  	}
    89  
    90  	manifestAddress, err := client.CreateResource(newResourceRequest)
    91  	if err != nil {
    92  		utils.Fatalf("Error creating resource: %s", err.Error())
    93  		return
    94  	}
    95  fmt.Println(manifestAddress) //
    96  
    97  }
    98  
    99  func resourceUpdate(ctx *cli.Context) {
   100  	args := ctx.Args()
   101  
   102  	var (
   103  		bzzapi    = strings.TrimRight(ctx.GlobalString(SwarmApiFlag.Name), "/")
   104  		client    = swarm.NewClient(bzzapi)
   105  		multihash = ctx.Bool(SwarmResourceMultihashFlag.Name)
   106  	)
   107  
   108  	if len(args) < 2 {
   109  		fmt.Println("Incorrect number of arguments")
   110  		cli.ShowCommandHelpAndExit(ctx, "update", 1)
   111  		return
   112  	}
   113  	signer := NewGenericSigner(ctx)
   114  	manifestAddressOrDomain := args[0]
   115  	data, err := hexutil.Decode(args[1])
   116  	if err != nil {
   117  		utils.Fatalf("Error parsing data: %s", err.Error())
   118  		return
   119  	}
   120  
   121  //
   122  	updateRequest, err := client.GetResourceMetadata(manifestAddressOrDomain)
   123  	if err != nil {
   124  		utils.Fatalf("Error retrieving resource status: %s", err.Error())
   125  	}
   126  
   127  //设置新数据
   128  	updateRequest.SetData(data, multihash)
   129  
   130  //
   131  	if err = updateRequest.Sign(signer); err != nil {
   132  		utils.Fatalf("Error signing resource update: %s", err.Error())
   133  	}
   134  
   135  //更新后
   136  	err = client.UpdateResource(updateRequest)
   137  	if err != nil {
   138  		utils.Fatalf("Error updating resource: %s", err.Error())
   139  		return
   140  	}
   141  }
   142  
   143  func resourceInfo(ctx *cli.Context) {
   144  	var (
   145  		bzzapi = strings.TrimRight(ctx.GlobalString(SwarmApiFlag.Name), "/")
   146  		client = swarm.NewClient(bzzapi)
   147  	)
   148  	args := ctx.Args()
   149  	if len(args) < 1 {
   150  		fmt.Println("Incorrect number of arguments.")
   151  		cli.ShowCommandHelpAndExit(ctx, "info", 1)
   152  		return
   153  	}
   154  	manifestAddressOrDomain := args[0]
   155  	metadata, err := client.GetResourceMetadata(manifestAddressOrDomain)
   156  	if err != nil {
   157  		utils.Fatalf("Error retrieving resource metadata: %s", err.Error())
   158  		return
   159  	}
   160  	encodedMetadata, err := metadata.MarshalJSON()
   161  	if err != nil {
   162  		utils.Fatalf("Error encoding metadata to JSON for display:%s", err)
   163  	}
   164  	fmt.Println(string(encodedMetadata))
   165  }
   166