Esempi in Golang per ServiceAvailable

Esempio n. 1

File: agentintegration_suite_test.go Progetto: nimbus-cloud/cf-redis-broker

func startAgent() *gexec.Session {
	config := &agentconfig.Config{
		DefaultConfPath:     helpers.AssetPath("redis.conf.default"),
		ConfPath:            redisConfPath,
		MonitExecutablePath: helpers.AssetPath("fake_monit"),
		Port:                "9876",
		AuthConfiguration: agentconfig.AuthConfiguration{
			Username: "******",
			Password: "******",
		},
	}

	configFile, err := ioutil.TempFile("", "config.yml")
	Expect(err).ToNot(HaveOccurred())

	encoder := candiedyaml.NewEncoder(configFile)
	err = encoder.Encode(config)
	Ω(err).ShouldNot(HaveOccurred())
	configFile.Close()

	agentPath, err := gexec.Build("github.com/pivotal-cf/cf-redis-broker/cmd/agent")
	Ω(err).ShouldNot(HaveOccurred())

	session, err := gexec.Start(
		exec.Command(agentPath, fmt.Sprintf("-agentConfig=%s", configFile.Name())),
		GinkgoWriter,
		GinkgoWriter,
	)
	Ω(err).ShouldNot(HaveOccurred())

	Expect(helpers.ServiceAvailable(9876)).To(BeTrue())
	return session
}

Esempio n. 2

File: reset_test.go Progetto: yacloud-io/cf-redis-broker

func startRedis(confPath string) (*gexec.Session, redis.Conn) {
	redisSession, err := gexec.Start(exec.Command("redis-server", confPath), GinkgoWriter, GinkgoWriter)
	Ω(err).ShouldNot(HaveOccurred())

	conf, err := redisconf.Load(confPath)
	Ω(err).ShouldNot(HaveOccurred())

	port, err := strconv.Atoi(conf.Get("port"))
	Ω(err).ShouldNot(HaveOccurred())

	Expect(helpers.ServiceAvailable(uint(port))).To(BeTrue())
	return redisSession, helpers.BuildRedisClient(uint(port), "localhost", conf.Get("requirepass"))
}

Esempio n. 3

File: redis_runner.go Progetto: nimbus-cloud/cf-redis-broker

func (runner *RedisRunner) Start(redisArgs []string) {
	command := exec.Command("redis-server", redisArgs...)

	var err error
	runner.Dir, err = ioutil.TempDir("", "redis-client-test")
	Ω(err).ShouldNot(HaveOccurred())
	command.Dir = runner.Dir

	err = command.Start()
	Ω(err).ShouldNot(HaveOccurred())

	runner.process = command.Process

	Expect(helpers.ServiceAvailable(RedisPort)).To(BeTrue())
}

Esempio n. 4

File: reset_test.go Progetto: yacloud-io/cf-redis-broker

func checkRedisStopAndStart(c chan<- bool) {
	defer GinkgoRecover()

	Eventually(redisSession, "3s").Should(gexec.Exit())

	// Sleep here to emulate the time it takes monit to do it's thing
	time.Sleep(time.Millisecond * 200)

	var err error
	redisSession, err = gexec.Start(exec.Command("redis-server", redisConfPath), GinkgoWriter, GinkgoWriter)
	Ω(err).ShouldNot(HaveOccurred())

	conf, err := redisconf.Load(redisConfPath)
	Ω(err).ShouldNot(HaveOccurred())

	port, err := strconv.Atoi(conf.Get("port"))
	Ω(err).ShouldNot(HaveOccurred())

	Expect(helpers.ServiceAvailable(uint(port))).To(BeTrue())

	c <- true
}

Esempio n. 5

