cmd/vpp-proxy/main.go

   1 //  Copyright (c) 2019 Cisco and/or its affiliates.
   2 //
   3 //  Licensed under the Apache License, Version 2.0 (the "License");
   4 //  you may not use this file except in compliance with the License.
   5 //  You may obtain a copy of the License at:
   6 //
   7 //      http://www.apache.org/licenses/LICENSE-2.0
   8 //
   9 //  Unless required by applicable law or agreed to in writing, software
  10 //  distributed under the License is distributed on an "AS IS" BASIS,
  11 //  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 //  See the License for the specific language governing permissions and
  13 //  limitations under the License.
  14
  15 package main
  16
  17 import (
  18         "encoding/gob"
  19         "flag"
  20         "log"
  21
  22         "git.fd.io/govpp.git/adapter/socketclient"
  23         "git.fd.io/govpp.git/adapter/statsclient"
  24         "git.fd.io/govpp.git/api"
  25         interfaces "git.fd.io/govpp.git/binapi/interface"
  26         "git.fd.io/govpp.git/binapi/vpe"
  27         _ "git.fd.io/govpp.git/core"
  28         "git.fd.io/govpp.git/proxy"
  29 )
  30
  31 var (
  32         binapiSocket = flag.String("binapi-socket", socketclient.DefaultSocketName, "Path to VPP binapi socket")
  33         statsSocket  = flag.String("stats-socket", statsclient.DefaultSocketName, "Path to VPP stats socket")
  34         proxyAddr    = flag.String("addr", ":7878", "Address on which proxy serves RPC.")
  35 )
  36
  37 func init() {
  38         for _, msg := range api.GetRegisteredMessages() {
  39                 gob.Register(msg)
  40         }
  41 }
  42
  43 func main() {
  44         flag.Parse()
  45
  46         switch cmd := flag.Arg(0); cmd {
  47         case "server":
  48                 runServer()
  49         case "client":
  50                 runClient()
  51         default:
  52                 log.Printf("invalid command: %q, (available commands: client, server)", cmd)
  53         }
  54 }
  55
  56 func runClient() {
  57         // connect to proxy server
  58         client, err := proxy.Connect(*proxyAddr)
  59         if err != nil {
  60                 log.Fatalln("connecting to proxy failed:", err)
  61         }
  62
  63         // proxy stats
  64         statsProvider, err := client.NewStatsClient()
  65         if err != nil {
  66                 log.Fatalln(err)
  67         }
  68
  69         var sysStats api.SystemStats
  70         if err := statsProvider.GetSystemStats(&sysStats); err != nil {
  71                 log.Fatalln("getting stats failed:", err)
  72         }
  73         log.Printf("SystemStats: %+v", sysStats)
  74
  75         var ifaceStats api.InterfaceStats
  76         if err := statsProvider.GetInterfaceStats(&ifaceStats); err != nil {
  77                 log.Fatalln("getting stats failed:", err)
  78         }
  79         log.Printf("InterfaceStats: %+v", ifaceStats)
  80
  81         // proxy binapi
  82         binapiChannel, err := client.NewBinapiClient()
  83         if err != nil {
  84                 log.Fatalln(err)
  85         }
  86         log.Println("checking compatibility")
  87         var msgs []api.Message
  88         msgs = append(msgs, interfaces.AllMessages()...)
  89         msgs = append(msgs, vpe.AllMessages()...)
  90         if err := binapiChannel.CheckCompatiblity(msgs...); err != nil {
  91                 panic(err)
  92         }
  93
  94         req := &vpe.CliInband{Cmd: "show version"}
  95         reply := new(vpe.CliInbandReply)
  96         if err := binapiChannel.SendRequest(req).ReceiveReply(reply); err != nil {
  97                 log.Fatalln("binapi request failed:", err)
  98         }
  99         log.Printf("VPP version: %+v", reply.Reply)
 100 }
 101
 102 func runServer() {
 103         p, err := proxy.NewServer()
 104         if err != nil {
 105                 log.Fatalln(err)
 106         }
 107
 108         statsAdapter := statsclient.NewStatsClient(*statsSocket)
 109         binapiAdapter := socketclient.NewVppClient(*binapiSocket)
 110
 111         if err := p.ConnectStats(statsAdapter); err != nil {
 112                 log.Fatalln("connecting to stats failed:", err)
 113         }
 114         defer p.DisconnectStats()
 115
 116         if err := p.ConnectBinapi(binapiAdapter); err != nil {
 117                 log.Fatalln("connecting to binapi failed:", err)
 118         }
 119         defer p.DisconnectBinapi()
 120
 121         if err := p.ListenAndServe(*proxyAddr); err != nil {
 122                 log.Fatalln(err)
 123         }
 124 }