github.com/stafiprotocol/go-substrate-rpc-client@v1.4.7/pkg/gethrpc/doc.go (about)

     1  // Copyright 2015 The go-ethereum Authors
     2  // This file is part of the go-ethereum library.
     3  //
     4  // The go-ethereum library is free software: you can redistribute it and/or modify
     5  // it under the terms of the GNU Lesser General Public License as published by
     6  // the Free Software Foundation, either version 3 of the License, or
     7  // (at your option) any later version.
     8  //
     9  // The go-ethereum library is distributed in the hope that it will be useful,
    10  // but WITHOUT ANY WARRANTY; without even the implied warranty of
    11  // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
    12  // GNU Lesser General Public License for more details.
    13  //
    14  // You should have received a copy of the GNU Lesser General Public License
    15  // along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
    16  
    17  /*
    18  Package rpc implements bi-directional JSON-RPC 2.0 on multiple transports.
    19  
    20  It provides access to the exported methods of an object across a network or other I/O
    21  connection. After creating a server or client instance, objects can be registered to make
    22  them visible as 'services'. Exported methods that follow specific conventions can be
    23  called remotely. It also has support for the publish/subscribe pattern.
    24  
    25  # RPC Methods
    26  
    27  Methods that satisfy the following criteria are made available for remote access:
    28  
    29    - method must be exported
    30    - method returns 0, 1 (response or error) or 2 (response and error) values
    31    - method argument(s) must be exported or builtin types
    32    - method returned value(s) must be exported or builtin types
    33  
    34  An example method:
    35  
    36  	func (s *CalcService) Add(a, b int) (int, error)
    37  
    38  When the returned error isn't nil the returned integer is ignored and the error is sent
    39  back to the client. Otherwise the returned integer is sent back to the client.
    40  
    41  Optional arguments are supported by accepting pointer values as arguments. E.g. if we want
    42  to do the addition in an optional finite field we can accept a mod argument as pointer
    43  value.
    44  
    45  	func (s *CalcService) Add(a, b int, mod *int) (int, error)
    46  
    47  This RPC method can be called with 2 integers and a null value as third argument. In that
    48  case the mod argument will be nil. Or it can be called with 3 integers, in that case mod
    49  will be pointing to the given third argument. Since the optional argument is the last
    50  argument the RPC package will also accept 2 integers as arguments. It will pass the mod
    51  argument as nil to the RPC method.
    52  
    53  The server offers the ServeCodec method which accepts a ServerCodec instance. It will read
    54  requests from the codec, process the request and sends the response back to the client
    55  using the codec. The server can execute requests concurrently. Responses can be sent back
    56  to the client out of order.
    57  
    58  An example server which uses the JSON codec:
    59  
    60  	 type CalculatorService struct {}
    61  
    62  	 func (s *CalculatorService) Add(a, b int) int {
    63  		return a + b
    64  	 }
    65  
    66  	 func (s *CalculatorService) Div(a, b int) (int, error) {
    67  		if b == 0 {
    68  			return 0, errors.New("divide by zero")
    69  		}
    70  		return a/b, nil
    71  	 }
    72  
    73  	 calculator := new(CalculatorService)
    74  	 server := NewServer()
    75  	 server.RegisterName("calculator", calculator")
    76  
    77  	 l, _ := net.ListenUnix("unix", &net.UnixAddr{Net: "unix", Name: "/tmp/calculator.sock"})
    78  	 for {
    79  		c, _ := l.AcceptUnix()
    80  		codec := v2.NewJSONCodec(c)
    81  		go server.ServeCodec(codec, 0)
    82  	 }
    83  
    84  # Subscriptions
    85  
    86  The package also supports the publish subscribe pattern through the use of subscriptions.
    87  A method that is considered eligible for notifications must satisfy the following
    88  criteria:
    89  
    90    - method must be exported
    91    - first method argument type must be context.Context
    92    - method argument(s) must be exported or builtin types
    93    - method must have return types (rpc.Subscription, error)
    94  
    95  An example method:
    96  
    97  	func (s *BlockChainService) NewBlocks(ctx context.Context) (rpc.Subscription, error) {
    98  		...
    99  	}
   100  
   101  When the service containing the subscription method is registered to the server, for
   102  example under the "blockchain" namespace, a subscription is created by calling the
   103  "blockchain_subscribe" method.
   104  
   105  Subscriptions are deleted when the user sends an unsubscribe request or when the
   106  connection which was used to create the subscription is closed. This can be initiated by
   107  the client and server. The server will close the connection for any write error.
   108  
   109  For more information about subscriptions, see https://github.com/ethereum/go-ethereum/wiki/RPC-PUB-SUB.
   110  
   111  # Reverse Calls
   112  
   113  In any method handler, an instance of rpc.Client can be accessed through the
   114  ClientFromContext method. Using this client instance, server-to-client method calls can be
   115  performed on the RPC connection.
   116  */
   117  package rpc