main_test.go

package main

// go generate protoc --proto_path=kmsintercomproto --go_out=kmsintercomproto --go_opt=paths=source_relative --go-grpc_out=kmsintercomproto --go-grpc_opt=paths=source_relative  kmsintercom.proto
// go generate protoc --proto_path=kmsetsiproto  --go_out=kmsetsiproto --go_opt=paths=source_relative --go-grpc_out=kmsetsiproto --go-grpc_opt=paths=source_relative  kmsetsiproto.proto

import (
	"flag"
	"net"
	"os"
	"testing"
	"time"

	log "github.com/sirupsen/logrus"

	"code.fbi.h-da.de/danet/proto-kms/kms"
	"github.com/google/uuid"
)

func TestMain(m *testing.M) {
	// run a self-test if set to yes
	var selfTesting bool
	// my own Name
	var udpQL1AddrString string
	var ql1Name string
	// a name for potential self-testing
	var udpQL2AddrString string
	var ql2Name string
	// Setup flags that allows to initially provide a address to a second
	// quantumlayer so generated keys can be fetched. This is mainly to simplify
	// the initial setup process.

	flag.BoolVar(&selfTesting, "selftesting", true,
		"Will perform self-testing with second quantum link if set to true")

	flag.StringVar(&udpQL1AddrString, "my-address", "[::1]:50900",
		"The UDP address for my quantumlayer so keys can be fetched")

	flag.StringVar(&ql1Name, "my-name", "ekms-ql1",
		"The name of the quantumlayer")

	flag.StringVar(&udpQL2AddrString, "remote-address", "[::1]:50901",
		"The UDP address to a second quantumlayer so keys can be fetched")

	flag.StringVar(&ql2Name, "remote-name", "ekms-ql2",
		"The name of the quantumlayer")

	// Parse the provided flags
	flag.Parse()

	log.Println("Welcome to the proto-kms called: ", ql1Name)

	if selfTesting == true {
		log.Infof("%s in self-testing mode", ql1Name)
		go emulatedKMS("leftKMS", "[::1]:50900", "[::1]:50930", "[::1]:50910", "[::1]:50932")
		go emulatedKMS("rightKMS", "[::1]:50901", "[::1]:50931", "[::1]:50911", "[::1]:50932")
		middleKMS("middleKMS", "[::1]:50902", "[::1]:50932", "[::1]:50900", "[::1]:50930", "[::1]:50901", "[::1]:50931")
	} else {
		//	log.Infof("%s in regular mode of operation", ql1Name)
		//	emulatedKMS(ql1Name, udpQL1AddrString, udpQL2AddrString)
	}
}

func emulatedKMS(myName, myUDPAddr, myInterComAddr, peerUDPAddr, peerInterComAddr string) {
	// Attach to eKMS
	emuKMS := kms.NewEKMS(myName, uuid.New(), os.Stdout, log.TraceLevel, false, myInterComAddr)

	eqm := kms.NewEmulatedQuantumModule(myUDPAddr, false, os.Stdout, log.TraceLevel, false)

	// Fire up Quantum LinK
	err := emuKMS.AddQuantumElement(eqm)
	if err != nil {
		log.Println("failed to create emulated quantum module")
		return
	}

	udpQL2Addr, err := net.ResolveUDPAddr("udp", peerUDPAddr)
	if err != nil {
		log.Fatalf("%s: QuantumlayerEmuPRNG UDP failure: %s", myName, err)
		return
	}

	eqm.QuantumElementLink.AddPeer(udpQL2Addr)

	_, err = emuKMS.AddPeer(myName, peerInterComAddr, eqm)
	if err != nil {
		log.Println("PEERERROR: ", err)
	}

	// Start the SDN/management and key retrieval interface
	go kms.StartETSI(myUDPAddr, emuKMS)

	// // TODO/XXX catch errors!
	// emuKMS.GlobalKeyHandler(7 * time.Second)
}

func middleKMS(myName, myUDPAddr, myInterComAddr, leftUDPAddr, leftInterComAddr, rightUDPAddr, rightInterComAddr string) {
	// Attach to eKMS
	emuKMS := kms.NewEKMS(myName, uuid.New(), os.Stdout, log.TraceLevel, false, myInterComAddr)

	// create two quantum modules that generate keys
	qlForLeft := kms.NewEmulatedQuantumModule("[::1]:50910", true, os.Stdout, log.TraceLevel, false)
	qlForRight := kms.NewEmulatedQuantumModule("[::1]:50911", true, os.Stdout, log.TraceLevel, false)

	netLeftUDPAddr, err := net.ResolveUDPAddr("udp", leftUDPAddr)
	if err != nil {
		log.Fatalf("%s: QuantumlayerEmuPRNG UDP failure: %s", myName, err)
		return
	}

	netRightUDPAddr, err := net.ResolveUDPAddr("udp", rightUDPAddr)
	if err != nil {
		log.Fatalf("%s: QuantumlayerEmuPRNG UDP failure: %s", myName, err)
		return
	}

	// Fire up Quantum LinK
	err = emuKMS.AddQuantumElement(qlForLeft)
	if err != nil {
		log.Println("failed to create emulated quantum module")
		return
	}

	err = emuKMS.AddQuantumElement(qlForRight)
	if err != nil {
		log.Println("failed to create emulated quantum module")
		return
	}

	qlForLeft.QuantumElementLink.AddPeer(netLeftUDPAddr)
	qlForRight.QuantumElementLink.AddPeer(netRightUDPAddr)

	peerLeft, err := emuKMS.AddPeer("leftKMS", leftInterComAddr, qlForLeft)
	if err != nil {
		log.Println(err)
	}

	peerRight, err := emuKMS.AddPeer("rightKMS", rightInterComAddr, qlForRight)
	if err != nil {
		log.Println(err)
	}

	// Start the SDN/management and key retrieval interface
	go kms.StartETSI(myUDPAddr, emuKMS)

	time.Sleep(time.Second * 15)
	if err := peerLeft.SyncBulkKeys(); err != nil {
		log.Println("SYNC ERROR: ", err)
	}
	if err := peerRight.SyncBulkKeys(); err != nil {
		log.Println("SYNC ERROR: ", err)
	}

	for {
	}
}