func applyVerifyRangeTag(t *testing.T, cfgBytes []byte, shouldFail bool) {
initFakeStateDriver(t)
defer deinitFakeStateDriver()
cfg := &intent.Config{}
err := json.Unmarshal(cfgBytes, cfg)
if err != nil {
t.Fatalf("error '%s' parsing config '%s'\n", err, cfgBytes)
}
_, err = resources.NewStateResourceManager(fakeDriver)
if err != nil {
log.Fatalf("state store initialization failed. Error: %s", err)
}
defer func() { resources.ReleaseStateResourceManager() }()
// setup global state
gCfg := &gstate.Cfg{}
gCfg.StateDriver = fakeDriver
gCfg.Auto.VLANs = "11-1000"
gCfg.Auto.VXLANs = "1001-2000"
// setup resources
err = gCfg.Process()
if err != nil {
t.Fatalf("Error updating the config %+v. Error: %s", gCfg, err)
}
err = gCfg.Write()
if err != nil {
t.Fatalf("error updating global config.Error: %s", err)
}
tenant := cfg.Tenants[0]
err = CreateTenant(fakeDriver, &tenant)
if err != nil {
t.Fatalf("error '%s' creating tenant\n", err)
}
err = CreateNetworks(fakeDriver, &tenant)
if shouldFail {
var expError string
network := tenant.Networks[0]
if network.PktTagType == "vlan" {
expError = "requested vlan not available"
} else {
expError = "requested vxlan not available"
}
if err == nil {
t.Fatalf("CreateNetworks did not return error\n")
} else if !strings.Contains(err.Error(), expError) {
t.Fatalf("CreateNetworks did not return error for OutOfRange\n")
}
} else if err != nil {
t.Fatalf("error '%s' while creating network\n", err)
}
}
// Init initializes the master daemon
func (d *MasterDaemon) Init() {
// set cluster mode
err := master.SetClusterMode(d.ClusterMode)
if err != nil {
log.Fatalf("Failed to set cluster-mode. Error: %s", err)
}
// save dns flag
err = master.SetDNSEnabled(d.DNSEnabled)
if err != nil {
log.Fatalf("Failed to set dns-enable. Error: %s", err)
}
// initialize state driver
d.stateDriver, err = initStateDriver(d.ClusterStore)
if err != nil {
log.Fatalf("Failed to init state-store. Error: %s", err)
}
// Initialize resource manager
d.resmgr, err = resources.NewStateResourceManager(d.stateDriver)
if err != nil {
log.Fatalf("Failed to init resource manager. Error: %s", err)
}
}
// Init initializes the master daemon
func (d *MasterDaemon) Init() {
// set cluster mode
err := master.SetClusterMode(d.ClusterMode)
if err != nil {
log.Fatalf("Failed to set cluster-mode. Error: %s", err)
}
// save dns flag
err = master.SetDNSEnabled(d.DNSEnabled)
if err != nil {
log.Fatalf("Failed to set dns-enable. Error: %s", err)
}
// initialize state driver
d.stateDriver, err = initStateDriver(d.ClusterStore)
if err != nil {
log.Fatalf("Failed to init state-store. Error: %s", err)
}
// Initialize resource manager
d.resmgr, err = resources.NewStateResourceManager(d.stateDriver)
if err != nil {
log.Fatalf("Failed to init resource manager. Error: %s", err)
}
// Create an objdb client
d.objdbClient, err = objdb.NewClient(d.ClusterStore)
if err != nil {
log.Fatalf("Error connecting to state store: %v. Err: %v", d.ClusterStore, err)
}
}
func TestGlobalConfigAutoVXLAN(t *testing.T) {
cfgData := []byte(`
{
"Tenant" : "default",
"Auto" : {
"SubnetPool" : "11.5.0.0",
"SubnetLen" : 16,
"AllocSubnetLen" : 24,
"VLANs" : "1-10",
"VXLANs" : "15000-17000"
},
"Deploy" : {
"DefaultNetType" : "vxlan"
}
}`)
var vxlan, localVLAN uint
gc, err := Parse(cfgData)
if err != nil {
t.Fatalf("error '%s' parsing config '%s' \n", err, cfgData)
}
gstateSD.Init(nil)
defer func() { gstateSD.Deinit() }()
gc.StateDriver = gstateSD
_, err = resources.NewStateResourceManager(gstateSD)
if err != nil {
t.Fatalf("Failed to instantiate resource manager. Error: %s", err)
}
defer func() { resources.ReleaseStateResourceManager() }()
err = gc.Process("vlan")
if err != nil {
t.Fatalf("error '%s' processing config %v \n", err, gc)
}
err = gc.Process("vxlan")
if err != nil {
t.Fatalf("error '%s' processing config %v \n", err, gc)
}
vxlan, localVLAN, err = gc.AllocVXLAN(uint(0))
if err != nil {
t.Fatalf("error - allocating vxlan - %s \n", err)
}
if vxlan == 0 {
t.Fatalf("error - invalid vxlan allocated %d \n", vxlan)
}
if localVLAN == 0 {
t.Fatalf("error - invalid vlan allocated %d \n", localVLAN)
}
err = gc.FreeVXLAN(vxlan, localVLAN)
if err != nil {
t.Fatalf("error freeing allocated vxlan %d localvlan %d - err '%s' \n",
vxlan, localVLAN, err)
}
}
func applyConfig(t *testing.T, cfgBytes []byte) {
cfg := &intent.Config{}
err := json.Unmarshal(cfgBytes, cfg)
if err != nil {
t.Fatalf("error '%s' parsing config '%s'\n", err, cfgBytes)
}
_, err = resources.NewStateResourceManager(fakeDriver)
if err != nil {
log.Fatalf("state store initialization failed. Error: %s", err)
}
defer func() { resources.ReleaseStateResourceManager() }()
// setup global state
gCfg := &gstate.Cfg{}
gCfg.StateDriver = fakeDriver
gCfg.Auto.VLANs = "1-4094"
gCfg.Auto.VXLANs = "1-10000"
// setup resources
err = gCfg.Process("vxlan")
if err != nil {
t.Fatalf("Error updating the config %+v. Error: %s", gCfg, err)
}
err = gCfg.Process("vlan")
if err != nil {
t.Fatalf("Error updating the config %+v. Error: %s", gCfg, err)
}
err = gCfg.Write()
if err != nil {
t.Fatalf("error updating global config.Error: %s", err)
}
for _, tenant := range cfg.Tenants {
err = CreateTenant(fakeDriver, &tenant)
if err != nil {
t.Fatalf("error '%s' creating tenant\n", err)
}
err = CreateNetworks(fakeDriver, &tenant)
if err != nil {
t.Fatalf("error '%s' creating networks\n", err)
}
err = CreateEndpoints(fakeDriver, &tenant)
if err != nil {
t.Fatalf("error '%s' creating endpoints\n", err)
}
}
fakeDriver.DumpState()
}
// setup the test netmaster REST server and client
func TestMain(m *testing.M) {
var err error
// Setup state store
stateStore, err = initStateDriver()
if err != nil {
log.Fatalf("Error initializing state store. Err: %v", err)
}
// little hack to clear all state from etcd
stateStore.(*state.EtcdStateDriver).Client.Delete("/contiv.io", true)
// Setup resource manager
if _, err = resources.NewStateResourceManager(stateStore); err != nil {
log.Fatalf("Failed to init resource manager. Error: %s", err)
}
router := mux.NewRouter()
// Create a new api controller
apiController = NewAPIController(router)
ofnetMaster := ofnet.NewOfnetMaster(ofnet.OFNET_MASTER_PORT)
if ofnetMaster == nil {
log.Fatalf("Error creating ofnet master")
}
// initialize policy manager
mastercfg.InitPolicyMgr(stateStore, ofnetMaster)
// Create HTTP server
go http.ListenAndServe(netmasterTestListenURL, router)
time.Sleep(time.Second)
// create a new contiv client
contivClient, err = client.NewContivClient(netmasterTestURL)
if err != nil {
log.Fatalf("Error creating contiv client. Err: %v", err)
}
// Create default tenant
createDefaultTenant()
exitCode := m.Run()
if exitCode == 0 {
cleanupState()
}
os.Exit(exitCode)
}
func execOpts(opts *cliOpts) core.StateDriver {
if opts.help {
fmt.Fprintf(os.Stderr, "Usage: %s [OPTION]...\n", os.Args[0])
flagSet.PrintDefaults()
os.Exit(0)
}
if opts.version {
fmt.Printf(version.String())
os.Exit(0)
}
log.SetFormatter(&log.TextFormatter{FullTimestamp: true, TimestampFormat: time.StampNano})
if opts.debug {
log.SetLevel(log.DebugLevel)
}
if err := master.SetClusterMode(opts.clusterMode); err != nil {
log.Fatalf("Failed to set cluster-mode. Error: %s", err)
}
if err := master.SetDNSEnabled(opts.dnsEnabled); err != nil {
log.Fatalf("Failed to set dns-enable. Error: %s", err)
}
sd, err := initStateDriver(opts)
if err != nil {
log.Fatalf("Failed to init state-store. Error: %s", err)
}
if _, err = resources.NewStateResourceManager(sd); err != nil {
log.Fatalf("Failed to init resource manager. Error: %s", err)
}
return sd
}
func (d *daemon) execOpts() {
if err := d.parseOpts(); err != nil {
log.Fatalf("Failed to parse cli options. Error: %s", err)
}
if d.opts.help {
fmt.Fprintf(os.Stderr, "Usage: %s [OPTION]...\n", os.Args[0])
flagSet.PrintDefaults()
os.Exit(0)
}
if d.opts.version {
fmt.Printf(version.String())
os.Exit(0)
}
log.SetFormatter(&log.TextFormatter{FullTimestamp: true, TimestampFormat: time.StampNano})
if d.opts.debug {
log.SetLevel(log.DebugLevel)
}
if err := master.SetClusterMode(d.opts.clusterMode); err != nil {
log.Fatalf("Failed to set cluster-mode. Error: %s", err)
}
sd, err := initStateDriver(&d.opts)
if err != nil {
log.Fatalf("Failed to init state-store. Error: %s", err)
}
if _, err = resources.NewStateResourceManager(sd); err != nil {
log.Fatalf("Failed to init resource manager. Error: %s", err)
}
d.stateDriver = sd
}
func main() {
var rsrcName string
var clusterStore string
var setVal string
var stateName string
var stateID string
var fieldName string
// parse all commandline args
flagSet := flag.NewFlagSet("cfgtool", flag.ExitOnError)
flagSet.Usage = func() {
fmt.Fprintf(os.Stderr, "Usage of %s:\n", os.Args[0])
flagSet.PrintDefaults()
fmt.Fprintf(os.Stderr, "\nExamples:\n")
fmt.Fprintf(os.Stderr, "%s -state <state-name> -id <state-id> -field <field-name> -set <new-value>\n", os.Args[0])
fmt.Fprintf(os.Stderr, " %s -state GlobConfig -id global -field FwdMode -set routing\n", os.Args[0])
fmt.Fprintf(os.Stderr, "%s -resource <vlan|vxlan> -set <new-range>\n", os.Args[0])
fmt.Fprintf(os.Stderr, " %s -resource vlan -set 1-10\n", os.Args[0])
}
flagSet.StringVar(&rsrcName,
"resource",
"",
"Resource to modify [vlan|vxlan]")
flagSet.StringVar(&setVal,
"set",
"",
"Resource value")
flagSet.StringVar(&clusterStore,
"cluster-store",
"etcd://127.0.0.1:2379",
"Etcd or Consul cluster store url.")
flagSet.StringVar(&stateName,
"state",
"",
"State to modify")
flagSet.StringVar(&stateID,
"id",
"",
"State ID to modify")
flagSet.StringVar(&fieldName,
"field",
"",
"State Field to modify")
if err := flagSet.Parse(os.Args[1:]); err != nil {
log.Errorf("Error parsing commandline args: %v", err)
return
}
// check if we have sufficient args
if (rsrcName == "" && stateName == "") ||
(stateName != "" && stateID == "") ||
(stateName != "" && stateID != "" && setVal != "" && fieldName == "") {
flagSet.Usage()
os.Exit(2)
}
// initialize state driver
stateDriver, err := initStateDriver(clusterStore)
if err != nil {
log.Fatalf("Failed to init state-store. Error: %s", err)
}
// Initialize resource manager
resmgr, err := resources.NewStateResourceManager(stateDriver)
if err != nil || resmgr == nil {
log.Fatalf("Failed to init resource manager. Error: %s", err)
}
// process `-resource` command
if rsrcName != "" {
err = processResource(stateDriver, rsrcName, setVal)
if err != nil {
log.Errorf("Error processing resource %s. Err: %v", rsrcName, err)
}
return
}
// handle `-state` command
if stateName != "" && stateID != "" {
err = processState(stateDriver, stateName, stateID, fieldName, setVal)
if err != nil {
log.Errorf("Error processing state %s{ id : %s }. Err: %v", stateName, stateID, err)
}
}
}
// TestNetworkDeleteWithEPs
// This test creates a network and adds endpoints to it.
// It then tries to delete the network, while it has
// active endpoints and expects them to fail
func TestNetworkDeleteWithEPs(t *testing.T) {
cfgBytes := []byte(`{
"Tenants" : [{
"Name" : "tenant-one",
"Networks" : [{
"Name" : "orange",
"SubnetCIDR" : "10.1.1.1/24",
"Gateway" : "10.1.1.254",
"Endpoints" : [
{
"Container" : "myContainer1"
},
{
"Container" : "myContainer3"
}
]
}]
}]}`)
initFakeStateDriver(t)
defer deinitFakeStateDriver()
applyConfig(t, cfgBytes)
epBindings := []intent.ConfigEP{{
Container: "myContainer1",
Host: "host1",
}, {
Container: "myContainer2",
Host: "host1",
}, {
Container: "myContainer3",
Host: "host2",
}, {
Container: "myContainer4",
Host: "host2",
}}
err := CreateEpBindings(&epBindings)
if err != nil {
t.Fatalf("error '%s' creating tenant\n", err)
}
cfg := &intent.Config{}
err = json.Unmarshal(cfgBytes, cfg)
if err != nil {
t.Fatalf("error '%s' parsing config '%s'\n", err, cfgBytes)
}
_, err = resources.NewStateResourceManager(fakeDriver)
if err != nil {
log.Fatalf("state store initialization failed. Error: %s", err)
}
defer func() { resources.ReleaseStateResourceManager() }()
for _, tenant := range cfg.Tenants {
err = DeleteNetworks(fakeDriver, &tenant)
if err == nil || (err != nil && !strings.Contains(err.Error(), "Error: Network has active endpoints")) {
t.Fatalf("Network delete did not Fail with Active EPs.")
}
}
}
