コード例 #1
0
ファイル: galaxy.go プロジェクト: zombor/galaxy
func poolCreate(c *cli.Context) {
	ensureEnvArg(c)
	ensurePoolArg(c)
	initStore(c)
	created, err := configStore.CreatePool(utils.GalaxyPool(c), utils.GalaxyEnv(c))
	if err != nil {
		log.Fatalf("ERROR: Could not create pool: %s", err)
		return
	}

	if created {
		log.Printf("Pool %s created\n", utils.GalaxyPool(c))
	} else {
		log.Printf("Pool %s already exists\n", utils.GalaxyPool(c))
	}

	ec2host, err := runtime.EC2PublicHostname()
	if err != nil || ec2host == "" {
		log.Debug("not running from AWS, skipping pool creation")
		return
	}

	// now create the cloudformation stack
	// is this fails, the stack can be created separately with
	// stack:create_pool
	stackCreatePool(c)
}
コード例 #2
0
ファイル: consul.go プロジェクト: sguzwf/galaxy
func NewConsulBackend() *ConsulBackend {
	client, err := consul.NewClient(consul.DefaultConfig())
	if err != nil {
		// this shouldn't ever error with the default config
		panic(err)
	}

	node, err := client.Agent().NodeName()
	if err != nil {
		log.Fatal(err)
	}

	// find an existing galaxy session if one exists, or create a new one
	sessions, _, err := client.Session().Node(node, nil)
	if err != nil {
		log.Fatal(err)
	}

	var session *consul.SessionEntry
	for _, s := range sessions {
		if s.Name == "galaxy" {
			session = s
			break
		}
	}

	// we have a session, now make sure we can renew it so it doesn't expire
	// before we start running
	if session != nil {
		session, _, err = client.Session().Renew(session.ID, nil)
		if err != nil {
			log.Debug("error renewing galaxy session:", err)
		}
	}

	// no existing session, so create a new one
	if session == nil {
		session = &consul.SessionEntry{
			Name:     "galaxy",
			Behavior: "delete",
			TTL:      "15s",
		}

		session.ID, _, err = client.Session().Create(session, nil)
		if err != nil {
			// we can't continue without a session for key TTLs
			log.Fatal(err)
		}
	}

	// keep our session alive in the background
	done := make(chan struct{})
	go client.Session().RenewPeriodic("10s", session.ID, nil, done)

	return &ConsulBackend{
		client:    client,
		sessionID: session.ID,
		done:      done,
		seen: &eventCache{
			seen: make(map[string]uint64),
		},
	}
}