コード例 #1
0
func deployConsul(deploymentPrefix string, count int, client bosh.Client, config Config, releaseVersion string, manifestGenerator ManifestGenerator) (manifest consul.ManifestV2, kv consulclient.HTTPKV, err error) {
	guid, err := NewGUID()
	if err != nil {
		return
	}

	info, err := client.Info()
	if err != nil {
		return
	}

	manifestConfig := consul.ConfigV2{
		DirectorUUID:   info.UUID,
		Name:           fmt.Sprintf("consul-%s-%s", deploymentPrefix, guid),
		TurbulenceHost: config.TurbulenceHost,
		WindowsClients: config.WindowsClients,
	}

	var iaasConfig iaas.Config
	switch info.CPI {
	case "aws_cpi":
		manifestConfig.PersistentDiskType = config.BOSH.Errand.DefaultPersistentDiskType
		manifestConfig.VMType = config.BOSH.Errand.DefaultVMType

		awsConfig := buildAWSConfig(config)
		if len(config.AWS.Subnets) > 0 {
			subnet := config.AWS.Subnets[0]

			var cidrBlock string
			cidrPool := NewCIDRPool(subnet.Range, 24, 27)
			cidrBlock, err = cidrPool.Get(ginkgoConfig.GinkgoConfig.ParallelNode)
			if err != nil {
				return
			}

			awsConfig.Subnets = append(awsConfig.Subnets, iaas.AWSConfigSubnet{ID: subnet.ID, Range: cidrBlock, AZ: subnet.AZ, SecurityGroup: subnet.SecurityGroup})
			manifestConfig.AZs = append(manifestConfig.AZs, consul.ConfigAZ{IPRange: cidrBlock, Nodes: count, Name: "z1"})
		} else {
			err = errors.New("AWSSubnet is required for AWS IAAS deployment")
			return
		}

		iaasConfig = awsConfig
	case "warden_cpi":
		iaasConfig = iaas.NewWardenConfig()

		var cidrBlock string
		cidrPool := NewCIDRPool("10.244.4.0", 24, 27)
		cidrBlock, err = cidrPool.Get(ginkgoConfig.GinkgoConfig.ParallelNode)
		if err != nil {
			return
		}

		manifestConfig.AZs = []consul.ConfigAZ{
			{
				IPRange: cidrBlock,
				Nodes:   count,
				Name:    "z1",
			},
		}
	default:
		err = errors.New("unknown infrastructure type")
		return
	}

	manifest, err = manifestGenerator(manifestConfig, iaasConfig)
	if err != nil {
		return
	}

	for i := range manifest.Releases {
		if manifest.Releases[i].Name == "consul" {
			manifest.Releases[i].Version = releaseVersion
		}
	}

	yaml, err := manifest.ToYAML()
	if err != nil {
		return
	}

	yaml, err = client.ResolveManifestVersions(yaml)
	if err != nil {
		return
	}

	err = consul.FromYAML(yaml, &manifest)
	if err != nil {
		return
	}

	_, err = client.Deploy(yaml)
	if err != nil {
		return
	}

	err = VerifyDeploymentRelease(client, manifestConfig.Name, releaseVersion)
	if err != nil {
		return
	}

	kv = consulclient.NewHTTPKV(fmt.Sprintf("http://%s:6769", manifest.InstanceGroups[1].Networks[0].StaticIPs[0]))
	return
}
		It("deploys successfully with minimal interruption", func() {
			if config.WindowsClients {
				Skip("bosh 1.0 style manifests do not support windows vms")
			}

			By("deploying 3 node cluster across two AZs with BOSH 1.0 manifest", func() {
				var err error
				manifest, err = helpers.DeployMultiAZConsul("migrate-instance-group", boshClient, config)
				Expect(err).NotTo(HaveOccurred())

				Eventually(func() ([]bosh.VM, error) {
					return helpers.DeploymentVMs(boshClient, manifest.Name)
				}, "1m", "10s").Should(ConsistOf(helpers.GetVMsFromManifestV1(manifest)))

				for i, ip := range manifest.Jobs[2].Networks[0].StaticIPs {
					kv = consulclient.NewHTTPKV(fmt.Sprintf("http://%s:6769", ip))
					spammers = append(spammers, helpers.NewSpammer(kv, 1*time.Second, fmt.Sprintf("test-consumer-%d", i)))
				}
			})

			By("starting spammer", func() {
				for _, spammer := range spammers {
					spammer.Spam()
				}
			})

			By("deploying 3 node cluster across two AZs with BOSH 2.0 manifest", func() {
				manifestv2, err := helpers.DeployMultiAZConsulMigration(boshClient, config, manifest.Name)
				Expect(err).NotTo(HaveOccurred())

				Eventually(func() ([]bosh.VM, error) {
コード例 #3
0
		It("gets the key-value based on the key", func() {
			server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
				Expect(req.URL.Path).To(Equal("/consul/v1/kv/some-key"))

				Expect(req.Method).To(Equal("GET"))

				params, err := url.ParseQuery(req.URL.RawQuery)
				Expect(err).NotTo(HaveOccurred())

				_, ok := params["raw"]
				Expect(ok).To(BeTrue())

				w.Write([]byte("some-value"))
			}))

			kv := consulclient.NewHTTPKV(server.URL)

			value, err := kv.Get("some-key")
			Expect(err).NotTo(HaveOccurred())

			Expect(value).To(Equal("some-value"))
		})

		Context("failure cases", func() {
			Context("when consul cant find a value based on the key", func() {
				It("should return an error", func() {
					server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
						w.WriteHeader(http.StatusNotFound)
					}))

					kv := consulclient.NewHTTPKV(server.URL)