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 _, msgList := range api.GetRegisteredMessages() {
  39                 for _, msg := range msgList {
  40                         gob.Register(msg)
  41                 }
  42         }
  43 }
  44
  45 func main() {
  46         flag.Parse()
  47
  48         switch cmd := flag.Arg(0); cmd {
  49         case "server":
  50                 runServer()
  51         case "client":
  52                 runClient()
  53         default:
  54                 log.Printf("invalid command: %q, (available commands: client, server)", cmd)
  55         }
  56 }
  57
  58 func runClient() {
  59         // connect to proxy server
  60         client, err := proxy.Connect(*proxyAddr)
  61         if err != nil {
  62                 log.Fatalln("connecting to proxy failed:", err)
  63         }
  64
  65         // proxy stats
  66         statsProvider, err := client.NewStatsClient()
  67         if err != nil {
  68                 log.Fatalln(err)
  69         }
  70
  71         var sysStats api.SystemStats
  72         if err := statsProvider.GetSystemStats(&sysStats); err != nil {
  73                 log.Fatalln("getting stats failed:", err)
  74         }
  75         log.Printf("SystemStats: %+v", sysStats)
  76
  77         var ifaceStats api.InterfaceStats
  78         if err := statsProvider.GetInterfaceStats(&ifaceStats); err != nil {
  79                 log.Fatalln("getting stats failed:", err)
  80         }
  81         log.Printf("InterfaceStats: %+v", ifaceStats)
  82
  83         // proxy binapi
  84         binapiChannel, err := client.NewBinapiClient()
  85         if err != nil {
  86                 log.Fatalln(err)
  87         }
  88         log.Println("checking compatibility")
  89         var msgs []api.Message
  90         msgs = append(msgs, interfaces.AllMessages()...)
  91         msgs = append(msgs, vpe.AllMessages()...)
  92         if err := binapiChannel.CheckCompatiblity(msgs...); err != nil {
  93                 panic(err)
  94         }
  95
  96         req := &vpe.CliInband{Cmd: "show version"}
  97         reply := new(vpe.CliInbandReply)
  98         if err := binapiChannel.SendRequest(req).ReceiveReply(reply); err != nil {
  99                 log.Fatalln("binapi request failed:", err)
 100         }
 101         log.Printf("VPP version: %+v", reply.Reply)
 102 }
 103
 104 func runServer() {
 105         p, err := proxy.NewServer()
 106         if err != nil {
 107                 log.Fatalln(err)
 108         }
 109
 110         statsAdapter := statsclient.NewStatsClient(*statsSocket)
 111         binapiAdapter := socketclient.NewVppClient(*binapiSocket)
 112
 113         if err := p.ConnectStats(statsAdapter); err != nil {
 114                 log.Fatalln("connecting to stats failed:", err)
 115         }
 116         defer p.DisconnectStats()
 117
 118         if err := p.ConnectBinapi(binapiAdapter); err != nil {
 119                 log.Fatalln("connecting to binapi failed:", err)
 120         }
 121         defer p.DisconnectBinapi()
 122
 123         if err := p.ListenAndServe(*proxyAddr); err != nil {
 124                 log.Fatalln(err)
 125         }
 126 }