From: Michael Cambria Date: Mon, 22 Apr 2019 20:26:01 +0000 (-0400) Subject: convert client to cnitool server X-Git-Url: https://git.halfball.org/?a=commitdiff_plain;h=5205737caf9493998f4df4dea1864a1f2681ba47;p=demo-grpc.git convert client to cnitool server --- diff --git a/api/api.proto b/api/api.proto index cb50e81..651c86c 100644 --- a/api/api.proto +++ b/api/api.proto @@ -52,7 +52,7 @@ enum CmdType { // { "hostPort": 9090, "containerPort": 90, "protocol": "tcp" } // ] -message PortMapMsg { +message CNIcapArgs { message PORTMAPPINGS { double hostPort = 1; @@ -61,11 +61,13 @@ message PortMapMsg { } repeated PORTMAPPINGS portMappings = 1; -} + message FOOMAP { + string thing1 = 1; + string thing2 = 2; + } -message CNIcapArgs { - repeated PortMapMsg portMap = 1; + repeated FOOMAP fooMap = 2; } message ConfPath { diff --git a/client/main.go b/client/main.go index ab5360f..d104b44 100644 --- a/client/main.go +++ b/client/main.go @@ -4,14 +4,10 @@ package main import ( "log" "context" - "crypto/sha512" - "encoding/json" + //"encoding/json" "fmt" "os" "path/filepath" - "strings" - - "github.com/containernetworking/cni/libcni" "github.com/mccv1r0/demo-grpc/api" "google.golang.org/grpc" @@ -52,7 +48,7 @@ func (a *Authentication) RequireTransportSecurity() bool { return true } -func sendgRPCusingUnix() error { +func sendgRPCusingTcp() error { var conn *grpc.ClientConn // Create the client TLS credentials @@ -79,12 +75,10 @@ func sendgRPCusingUnix() error { // CNI Test cni := api.NewCNIserverClient(conn) - /// cniPath := api.ConfPath { NetDir: "/home/mcambria/go/src/github.com/containernetworking", NetConf: "firewall-mcc1-range-chain", } - // cniMsg := api.CNImsg{ //ConfigPath: { @@ -105,12 +99,13 @@ func sendgRPCusingUnix() error { log.Fatalf("error when calling CNIop: %s", err) return err } - log.Printf("Response from unix socket server: %s", result.StdOut) + + log.Printf("Response from TCP server: %s", result.StdOut) return nil } -func sendgRPCusingTcp() error { +func sendgRPCusingUnix() error { var conn *grpc.ClientConn @@ -138,12 +133,10 @@ func sendgRPCusingTcp() error { // CNI Test cni := api.NewCNIserverClient(conn) - /// cniPath := api.ConfPath { NetDir: "/home/mcambria/go/src/github.com/containernetworking", NetConf: "firewall-mcc1-range-chain", } - // cniMsg := api.CNImsg{ //ConfigPath: { @@ -180,121 +173,324 @@ func sendgRPCusingTcp() error { log.Fatalf("error when calling CNIadd: %s", err) return err } - log.Printf("Response from TCP server: %s", resultAdd.StdOut) + log.Printf("Response from Unix Socket server: %s", resultAdd.StdOut) + + return nil +} + +func main() { + if len(os.Args) < 4 { + usage() + return + } + if os.Args[2] == "" { + fmt.Fprintf(os.Stderr, " network config name must be supplied as 2ed argument\n") + os.Exit(1) + } + + /* + var capabilityArgs map[string]interface{} + capabilityArgsValue := os.Getenv(EnvCapabilityArgs) + if len(capabilityArgsValue) > 0 { + if err := json.Unmarshal([]byte(capabilityArgsValue), &capabilityArgs); err != nil { + exit(err) + } + } + */ + + /* + capArgs, okCapArgs := os.LookupEnv(EnvCapabilityArgs) + if !okCapArgs { + capArgs = "" + } + */ + + args, okArgs := os.LookupEnv(EnvCNIArgs) + if !okArgs { + args = "" + } + + ifName, okIfName := os.LookupEnv(EnvCNIIfname) + if !okIfName { + ifName = "eth0" + } + + netns := os.Args[3] + if netns == "" { + fmt.Fprintf(os.Stderr, " network namespace path must be supplied as 3rd argument\n") + os.Exit(1) + } + + switch os.Args[1] { + case CmdAdd: + gRPCsendAddTcp(os.Args[2], netns, ifName, args) + os.Exit(0) + case CmdCheck: + gRPCsendCheckTcp(os.Args[2], netns, ifName, args) + os.Exit(0) + case CmdDel: + gRPCsendDelTcp(os.Args[2], netns, ifName, args) + os.Exit(0) + } +} + +func gRPCsendAddTcp(conf string, netns string, ifName string, args string) error { + var conn *grpc.ClientConn + + // Create the client TLS credentials + creds, err := credentials.NewClientTLSFromFile("cert/server.crt", "") + if err != nil { + log.Fatalf("could not load tls cert: %s", err) + return err + } + + // Setup the login/pass + auth := Authentication{ + Login: "john", + Password: "doe", + } + + // Initiate a connection with the server + conn, err = grpc.Dial("localhost:7777", grpc.WithTransportCredentials(creds), grpc.WithPerRPCCredentials(&auth)) + if err != nil { + log.Fatalf("did not connect: %s", err) + return err + } + defer conn.Close() + + cni := api.NewCNIserverClient(conn) + + cniAddMsg := api.CNIaddMsg{ + Conf: os.Args[2], + NetNS: netns, + IfName: ifName, + CniArgs: args, + //CapArgs: capArgs, + } + resultAdd, err := cni.CNIadd(context.Background(), &cniAddMsg) + if err != nil { + log.Fatalf("error when calling CNIadd: %s", err) + return err + } + log.Printf("Response from TCP server: %s", resultAdd.StdOut) return nil } -func oldmain() { - err := sendgRPCusingTcp() - if err != nil { - log.Fatalf("error when calling sendRPCusingTcp: %s", err) - } +func gRPCsendCheckTcp(conf string, netns string, ifName string, args string) error { + var conn *grpc.ClientConn + + // Create the client TLS credentials + creds, err := credentials.NewClientTLSFromFile("cert/server.crt", "") + if err != nil { + log.Fatalf("could not load tls cert: %s", err) + return err + } + + // Setup the login/pass + auth := Authentication{ + Login: "john", + Password: "doe", + } + + // Initiate a connection with the server + conn, err = grpc.Dial("localhost:7777", grpc.WithTransportCredentials(creds), grpc.WithPerRPCCredentials(&auth)) + if err != nil { + log.Fatalf("did not connect: %s", err) + return err + } + defer conn.Close() + + cni := api.NewCNIserverClient(conn) - err2 := sendgRPCusingUnix() - if err2 != nil { - log.Fatalf("error when calling sendRPCusingUnix: %s", err2) - } + cniCheckMsg := api.CNIcheckMsg{ + Conf: os.Args[2], + NetNS: netns, + IfName: ifName, + CniArgs: args, + //CapArgs: capArgs, + } + resultCheck, err := cni.CNIcheck(context.Background(), &cniCheckMsg) + if err != nil { + log.Fatalf("error when calling CNIcheck: %s", err) + return err + } + log.Printf("Response from TCP server: %s", resultCheck.Error) + + return nil } -func parseArgs(args string) ([][2]string, error) { - var result [][2]string +func gRPCsendDelTcp(conf string, netns string, ifName string, args string) error { + var conn *grpc.ClientConn - pairs := strings.Split(args, ";") - for _, pair := range pairs { - kv := strings.Split(pair, "=") - if len(kv) != 2 || kv[0] == "" || kv[1] == "" { - return nil, fmt.Errorf("invalid CNI_ARGS pair %q", pair) - } + // Create the client TLS credentials + creds, err := credentials.NewClientTLSFromFile("cert/server.crt", "") + if err != nil { + log.Fatalf("could not load tls cert: %s", err) + return err + } - result = append(result, [2]string{kv[0], kv[1]}) + // Setup the login/pass + auth := Authentication{ + Login: "john", + Password: "doe", } - return result, nil + // Initiate a connection with the server + conn, err = grpc.Dial("localhost:7777", grpc.WithTransportCredentials(creds), grpc.WithPerRPCCredentials(&auth)) + if err != nil { + log.Fatalf("did not connect: %s", err) + return err + } + defer conn.Close() + + cni := api.NewCNIserverClient(conn) + + cniDelMsg := api.CNIdelMsg{ + Conf: os.Args[2], + NetNS: netns, + IfName: ifName, + CniArgs: args, + //CapArgs: capArgs, + } + resultDel, err := cni.CNIdel(context.Background(), &cniDelMsg) + if err != nil { + log.Fatalf("error when calling CNIdel: %s", err) + return err + } + log.Printf("Response from TCP server: %s", resultDel.Error) + + return nil } -func main() { - if len(os.Args) < 4 { - usage() - return +func gRPCsendAddUnix(conf string, netns string, ifName string, args string) error { + + var conn *grpc.ClientConn + + // Create the unix socket client TLS credentials + creds, err := credentials.NewClientTLSFromFile("cert/unixServer.crt", "") + if err != nil { + log.Fatalf("could not load tls cert: %s", err) + return err } - netdir := os.Getenv(EnvNetDir) - if netdir == "" { - netdir = DefaultNetDir + // Setup the login/pass + auth := Authentication{ + Login: "john", + Password: "doe", } - netconf, err := libcni.LoadConfList(netdir, os.Args[2]) + + // Initiate a connection with the server + conn, err = grpc.Dial("unix:///tmp/grpc.sock", grpc.WithTransportCredentials(creds), grpc.WithPerRPCCredentials(&auth)) if err != nil { - exit(err) + log.Fatalf("did not connect: %s", err) + return err } + defer conn.Close() - var capabilityArgs map[string]interface{} - capabilityArgsValue := os.Getenv(EnvCapabilityArgs) - if len(capabilityArgsValue) > 0 { - if err = json.Unmarshal([]byte(capabilityArgsValue), &capabilityArgs); err != nil { - exit(err) - } + cni := api.NewCNIserverClient(conn) + + cniAddMsg := api.CNIaddMsg{ + Conf: os.Args[2], + NetNS: netns, + IfName: ifName, + CniArgs: args, + } + resultAdd, err := cni.CNIadd(context.Background(), &cniAddMsg) + if err != nil { + log.Fatalf("error when calling CNIadd: %s", err) + return err } + log.Printf("Response from Unix server: %s", resultAdd.StdOut) - var cniArgs [][2]string - args := os.Getenv(EnvCNIArgs) - if len(args) > 0 { - cniArgs, err = parseArgs(args) - if err != nil { - exit(err) - } + return nil +} + +func gRPCsendCheckUnix(conf string, netns string, ifName string, args string) error { + + var conn *grpc.ClientConn + + // Create the unix socket client TLS credentials + creds, err := credentials.NewClientTLSFromFile("cert/unixServer.crt", "") + if err != nil { + log.Fatalf("could not load tls cert: %s", err) + return err } - ifName, ok := os.LookupEnv(EnvCNIIfname) - if !ok { - ifName = "eth0" + // Setup the login/pass + auth := Authentication{ + Login: "john", + Password: "doe", } - netns := os.Args[3] - netns, err = filepath.Abs(netns) + // Initiate a connection with the server + conn, err = grpc.Dial("unix:///tmp/grpc.sock", grpc.WithTransportCredentials(creds), grpc.WithPerRPCCredentials(&auth)) if err != nil { - exit(err) + log.Fatalf("did not connect: %s", err) + return err + } + defer conn.Close() + + cni := api.NewCNIserverClient(conn) + + cniCheckMsg := api.CNIcheckMsg{ + Conf: os.Args[2], + NetNS: netns, + IfName: ifName, + CniArgs: args, + } + resultCheck, err := cni.CNIcheck(context.Background(), &cniCheckMsg) + if err != nil { + log.Fatalf("error when calling CNIcheck: %s", err) + return err } + log.Printf("Response from Unix server: %s", resultCheck.Error) + + return nil +} + +func gRPCsendDelUnix(conf string, netns string, ifName string, args string) error { - // Generate the containerid by hashing the netns path - s := sha512.Sum512([]byte(netns)) - containerID := fmt.Sprintf("cnitool-%x", s[:10]) + var conn *grpc.ClientConn - cninet := libcni.NewCNIConfig(filepath.SplitList(os.Getenv(EnvCNIPath)), nil) + // Create the unix socket client TLS credentials + creds, err := credentials.NewClientTLSFromFile("cert/unixServer.crt", "") + if err != nil { + log.Fatalf("could not load tls cert: %s", err) + return err + } - rt := &libcni.RuntimeConf{ - ContainerID: containerID, - NetNS: netns, - IfName: ifName, - Args: cniArgs, - CapabilityArgs: capabilityArgs, + // Setup the login/pass + auth := Authentication{ + Login: "john", + Password: "doe", } -var f *os.File -var sout string -f, _ = os.OpenFile("/tmp/check.log", os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644) + // Initiate a connection with the server + conn, err = grpc.Dial("unix:///tmp/grpc.sock", grpc.WithTransportCredentials(creds), grpc.WithPerRPCCredentials(&auth)) + if err != nil { + log.Fatalf("did not connect: %s", err) + return err + } + defer conn.Close() -sout = fmt.Sprintf("mcc: cninet: %v of type %T \n", cninet, cninet) -_, _ = f.Write([]byte(sout)) -sout = fmt.Sprintf("mcc: netconf: %v of type %T \n", netconf, netconf) -_, _ = f.Write([]byte(sout)) -sout = fmt.Sprintf("mcc: rt: %v of type %T \n", rt, rt) -_, _ = f.Write([]byte(sout)) + cni := api.NewCNIserverClient(conn) - switch os.Args[1] { - case CmdAdd: - result, err := cninet.AddNetworkList(context.TODO(), netconf, rt) - if result != nil { - _ = result.Print() - } - exit(err) - case CmdCheck: - err := cninet.CheckNetworkList(context.TODO(), netconf, rt) - exit(err) - case CmdDel: - exit(cninet.DelNetworkList(context.TODO(), netconf, rt)) + cniDelMsg := api.CNIdelMsg{ + Conf: os.Args[2], + NetNS: netns, + IfName: ifName, + CniArgs: args, + } + resultDel, err := cni.CNIdel(context.Background(), &cniDelMsg) + if err != nil { + log.Fatalf("error when calling CNIdel: %s", err) + return err } + log.Printf("Response from Unix server: %s", resultDel.Error) + + return nil } func usage() {