コード例 #1
0
func WatchForDisappearancesUnder(logger lager.Logger, client consuladapter.Client, disappearanceChan chan []string, stop <-chan struct{}, prefix string) {
	logger = logger.Session("watch-for-disappearances")

	go func() {
		logger.Info("starting")
		defer logger.Info("finished")

		keys := keySet{}

		queryOpts := &api.QueryOptions{
			WaitIndex: 0,
			WaitTime:  defaultWatchBlockDuration,
		}

		for {
			newPairs, queryMeta, err := client.KV().List(prefix, queryOpts)

			if err != nil {
				logger.Error("list-failed", err)
				select {
				case <-stop:
					return
				case <-time.After(1 * time.Second):
				}
				queryOpts.WaitIndex = 0
				continue
			}

			select {
			case <-stop:
				return
			default:
			}

			queryOpts.WaitIndex = queryMeta.LastIndex

			if newPairs == nil {
				// key not found
				_, err = client.KV().Put(&api.KVPair{Key: prefix, Value: emptyBytes}, nil)
				if err != nil {
					logger.Error("put-failed", err)
					continue
				}
			}

			newKeys := newKeySet(newPairs)
			if missing := difference(keys, newKeys); len(missing) > 0 {
				select {
				case disappearanceChan <- missing:
				case <-stop:
					return
				}
			}

			keys = newKeys
		}
	}()
}
コード例 #2
0
ファイル: session.go プロジェクト: cloudfoundry/locket
func create(se *api.SessionEntry, noChecks bool, client consuladapter.Client) (string, string, error) {
	session := client.Session()
	agent := client.Agent()

	nodeName, err := agent.NodeName()
	if err != nil {
		return "", "", err
	}

	nodeSessions, _, err := session.Node(nodeName, nil)
	if err != nil {
		return "", "", err
	}

	sessions := findSessions(se.Name, nodeSessions)
	if sessions != nil {
		for _, s := range sessions {
			_, err = session.Destroy(s.ID, nil)
			if err != nil {
				return "", "", err
			}
		}
	}

	var f func(*api.SessionEntry, *api.WriteOptions) (string, *api.WriteMeta, error)
	if noChecks {
		f = session.CreateNoChecks
	} else {
		f = session.Create
	}

	id, _, err := f(se, nil)
	if err != nil {
		return "", "", err
	}

	return id, se.TTL, nil
}
コード例 #3
0
	"github.com/tedsuo/ifrit/ginkgomon"

	. "github.com/onsi/ginkgo"
	. "github.com/onsi/gomega"
)

var _ = Describe("Service Registration Integration", func() {
	const (
		serviceID   = "test-id"
		serviceName = "Test-Service"
	)

	var (
		consulClient consuladapter.Client
		logger       lager.Logger
		clock        *fakeclock.FakeClock

		registration        *api.AgentServiceRegistration
		registrationProcess ifrit.Process
	)

	BeforeEach(func() {
		consulClient = consulRunner.NewClient()

		logger = lagertest.NewTestLogger("test")
		clock = fakeclock.NewFakeClock(time.Now())
		registration = &api.AgentServiceRegistration{
			ID:      serviceID,
			Name:    serviceName,
			Tags:    []string{"a", "b", "c"},
			Port:    8080,
			Address: "127.0.0.1",
コード例 #4
0
ファイル: presence_test.go プロジェクト: cloudfoundry/locket
	"code.cloudfoundry.org/lager/lagertest"
	"github.com/tedsuo/ifrit"
	"github.com/tedsuo/ifrit/ginkgomon"

	. "github.com/onsi/ginkgo"
	. "github.com/onsi/gomega"
	. "github.com/onsi/gomega/gbytes"
)

var _ = Describe("Presence", func() {
	var (
		presenceKey   string
		presenceValue []byte

		consulClient consuladapter.Client

		presenceRunner             ifrit.Runner
		presenceProcess            ifrit.Process
		retryInterval, presenceTTL time.Duration
		logger                     lager.Logger
		clock                      *fakeclock.FakeClock
	)

	getPresenceValue := func() ([]byte, error) {
		kvPair, _, err := consulClient.KV().Get(presenceKey, nil)
		if err != nil {
			return nil, err
		}

		if kvPair == nil || kvPair.Session == "" {
			return nil, consuladapter.NewKeyNotFoundError(presenceKey)
		}
コード例 #5
0
	"github.com/tedsuo/ifrit"
	"github.com/tedsuo/ifrit/ginkgomon"

	. "github.com/onsi/ginkgo"
	. "github.com/onsi/gomega"
	"github.com/onsi/gomega/gbytes"
)

var _ = Describe("Disappearance Watcher", func() {
	const retryInterval = 500 * time.Millisecond

	var (
		consulClient   consuladapter.Client
		watcherRunner  ifrit.Runner
		watcherProcess ifrit.Process

		disappearChan <-chan []string

		logger *lagertest.TestLogger
	)

	BeforeEach(func() {
		consulClient = consulRunner.NewClient()
		logger = lagertest.NewTestLogger("test")
		clock := clock.NewClock()
		watcherRunner, disappearChan = locket.NewDisappearanceWatcher(logger, consulClient, "under", clock)
		watcherProcess = ifrit.Invoke(watcherRunner)
	})

	AfterEach(func() {
		ginkgomon.Kill(watcherProcess)