package main

import "errors"

type Args struct {
    A, B int
}

type Quotient struct {
    Quo, Rem int
}

type Arith int

func (t *Arith) Multiply(args *Args, reply *int) error {
    *reply = args.A * args.B

    return nil
}

func (t *Arith) Divide(args *Args, quo *Quotient) error {
    if args.B == 0 {
        return errors.New("divide by zero")
    }
    quo.Quo = args.A / args.B
    quo.Rem = args.A % args.B

    return nil
}

package main

import (
    "log"
    "net"
    "net/rpc"
    "errors"
)

func main() {
    service := new(Arith)

    server := rpc.NewServer()
    server.Register(service)

    listener, err := net.Listen("tcp", ":1234")
    if err != nil {
        log.Fatal("listen error:", err)
    }

    log.Println("Starting TCP RPC server on :1234")
    server.Accept(listener)
}

type Args struct {
    A, B int
}

type Quotient struct {
    Quo, Rem int
}

type Arith int

func (t *Arith) Multiply(args *Args, reply *int) error {
    *reply = args.A * args.B

    return nil
}

func (t *Arith) Divide(args *Args, quo *Quotient) error {
    if args.B == 0 {
        return errors.New("divide by zero")
    }
    quo.Quo = args.A / args.B
    quo.Rem = args.A % args.B

    return nil
}

package main

import (
    "log"
    "net/rpc"
)

func main() {
    client, err := rpc.Dial("tcp", ":1234")
    if err != nil {
        log.Fatal("dialing:", err)
	}
    defer client.Close()

    syncCall(client)
    asyncCall(client)
}

func syncCall(client *rpc.Client) {
    args := &Args{
        A: 7,
        B: 8,
    }

    var reply int
    err := client.Call("Arith.Multiply", args, &reply)
    if err != nil {
	    log.Fatal("arith error:", err)
    }

    log.Printf("Arith: %d*%d=%d\n", args.A, args.B, reply)
}

func asyncCall(client *rpc.Client) {
    quotient := new(Quotient)
    args := &Args{
        A: 7,
        B: 8,
	}

    divCall := client.Go("Arith.Divide", args, quotient, nil)

    <-divCall.Done // will be equal to divCall

    if divCall.Error != nil {
	    log.Fatal("arith error:", divCall.Error)
    }
    log.Printf("Arith: %d/%d=%d remainder %d\n", args.A, args.B, quotient.Quo, quotient.Rem)
}

type Args struct {
    A, B int
}

type Quotient struct {
    Quo, Rem int
}

type Arith int

package main

import (
    "log"
    "net/http"
    "net/rpc"
    "sync"
    "errors"
)

func main() {
    service := new(Arith)

    server := rpc.NewServer()
    server.Register(service)

    server.HandleHTTP(rpc.DefaultRPCPath, rpc.DefaultDebugPath)

    var wg sync.WaitGroup

    wg.Go(func() {
	    log.Println("Starting HTTP RPC server on :1234")
        log.Fatal(http.ListenAndServe(":1234", server))
    })

    wg.Go(func() {
	    log.Println("Starting HTTP RPC debug server on :1235")
        http.ListenAndServe(":1235", nil)
    })

    wg.Wait()
}

type Args struct {
    A, B int
}

type Quotient struct {
    Quo, Rem int
}

type Arith int

func (t *Arith) Multiply(args *Args, reply *int) error {
    *reply = args.A * args.B

    return nil
}

func (t *Arith) Divide(args *Args, quo *Quotient) error {
    if args.B == 0 {
        return errors.New("divide by zero")
	}
    quo.Quo = args.A / args.B
    quo.Rem = args.A % args.B

    return nil
}

package main

import (
    "flag"
    "log"
    "net/rpc"
    "strconv"
)

func main() {
    var port int

    flag.IntVar(&port, "port", 1234, "port to connect to")
    flag.Parse()

    client, err := rpc.DialHTTP("tcp", ":"+strconv.Itoa(port))
    if err != nil {
        log.Fatal("dialing:", err)
    }
    defer client.Close()

    syncCall(client)
    asyncCall(client)
}

func syncCall(client *rpc.Client) {
    args := &Args{
        A: 7,
        B: 8,
    }

    var reply int
    err := client.Call("Arith.Multiply", args, &reply)
	if err != nil {
        log.Fatal("arith error:", err)
    }

    log.Printf("Arith: %d*%d=%d\n", args.A, args.B, reply)
}

func asyncCall(client *rpc.Client) {
    quotient := new(Quotient)
    args := &Args{
        A: 7,
        B: 8,
    }

    divCall := client.Go("Arith.Divide", args, quotient, nil)

    <-divCall.Done // will be equal to divCall

    if divCall.Error != nil {
        log.Fatal("arith error:", divCall.Error)
    }
    log.Printf("Arith: %d/%d=%d remainder %d\n", args.A, args.B, quotient.Quo, quotient.Rem)
}

type Args struct {
    A, B int
}

type Quotient struct {
    Quo, Rem int
}

type Arith int