File: process_restarting_test.go Progetto: yacloud-io/cf-redis-broker

			client = helpers.BuildRedisClient(port, host, password)
		})

		AfterEach(func() {
			helpers.KillProcess(monitorSession)
			client.Close()
			brokerClient.DeprovisionInstance(instanceID)
		})

		It("is restarted", func() {
			_, err := client.Do("SET", "foo", "bar")
			Ω(err).ShouldNot(HaveOccurred())

			helpers.KillRedisProcess(instanceID, brokerConfig)

			Ω(helpers.ServiceAvailable(port)).Should(BeTrue())

			client = helpers.BuildRedisClient(port, host, password)

			value, err := redisclient.String(client.Do("GET", "foo"))
			Ω(err).ToNot(HaveOccurred())
			Ω(value).To(Equal("bar"))
		})

		Context("when there is a lock file for the instance", func() {
			It("is not restarted", func() {
				_, err := client.Do("SET", "foo", "bar")
				Ω(err).ShouldNot(HaveOccurred())

				lockFilePath := filepath.Join(brokerConfig.RedisConfiguration.InstanceDataDirectory, instanceID, "lock")
				lockFile, err := os.Create(lockFilePath)

Esempio n. 6

File: agentintegration_suite_test.go Progetto: nimbus-cloud/cf-redis-broker

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

	"testing"
)

var redisConfPath string

func TestAgentintegration(t *testing.T) {
	RegisterFailHandler(Fail)
	junitReporter := reporters.NewJUnitReporter("junit_agentintegration.xml")
	RunSpecsWithDefaultAndCustomReporters(t, "Agent Integration Suite", []Reporter{junitReporter})
}

var _ = BeforeSuite(func() {
	if helpers.ServiceAvailable(6379) {
		panic("something is already using the dedicated redis port!")
	}
	dir, err := ioutil.TempDir("", "redisconf-test")
	Expect(err).ToNot(HaveOccurred())
	redisConfPath = filepath.Join(dir, "redis.conf")
})

func startAgent() *gexec.Session {
	config := &agentconfig.Config{
		DefaultConfPath:     helpers.AssetPath("redis.conf.default"),
		ConfPath:            redisConfPath,
		MonitExecutablePath: helpers.AssetPath("fake_monit"),
		Port:                "9876",
		AuthConfiguration: agentconfig.AuthConfiguration{
			Username: "******",

Esempio n. 7

File: statefile_test.go Progetto: yacloud-io/cf-redis-broker

	var instanceID string

	BeforeEach(func() {
		instanceID = uuid.NewRandom().String()
		brokerClient.ProvisionInstance(instanceID, "dedicated")
	})

	AfterEach(func() {
		brokerClient.DeprovisionInstance(instanceID)
	})

	Context("when the broker is restarted", func() {
		BeforeEach(func() {
			helpers.KillProcess(brokerSession)
			brokerSession = integration.LaunchProcessWithBrokerConfig(brokerExecutablePath, "broker.yml")
			Ω(helpers.ServiceAvailable(brokerPort)).Should(BeTrue())
		})

		It("retains state", func() {
			debugInfo := getDebugInfo()

			Ω(debugInfo.Allocated.Count).Should(Equal(1))
			Ω(len(debugInfo.Allocated.Clusters)).Should(Equal(1))

			host := debugInfo.Allocated.Clusters[0].Hosts[0]
			Ω(host).Should(MatchRegexp("server[1-3]\\.127\\.0\\.0\\.1\\.xip\\.io"))

			Ω(debugInfo.Pool.Clusters).ShouldNot(ContainElement([]string{host}))
		})
	})

Esempio n. 8

File: catalog_test.go Progetto: nimbus-cloud/cf-redis-broker

func switchBroker(config string) {
	helpers.KillProcess(brokerSession)
	helpers.ResetTestDirs()
	brokerSession = integration.LaunchProcessWithBrokerConfig(brokerExecutablePath, config)
	Ω(helpers.ServiceAvailable(brokerPort)).Should(BeTrue())
}

Esempio n. 9

File: brokerintegration_suite_test.go Progetto: nimbus-cloud/cf-redis-broker

	RunSpecsWithDefaultAndCustomReporters(t, "Broker Integration Suite", []Reporter{junitReporter})
}

var _ = BeforeEach(func() {
	helpers.ResetTestDirs()
})

var _ = BeforeSuite(func() {
	helpers.ResetTestDirs()

	brokerExecutablePath = integration.BuildBroker()
	brokerSession = integration.LaunchProcessWithBrokerConfig(brokerExecutablePath, "broker.yml")

	brokerConfig = integration.LoadBrokerConfig("broker.yml")

	if helpers.ServiceAvailable(uint(brokerConfig.RedisConfiguration.Dedicated.Port)) {
		panic("something is already using the dedicated redis port!")
	}

	brokerClient = &integration.BrokerClient{Config: &brokerConfig}

	Ω(helpers.ServiceAvailable(brokerPort)).Should(BeTrue())
	startFakeAgent(&agentRequests, &agentResponseStatus)
})

var _ = AfterSuite(func() {
	helpers.KillProcess(brokerSession)
})

func getRedisProcessCount() int {
	scriptPath := helpers.AssetPath("redis_process_count.sh")