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"
return true
}
-func sendgRPCusingUnix() error {
+func sendgRPCusingTcp() error {
var conn *grpc.ClientConn
// Create the client TLS credentials
// 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: {
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
// 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: {
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() {
git://git.halfball.org / demo-grpc.git / commitdiff