Check for nil fields; seperate client into 2 functions

diff --git a/api/handler.go b/api/handler.go
index 7a838e2..a605abf 100644 (file)
--- a/api/handler.go
+++ b/api/handler.go
@@ -15,8 +15,14 @@ func (s *CNIServer) CNIop(ctx context.Context, in *CNImsg) (*CNIresult, error) {
 
        confPath := in.ConfigPath
 
-       log.Printf("Receive message NetDir: %s", confPath.NetDir)
-       log.Printf("Receive message NetConf: %s", confPath.NetConf)
+       if confPath != nil {
+          if confPath.NetDir != "" {
+             log.Printf("Receive message NetDir: %s", confPath.NetDir)
+          }
+       if confPath.NetConf != "" {
+          log.Printf("Receive message NetConf: %s", confPath.NetConf)
+          }
+       }
 
        log.Printf("Receive message ContainerID: %s", in.ContainerID)
        log.Printf("Receive message NetNS: %s", in.NetNS)

diff --git a/client/main.go b/client/main.go
index 9097f31..b991231 100644 (file)
--- a/client/main.go
+++ b/client/main.go
@@ -28,13 +28,14 @@ func (a *Authentication) RequireTransportSecurity() bool {
        return true
 }
 
-func main() {
+func sendgRPCusingUnix() 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
@@ -47,6 +48,7 @@ func main() {
        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()
 
@@ -77,46 +79,54 @@ func main() {
        result, err := cni.CNIop(context.Background(), &cniMsg)
        if err != nil {
                log.Fatalf("error when calling CNIop: %s", err)
+               return err
        }
-       log.Printf("Response from server: %s", result.StdOut)
+       log.Printf("Response from unix socket server: %s", result.StdOut)
+
+       return nil
+}
+
+func sendgRPCusingTcp() error {
+
+       var conn *grpc.ClientConn
 
        // Create the unix socket client TLS credentials
-       creds2, err := credentials.NewClientTLSFromFile("cert/unixServer.crt", "")
+       creds, err := credentials.NewClientTLSFromFile("cert/unixServer.crt", "")
        if err != nil {
                log.Fatalf("could not load tls cert: %s", err)
+               return err
        }
 
        // Setup the login/pass
-       auth2 := Authentication{
+       auth := Authentication{
                Login:    "john",
                Password: "doe",
        }
 
-       var conn2 *grpc.ClientConn
-
        // Initiate a connection with the server
-       conn2, err = grpc.Dial("unix:///tmp/grpc.sock", grpc.WithTransportCredentials(creds2), grpc.WithPerRPCCredentials(&auth2))
+       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 conn2.Close()
+       defer conn.Close()
 
        // CNI Test 
-       cni2 := api.NewCNIserverClient(conn2)
+       cni := api.NewCNIserverClient(conn)
 
        ///
-       cniPath2 := api.ConfPath {
+       cniPath := api.ConfPath {
                 NetDir: "/home/mcambria/go/src/github.com/containernetworking",
                 NetConf: "firewall-mcc1-range-chain",
               }
        //
 
-       cniMsg2 := api.CNImsg{
+       cniMsg := api.CNImsg{
               //ConfigPath: {
               //NetDir: "/home/mcambria/go/src/github.com/containernetworking",
               //NetConf: "firewall-mcc1-range-chain",
               //},
-              ConfigPath: &cniPath2,
+              ConfigPath: &cniPath,
               Cmd: api.CmdType_ADD,
               ContainerID: "containerOne",
               NetNS: "mcc-test-0",
@@ -125,9 +135,24 @@ func main() {
               CniArgs: "IgnoreUnknown=1;IP=10.1.0.20",
 
        }
-       result2, err := cni2.CNIop(context.Background(), &cniMsg2)
+       result, err := cni.CNIop(context.Background(), &cniMsg)
        if err != nil {
                log.Fatalf("error when calling CNIop: %s", err)
+               return err
        }
-       log.Printf("Response from server: %s", result2.StdOut)
+       log.Printf("Response from TCP server: %s", result.StdOut)
+
+       return nil
+}
+
+func main() {
+     err := sendgRPCusingTcp()
+     if err != nil {
+               log.Fatalf("error when calling sendRPCusingTcp: %s", err)
+     }
+
+     err2 := sendgRPCusingUnix()
+     if err2 != nil {
+               log.Fatalf("error when calling sendRPCusingUnix: %s", err2)
+     }
 }