Beispiel #1
0
func DeleteFromPool(containers []string) error {
	pools := map[bool]map[string]*poolDefinition{}
	pools[true] = map[string]*poolDefinition{}
	pools[false] = map[string]*poolDefinition{}
	for _, cont := range containers {
		inst, err := GetInstance(cont)
		if err != nil {
			// instance doesn't exist
			continue
		}
		name := helper.CreatePoolName(inst.App, inst.Sha, inst.Env)
		zkApp, err := GetApp(inst.App)
		if err != nil {
			return err
		}
		poolDef := pools[zkApp.Internal][name]
		if poolDef == nil {
			poolDef = &poolDefinition{
				app:   inst.App,
				sha:   inst.Sha,
				env:   inst.Env,
				insts: []*ZkInstance{},
			}
			pools[zkApp.Internal][name] = poolDef
		}
		pools[zkApp.Internal][name].insts = append(poolDef.insts, inst)
	}
	for internal, allPools := range pools {
		helper.SetRouterRoot(internal)
		for name, poolDef := range allPools {
			// remove hosts
			hosts := []string{}
			for _, inst := range poolDef.insts {
				hosts = append(hosts, fmt.Sprintf("%s:%d", inst.Host, inst.Port))
			}
			routerzk.DelHosts(Zk.Conn, name, hosts)
			// delete pool if no hosts exist
			getHosts, err := routerzk.GetHosts(Zk.Conn, name)
			if err != nil || len(getHosts) == 0 {
				err = routerzk.DelPool(Zk.Conn, name)
				if err != nil {
					log.Println("Error trying to clean up pool:", err)
				}
				err = CleanupCreatedPoolRefs(internal, poolDef.app, poolDef.sha, poolDef.env)
				if err != nil {
					log.Println("Error trying to clean up pool:", err)
				}
			}
		}
	}
	return nil
}
Beispiel #2
0
func UpdateAppEnvTrie(internal bool, app, sha, env string) (string, error) {
	helper.SetRouterRoot(internal)
	// create trie (if it doesn't exist)
	trieName := helper.GetAppEnvTrieName(app, env)
	if exists, err := routerzk.TrieExists(Zk.Conn, trieName); !exists || err != nil {
		err = routerzk.SetTrie(Zk.Conn, routercfg.Trie{
			Name:     trieName,
			Rules:    []string{},
			Internal: internal,
		})
		if err != nil {
			return trieName, err
		}
	}
	// if sha != "" attach pool as static rule (if trie is empty)
	if sha != "" {
		// if static rule does not exist, create it
		ruleName := helper.GetAppShaEnvStaticRuleName(app, sha, env)
		poolName := helper.CreatePoolName(app, sha, env)
		if exists, err := routerzk.RuleExists(Zk.Conn, ruleName); !exists || err != nil {
			err = routerzk.SetRule(Zk.Conn, routercfg.Rule{
				Name:     ruleName,
				Type:     "static",
				Value:    "true",
				Pool:     poolName,
				Internal: internal,
			})
			if err != nil {
				return trieName, err
			}
		}
		trie, err := routerzk.GetTrie(Zk.Conn, trieName)
		if err != nil {
			return trieName, err
		}
		if len(trie.Rules) == 0 {
			trie.Rules = []string{ruleName}
		} else {
			trie.Rules = append(trie.Rules, ruleName)
		}
		if err = routerzk.SetTrie(Zk.Conn, trie); err != nil {
			return trieName, err
		}
	}
	return trieName, nil
}
Beispiel #3
0
func AddToPool(containers []string) error {
	pools := map[bool]map[string][]*ZkInstance{}
	pools[true] = map[string][]*ZkInstance{}
	pools[false] = map[string][]*ZkInstance{}
	for _, cont := range containers {
		inst, err := GetInstance(cont)
		if err != nil {
			// instance doesn't exist
			continue
		}
		name := helper.CreatePoolName(inst.App, inst.Sha, inst.Env)
		zkApp, err := GetApp(inst.App)
		if err != nil {
			return err
		}
		currInsts := pools[zkApp.Internal][name]
		if currInsts == nil {
			currInsts = []*ZkInstance{}
		}
		pools[zkApp.Internal][name] = append(currInsts, inst)
	}
	for internal, allPools := range pools {
		helper.SetRouterRoot(internal)
		for name, insts := range allPools {
			// create pool if we need to
			if exists, err := routerzk.PoolExists(Zk.Conn, name); !exists || err != nil {
				if err = routerzk.SetPool(Zk.Conn, defaultPool(name, internal)); err != nil {
					return err
				}
			}
			// add hosts
			hosts := map[string]routercfg.Host{}
			for _, inst := range insts {
				address := fmt.Sprintf("%s:%d", inst.Host, inst.Port)
				hosts[address] = routercfg.Host{Address: address}
			}
			if err := routerzk.AddHosts(Zk.Conn, name, hosts); err != nil {
				return err
			}
		}
	}
	return nil
}
func (s *DatamodelSuite) TestRouterExternalPool(c *C) {
	Zk.RecursiveDelete("/atlantis/router")
	Zk.RecursiveDelete("/atlantis/apps")
	Zk.RecursiveDelete(helper.GetBaseInstancePath())
	CreateRouterPaths()
	CreateAppPath()
	// fake register app
	CreateOrUpdateApp(false, false, app, "ssh://[email protected]/app", "/", "*****@*****.**")
	CreateOrUpdateApp(false, false, "app2", "ssh://[email protected]/app", "/", "*****@*****.**")
	// do tests
	instance, err := CreateInstance(app, sha, env, host+"-1")
	c.Assert(err, IsNil)
	instance.SetPort(uint16(1337))
	instance2, err := CreateInstance(app, sha, env, host+"-2")
	c.Assert(err, IsNil)
	instance2.SetPort(uint16(1338))
	c.Assert(AddToPool([]string{instance.ID, instance2.ID}), IsNil)
	theName := helper.CreatePoolName(app, sha, env)
	helper.SetRouterRoot(false)
	thePool, err := routerzk.GetPool(Zk.Conn, theName)
	c.Assert(err, IsNil)
	c.Assert(thePool.Name, Equals, theName)
	c.Assert(thePool.Config.HealthzEvery, Not(Equals), "")
	c.Assert(thePool.Config.HealthzTimeout, Not(Equals), "")
	c.Assert(thePool.Config.RequestTimeout, Not(Equals), "")
	c.Assert(thePool.Hosts, DeepEquals, map[string]config.Host{host + "-1:1337": config.Host{Address: host + "-1:1337"}, host + "-2:1338": config.Host{Address: host + "-2:1338"}})
	newInstance, err := CreateInstance("app2", "sha1", "env1", host+"-1")
	c.Assert(err, IsNil)
	newInstance.SetPort(uint16(1339))
	newInstance2, err := CreateInstance(app, sha, env, host+"-3")
	c.Assert(err, IsNil)
	newInstance2.SetPort(uint16(1340))
	c.Assert(DeleteFromPool([]string{instance2.ID}), IsNil)
	instance2.Delete()
	c.Assert(AddToPool([]string{newInstance.ID, newInstance2.ID}), IsNil)
	helper.SetRouterRoot(false)
	thePool, err = routerzk.GetPool(Zk.Conn, theName)
	c.Assert(err, IsNil)
	c.Assert(thePool.Name, Equals, theName)
	c.Assert(thePool.Config.HealthzEvery, Not(Equals), "")
	c.Assert(thePool.Config.HealthzTimeout, Not(Equals), "")
	c.Assert(thePool.Config.RequestTimeout, Not(Equals), "")
	c.Assert(thePool.Hosts, DeepEquals, map[string]config.Host{host + "-1:1337": config.Host{Address: host + "-1:1337"}, host + "-3:1340": config.Host{Address: host + "-3:1340"}})
	helper.SetRouterRoot(false)
	thePool2, err := routerzk.GetPool(Zk.Conn, helper.CreatePoolName("app2", "sha1", "env1"))
	c.Assert(err, IsNil)
	c.Assert(thePool2.Name, Equals, helper.CreatePoolName("app2", "sha1", "env1"))
	c.Assert(thePool2.Config.HealthzEvery, Not(Equals), "")
	c.Assert(thePool2.Config.HealthzTimeout, Not(Equals), "")
	c.Assert(thePool2.Config.RequestTimeout, Not(Equals), "")
	c.Assert(thePool2.Hosts, DeepEquals, map[string]config.Host{host + "-1:1339": config.Host{Address: host + "-1:1339"}})
	helper.SetRouterRoot(false)
	pools, err := routerzk.ListPools(Zk.Conn)
	c.Assert(err, IsNil)
	sort.Strings(pools)
	c.Assert(pools, DeepEquals, []string{thePool2.Name, thePool.Name})
	c.Assert(DeleteFromPool([]string{instance.ID, newInstance.ID, newInstance2.ID}), IsNil)
	instance.Delete()
	newInstance.Delete()
	newInstance2.Delete()
	helper.SetRouterRoot(false)
	thePool, err = routerzk.GetPool(Zk.Conn, theName)
	c.Assert(err, Not(IsNil))
}
func (s *DatamodelSuite) TestRouterPoolNaming(c *C) {
	c.Assert(helper.CreatePoolName(app, sha, env), Matches, app+"."+sha+"."+env)
}