Package RPC

Remote precedure call

The package net/rpc allows Go programs to communicate each others. The package provides access to remote exported methods of an object, implementing a client-server paradigm. Methods have made visible to remote clients as a service with the name of the type of the object. Objects must be exported and registered on the server in order to be accessible. A server may register multiple objects of different types but you can not register objects of the same type.

 Only the exported methods that meet certain conditions are made accessible:

  • the method has two arguments, both exported (or builtin) types
  • the method's second argument is a pointer, but usually also the first is a pointer
  • the method has return type error
The methods that meet these criteria are remotely accessible, other methods of the object are ignored and not accessible.

Communication occurs serializing the parameters through the gob format. The transport is done using a raw network connection (TCP protocol) or HTTP (HTTP over TCP protocol).
Here a non-trivial example.

The data model

These are objects used as an interchange between client and server.
package model
type Order struct {
    IdCustomer int
    Items []*Product
}
type Product struct {
    Id int
    Name string
    Quantity int
    Cost float64
}
type OrderReference struct {
    Id int
    IdCustomer int
    Total float64
}

The server

The server exposes the method RegisterOrder to store orders.
package main
import(
    "fmt"
    "log"
    "errors"
    "net"
    "net/rpc"
    "net/http"
    "github.com/maxzerbini/packagemain/rpc/model"
)
type OrderServer struct {
    endpoint string
    referenceId int
}
// Register a new order.
func (srv *OrderServer) RegisterOrder(order *model.Order, reply *model.OrderReference) (err error) {
    defer func() {
        // Executes normally even if there is a panic
        if e:= recover(); e != nil {
            log.Println("Run time panic: %v", e)
            err = errors.New("Runtime error.")
        }
    }()
    // simulate order management creating a order reference id
    // (in a true case the order will be saved on a database)
    log.Printf("Order received %v", order)
    reply.Id = srv.referenceId
    for _,item := range order.Items {
        reply.Total += item.Cost * float64(item.Quantity)
    }
    reply.IdCustomer = order.IdCustomer
    return err
}
// Start listening commands.
func (srv *OrderServer)Do(){
    rpc.Register(srv)
    rpc.HandleHTTP()
    listener, e := net.Listen("tcp", srv.endpoint)
    if e != nil {
        log.Fatal("Starting RPC-server -listen error:", e)
    }
    log.Println("Server started ...")
    http.Serve(listener, nil)
}
func NewOrderServer(endpoint string) *OrderServer{
    s := &OrderServer{endpoint:endpoint, referenceId:1}
    return s
}
func main(){
    endpoint := "localhost:9000"
    s := NewOrderServer(endpoint)
    go s.Do()
    _,_ = fmt.Scanln()  
}

The client

The client sends commands to the server and get the ID generated by the server.
package client
import(
    "log"
    "errors"
    "net/rpc"
    "github.com/maxzerbini/packagemain/rpc/model"
)
type OrderClient struct {
    endpoint string
    client *rpc.Client
}
func (nc *OrderClient) ConnectClient(){
    defer func() {
        // Println executes normally even if there is a panic
        if err := recover(); err != nil {
            log.Println("run time panic: %v", err)
        }
    }()
    client, err := rpc.DialHTTP("tcp", nc.endpoint)
    if err != nil {
        log.Printf("Error dialing server: %v \r\n", err)
    } else {
        log.Printf("Dialing server on %s done.\r\n",nc.endpoint)
        nc.client = client
    }
}
// Send an order
func (nc *OrderClient) SendOrder(order *model.Order) ( reference *model.OrderReference, err error) {
    defer func() {
        // executes normally even if there is a panic
        if e := recover(); e != nil {
            log.Printf("Error %v\r\n",e)
            reference = nil
            err = errors.New("Client runtime error.")
        }
    }()
    reference = new (model.OrderReference)
    err = nc.client.Call("OrderServer.RegisterOrder", order, ref)
    if err != nil {
        reference = nil
        log.Println("OrderServer.RegisterOrder error: ", err)
    }
    return reference, err
}
func NewOrderClient(endpoint string) *OrderClient{
    c := &OrderClient{endpoint:endpoint}
    c.ConnectClient()
    return c
}

Testing the client

This is an example of a call between clients and servers.
package main
import(
    "log"
    "github.com/maxzerbini/packagemain/rpc/model"
    "github.com/maxzerbini/packagemain/rpc/client"
)
func main(){
    endpoint := "localhost:9000"
    c := client.NewOrderClient(endpoint)
    o := &model.Order{IdCustomer:101,Items:make([]*model.Product,10)}
    for i := 0; i<10; i++ {
        o.Items[i] =&model.Product{Id:i,Name:"product",Quantity:1,Cost:5.3}
    }  
    if ref, err := c.SendOrder(o); err == nil {
        log.Printf("Order reference: %v\r\n", ref)
    } else {
        log.Printf("Error: %v", err)
    }
}
The full example code can be downloaded here:
https://github.com/maxzerbini/packagemain/tree/master/rpc



































Commenti











Posta un commento



















Post popolari in questo blog









OAuth 2.0 Server & Authorization Middleware for Gin-Gonic





















 Project OAuth  OAuth is an open source project developed in Go and available on GitHub .  The project offers an Authorization Server and an Authorization Middleware that can be used to make secure access to resources API and provide a simple and efficient implementation of the OAuth 2.0 specification.  Authorization Server and Middleware are both based on Gin-Gonic  and can interoperate with any other middleware available for this framework.      Authorization Server   The Authorization Server is implemented by the struct OAuthBearerServer  that manages two grant types of authorizations: password and client_credentials. This Authorization Server is made to provide authorization token usable for consuming resources API.   Developers need only add their own implementation of CredentialsVerifier  interface to validate the credentials of users or applications that require a token.     package main   import (  "errors"  "time"   "gopkg.in/gin-gonic/gin.v1"...








Continua a leggere










From the database schema to RESTful API with DinGo




















Immagine







 In the  previous post  I had started writing about data model and code generation and the post coincided with the boot of an open source project called DinGo  thought to generate the Go code for a Microservice host analysing the schema of a relational database.   It's a very SQL First  approach to write code, so I don't think it should be good for all the projects, but surely there are many applications that can take advantage from this, at least those are using already defined relational databases and want to adopt a Microservice architecture and RESTful API.     What DinGo does  DinGo creates a Microservice application starting from a MySQL database schema. Dingo follows these steps during the generation process:   DinGo reads the information_schema  of the MySQL database  it generates a set of Data Model structs used to map tables into Go structs   it generates the Data Access Objects , these objects provide a set of basic operations (CRUD operatio...








Continua a leggere










OVO Key/Value Storage





















  Yet another Key/Value Storage ?  I started developing OVO , my own implementation of a Key/Value Storage, six month ago because I wanted to test  developing a project  using  the  Go language. In the past , I had already  worked  on a similar project , GetCache , but  it is developed  with  .Net framework .  I don't think  that  the world  lacks  the  Key / Value  Storage , but  for me  it  is treated  to  a great gym  to  train my  Go . I have r ealized that this project with the Go language is extraordinarily simple and so I would like to share this experience.     What is OVO  Initially, the project  aimed to  create  a distributed cache , like  Memcached , that would allow to store  objects  and   JSON   structures  quickly  by spreading the load  across multiple servers , and could  run on any  kind of  Linux , Windows , iOS machine . Each  cached object  can have  a time-to-live property ( TTL)  set  so  that  the removal  is done  automaticall...








Continua a leggere