Golang NewSequentialIDGenerator Examples

Example #1

File: main.go Project: digideskio/guardian

func wireNetworker(
	log lager.Logger,
	tag string,
	networkPoolCIDR *net.IPNet,
	externalIP net.IP,
	iptablesMgr kawasaki.IPTablesConfigurer,
	interfacePrefix string,
	chainPrefix string,
	propManager *properties.Manager,
	networkModulePath string) gardener.Networker {
	runner := &logging.Runner{CommandRunner: linux_command_runner.New(), Logger: log.Session("network-runner")}

	hostConfigurer := &configure.Host{
		Veth:   &devices.VethCreator{},
		Link:   &devices.Link{Name: "guardian"},
		Bridge: &devices.Bridge{},
		Logger: log.Session("network-host-configurer"),
	}

	containerCfgApplier := &configure.Container{
		Logger: log.Session("network-container-configurer"),
		Link:   &devices.Link{Name: "guardian"},
	}

	idGenerator := kawasaki.NewSequentialIDGenerator(time.Now().UnixNano())
	portPool, err := ports.NewPool(uint32(*portPoolStart), uint32(*portPoolSize), ports.State{})
	if err != nil {
		log.Fatal("invalid pool range", err)
	}

	switch networkModulePath {
	case "":
		return kawasaki.New(
			kawasaki.NewManager(runner, "/var/run/netns"),
			kawasaki.SpecParserFunc(kawasaki.ParseSpec),
			subnets.NewPool(networkPoolCIDR),
			kawasaki.NewConfigCreator(idGenerator, interfacePrefix, chainPrefix, externalIP),
			kawasaki.NewConfigurer(
				hostConfigurer,
				containerCfgApplier,
				iptablesMgr,
				&netns.Execer{},
			),
			propManager,
			iptables.NewPortForwarder(runner),
			portPool,
		)
	default:
		if _, err := os.Stat(networkModulePath); err != nil {
			log.Fatal("failed-to-stat-network-module", err)
			return nil
		}
		return gardener.ForeignNetworkAdaptor{
			ForeignNetworker: genclient.New(networkModulePath),
		}
	}
}

Example #2

File: idgenerator_test.go Project: digideskio/guardian

package kawasaki_test

import (
	"github.com/cloudfoundry-incubator/guardian/kawasaki"
	. "github.com/onsi/ginkgo"
	. "github.com/onsi/gomega"
)

var _ = Describe("Generate", func() {
	It("generates an 11 character ID", func() {
		idgen := kawasaki.NewSequentialIDGenerator(0)
		Expect(idgen.Generate()).To(HaveLen(11))
	})

	It("generates unique IDs on each invocation", func() {
		idgen := kawasaki.NewSequentialIDGenerator(0)
		id1 := idgen.Generate()
		id2 := idgen.Generate()

		Expect(id1).NotTo(Equal(id2))
	})

	It("generates deterministic IDs based on the seed", func() {
		idgen := kawasaki.NewSequentialIDGenerator(0)
		id1 := idgen.Generate()
		id2 := idgen.Generate()

		idgen = kawasaki.NewSequentialIDGenerator(1)
		id3 := idgen.Generate()

		Expect(id1).NotTo(Equal(id2))