func init() { Describe("ReleaseApplySpec", func() { var ( platform *fakeplatform.FakePlatform action ReleaseApplySpecAction ) BeforeEach(func() { platform = fakeplatform.NewFakePlatform() action = NewReleaseApplySpec(platform) }) It("is synchronous", func() { Expect(action.IsAsynchronous()).To(BeFalse()) }) It("is not persistent", func() { Expect(action.IsPersistent()).To(BeFalse()) }) It("run", func() { err := platform.GetFs().WriteFileString("/var/vcap/micro/apply_spec.json", `{"json":["objects"]}`) Expect(err).ToNot(HaveOccurred()) value, err := action.Run() Expect(err).ToNot(HaveOccurred()) Expect(value).To(Equal(map[string]interface{}{"json": []interface{}{"objects"}})) }) }) }
func init() { Describe("ListDisk", func() { var ( settingsService *fakesettings.FakeSettingsService platform *fakeplatform.FakePlatform logger boshlog.Logger action ListDiskAction ) BeforeEach(func() { settingsService = &fakesettings.FakeSettingsService{} platform = fakeplatform.NewFakePlatform() logger = boshlog.NewLogger(boshlog.LevelNone) action = NewListDisk(settingsService, platform, logger) }) It("list disk should be synchronous", func() { Expect(action.IsAsynchronous()).To(BeFalse()) }) It("is not persistent", func() { Expect(action.IsPersistent()).To(BeFalse()) }) It("list disk run", func() { platform.MountedDevicePaths = []string{"/dev/sdb", "/dev/sdc"} settingsService.Settings.Disks = boshsettings.Disks{ Persistent: map[string]interface{}{ "volume-1": "/dev/sda", "volume-2": "/dev/sdb", "volume-3": "/dev/sdc", }, } value, err := action.Run() Expect(err).ToNot(HaveOccurred()) values, ok := value.([]string) Expect(ok).To(BeTrue()) Expect(values).To(ContainElement("volume-2")) Expect(values).To(ContainElement("volume-3")) Expect(len(values)).To(Equal(2)) }) }) }
func init() { Describe("Stop", func() { var ( jobSupervisor *fakejobsuper.FakeJobSupervisor platform *fakeplatform.FakePlatform settingsService *fakesettings.FakeSettingsService logger boshlog.Logger specService *fakeas.FakeV1Service dualDCSupport *nimbus.DualDCSupport action StopAction ) BeforeEach(func() { jobSupervisor = fakejobsuper.NewFakeJobSupervisor() platform = fakeplatform.NewFakePlatform() logger = boshlog.NewLogger(boshlog.LevelNone) specService = fakeas.NewFakeV1Service() settingsService = &fakesettings.FakeSettingsService{} dualDCSupport = nimbus.NewDualDCSupport( platform.GetRunner(), platform.GetFs(), platform.GetDirProvider(), specService, settingsService, logger, ) action = NewStop(jobSupervisor, dualDCSupport, platform) }) It("is asynchronous", func() { Expect(action.IsAsynchronous()).To(BeTrue()) }) It("is not persistent", func() { Expect(action.IsPersistent()).To(BeFalse()) }) It("returns stopped", func() { stopped, err := action.Run() Expect(err).ToNot(HaveOccurred()) Expect(stopped).To(Equal("stopped")) }) It("stops job supervisor services", func() { _, err := action.Run() Expect(err).ToNot(HaveOccurred()) Expect(jobSupervisor.Stopped).To(BeTrue()) }) }) }
func init() { Describe("ApplyAction", func() { var ( applier *fakeappl.FakeApplier specService *fakeas.FakeV1Service settingsService *fakesettings.FakeSettingsService platform *fakeplatform.FakePlatform dualDCSupport *nimbus.DualDCSupport logger boshlog.Logger action ApplyAction ) BeforeEach(func() { applier = fakeappl.NewFakeApplier() specService = fakeas.NewFakeV1Service() settingsService = &fakesettings.FakeSettingsService{} platform = fakeplatform.NewFakePlatform() logger = boshlog.NewLogger(boshlog.LevelNone) dualDCSupport = nimbus.NewDualDCSupport( platform.GetRunner(), platform.GetFs(), platform.GetDirProvider(), specService, settingsService, logger, ) action = NewApply(applier, specService, settingsService, dualDCSupport, platform) }) It("apply should be asynchronous", func() { Expect(action.IsAsynchronous()).To(BeTrue()) }) It("is not persistent", func() { Expect(action.IsPersistent()).To(BeFalse()) }) Describe("Run", func() { settings := boshsettings.Settings{AgentID: "fake-agent-id"} BeforeEach(func() { settingsService.Settings = settings }) Context("when desired spec has configuration hash", func() { currentApplySpec := boshas.V1ApplySpec{ConfigurationHash: "fake-current-config-hash"} desiredApplySpec := boshas.V1ApplySpec{ConfigurationHash: "fake-desired-config-hash"} populatedDesiredApplySpec := boshas.V1ApplySpec{ ConfigurationHash: "fake-populated-desired-config-hash", } Context("when current spec can be retrieved", func() { BeforeEach(func() { specService.Spec = currentApplySpec }) It("populates dynamic networks in desired spec", func() { _, err := action.Run(desiredApplySpec) Expect(err).ToNot(HaveOccurred()) Expect(specService.PopulateDHCPNetworksSpec).To(Equal(desiredApplySpec)) Expect(specService.PopulateDHCPNetworksSettings).To(Equal(settings)) }) Context("when resolving dynamic networks succeeds", func() { BeforeEach(func() { specService.PopulateDHCPNetworksResultSpec = populatedDesiredApplySpec }) It("runs applier with populated desired spec", func() { _, err := action.Run(desiredApplySpec) Expect(err).ToNot(HaveOccurred()) Expect(applier.Applied).To(BeTrue()) Expect(applier.ApplyCurrentApplySpec).To(Equal(currentApplySpec)) Expect(applier.ApplyDesiredApplySpec).To(Equal(populatedDesiredApplySpec)) }) Context("when applier succeeds applying desired spec", func() { Context("when saving desires spec as current spec succeeds", func() { It("returns 'applied' after setting populated desired spec as current spec", func() { value, err := action.Run(desiredApplySpec) Expect(err).ToNot(HaveOccurred()) Expect(value).To(Equal("applied")) Expect(specService.Spec).To(Equal(populatedDesiredApplySpec)) }) }) Context("when saving populated desires spec as current spec fails", func() { It("returns error because agent was not able to remember that is converged to desired spec", func() { specService.SetErr = errors.New("fake-set-error") _, err := action.Run(desiredApplySpec) Expect(err).To(HaveOccurred()) Expect(err.Error()).To(ContainSubstring("fake-set-error")) }) }) }) Context("when applier fails applying desired spec", func() { BeforeEach(func() { applier.ApplyError = errors.New("fake-apply-error") }) It("returns error", func() { _, err := action.Run(desiredApplySpec) Expect(err).To(HaveOccurred()) Expect(err.Error()).To(ContainSubstring("fake-apply-error")) }) It("does not save desired spec as current spec", func() { _, err := action.Run(desiredApplySpec) Expect(err).To(HaveOccurred()) Expect(specService.Spec).To(Equal(currentApplySpec)) }) }) }) Context("when resolving dynamic networks fails", func() { BeforeEach(func() { specService.PopulateDHCPNetworksErr = errors.New("fake-populate-dynamic-networks-err") }) It("returns error", func() { _, err := action.Run(desiredApplySpec) Expect(err).To(HaveOccurred()) Expect(err.Error()).To(ContainSubstring("fake-populate-dynamic-networks-err")) }) It("does not apply desired spec as current spec", func() { _, err := action.Run(desiredApplySpec) Expect(err).To(HaveOccurred()) Expect(applier.Applied).To(BeFalse()) }) It("does not save desired spec as current spec", func() { _, err := action.Run(desiredApplySpec) Expect(err).To(HaveOccurred()) Expect(specService.Spec).To(Equal(currentApplySpec)) }) }) }) Context("when current spec cannot be retrieved", func() { BeforeEach(func() { specService.Spec = currentApplySpec specService.GetErr = errors.New("fake-get-error") }) It("returns error and does not apply desired spec", func() { _, err := action.Run(desiredApplySpec) Expect(err).To(HaveOccurred()) Expect(err.Error()).To(ContainSubstring("fake-get-error")) }) It("does not run applier with desired spec", func() { _, err := action.Run(desiredApplySpec) Expect(err).To(HaveOccurred()) Expect(applier.Applied).To(BeFalse()) }) It("does not save desired spec as current spec", func() { _, err := action.Run(desiredApplySpec) Expect(err).To(HaveOccurred()) Expect(specService.Spec).To(Equal(currentApplySpec)) }) }) }) Context("when desired spec does not have a configuration hash", func() { desiredApplySpec := boshas.V1ApplySpec{ JobSpec: boshas.JobSpec{ Template: "fake-job-template", }, } populatedDesiredApplySpec := boshas.V1ApplySpec{ JobSpec: boshas.JobSpec{ Template: "fake-populated-job-template", }, } It("populates dynamic networks in desired spec", func() { _, err := action.Run(desiredApplySpec) Expect(err).ToNot(HaveOccurred()) Expect(specService.PopulateDHCPNetworksSpec).To(Equal(desiredApplySpec)) Expect(specService.PopulateDHCPNetworksSettings).To(Equal(settings)) }) Context("when resolving dynamic networks succeeds", func() { BeforeEach(func() { specService.PopulateDHCPNetworksResultSpec = populatedDesiredApplySpec }) Context("when saving desires spec as current spec succeeds", func() { It("returns 'applied' after setting desired spec as current spec", func() { value, err := action.Run(desiredApplySpec) Expect(err).ToNot(HaveOccurred()) Expect(value).To(Equal("applied")) Expect(specService.Spec).To(Equal(populatedDesiredApplySpec)) }) It("does not try to apply desired spec since it does not have jobs and packages", func() { _, err := action.Run(desiredApplySpec) Expect(err).ToNot(HaveOccurred()) Expect(applier.Applied).To(BeFalse()) }) }) Context("when saving desires spec as current spec fails", func() { BeforeEach(func() { specService.SetErr = errors.New("fake-set-error") }) It("returns error because agent was not able to remember that is converged to desired spec", func() { _, err := action.Run(desiredApplySpec) Expect(err).To(HaveOccurred()) Expect(err.Error()).To(ContainSubstring("fake-set-error")) }) It("does not try to apply desired spec since it does not have jobs and packages", func() { _, err := action.Run(desiredApplySpec) Expect(err).To(HaveOccurred()) Expect(applier.Applied).To(BeFalse()) }) }) }) Context("when resolving dynamic networks fails", func() { BeforeEach(func() { specService.PopulateDHCPNetworksErr = errors.New("fake-populate-dynamic-networks-err") }) It("returns error", func() { _, err := action.Run(desiredApplySpec) Expect(err).To(HaveOccurred()) Expect(err.Error()).To(ContainSubstring("fake-populate-dynamic-networks-err")) }) It("does not apply desired spec as current spec", func() { _, err := action.Run(desiredApplySpec) Expect(err).To(HaveOccurred()) Expect(applier.Applied).To(BeFalse()) }) It("does not save desired spec as current spec", func() { _, err := action.Run(desiredApplySpec) Expect(err).To(HaveOccurred()) Expect(specService.Spec).ToNot(Equal(desiredApplySpec)) }) }) }) }) }) }
import ( "encoding/json" "errors" . "github.com/cloudfoundry/bosh-agent/internal/github.com/onsi/ginkgo" . "github.com/cloudfoundry/bosh-agent/internal/github.com/onsi/gomega" . "github.com/cloudfoundry/bosh-agent/infrastructure" boshlog "github.com/cloudfoundry/bosh-agent/internal/github.com/cloudfoundry/bosh-utils/logger" fakeplatform "github.com/cloudfoundry/bosh-agent/platform/fakes" ) var _ = Describe("ConfigDriveSettingsSource", func() { var ( platform *fakeplatform.FakePlatform source *ConfigDriveSettingsSource ) BeforeEach(func() { diskPaths := []string{"/fake-disk-path-1", "/fake-disk-path-2"} metadataPath := "fake-metadata-path" settingsPath := "fake-settings-path" platform = fakeplatform.NewFakePlatform() logger := boshlog.NewLogger(boshlog.LevelNone) source = NewConfigDriveSettingsSource(diskPaths, metadataPath, settingsPath, platform, logger) }) BeforeEach(func() { // Set up default settings and metadata platform.SetGetFilesContentsFromDisk("/fake-disk-path-1/fake-metadata-path", []byte(`{}`), nil) platform.SetGetFilesContentsFromDisk("/fake-disk-path-1/fake-settings-path", []byte(`{}`), nil)
func init() { Describe("natsHandler", func() { var ( settingsService *fakesettings.FakeSettingsService client *fakeyagnats.FakeYagnats logger boshlog.Logger handler boshhandler.Handler platform *fakeplatform.FakePlatform loggerOutBuf *bytes.Buffer loggerErrBuf *bytes.Buffer ) BeforeEach(func() { settingsService = &fakesettings.FakeSettingsService{ Settings: boshsettings.Settings{ AgentID: "my-agent-id", Mbus: "nats://*****:*****@127.0.0.1:1234", }, } loggerOutBuf = bytes.NewBufferString("") loggerErrBuf = bytes.NewBufferString("") logger = boshlog.NewWriterLogger(boshlog.LevelError, loggerOutBuf, loggerErrBuf) client = fakeyagnats.New() platform = fakeplatform.NewFakePlatform() handler = NewNatsHandler(settingsService, client, logger, platform) }) Describe("Start", func() { It("starts", func() { var receivedRequest boshhandler.Request handler.Start(func(req boshhandler.Request) (resp boshhandler.Response) { receivedRequest = req return boshhandler.NewValueResponse("expected value") }) defer handler.Stop() Expect(client.ConnectedConnectionProvider()).ToNot(BeNil()) Expect(client.SubscriptionCount()).To(Equal(1)) subscriptions := client.Subscriptions("agent.my-agent-id") Expect(len(subscriptions)).To(Equal(1)) expectedPayload := []byte(`{"method":"ping","arguments":["foo","bar"], "reply_to": "reply to me!"}`) subscription := subscriptions[0] subscription.Callback(&yagnats.Message{ Subject: "agent.my-agent-id", Payload: expectedPayload, }) Expect(receivedRequest).To(Equal(boshhandler.Request{ ReplyTo: "reply to me!", Method: "ping", Payload: expectedPayload, })) Expect(client.PublishedMessageCount()).To(Equal(1)) messages := client.PublishedMessages("reply to me!") Expect(len(messages)).To(Equal(1)) Expect(messages[0].Payload).To(Equal([]byte(`{"value":"expected value"}`))) }) It("cleans up ip-mac address cache for nats configured with ip address", func() { handler.Start(func(req boshhandler.Request) (resp boshhandler.Response) { return nil }) defer handler.Stop() Expect(platform.CleanedIPMacAddressCache).To(Equal("127.0.0.1")) Expect(client.ConnectedConnectionProvider()).ToNot(BeNil()) }) It("does not try to clean up ip-mac address cache for nats configured with hostname", func() { settingsService.Settings.Mbus = "nats://*****:*****@fake-hostname.com:1234" handler.Start(func(req boshhandler.Request) (resp boshhandler.Response) { return nil }) defer handler.Stop() Expect(platform.CleanedIPMacAddressCache).To(BeEmpty()) Expect(client.ConnectedConnectionProvider()).ToNot(BeNil()) }) It("logs error and proceeds if it fails to clean up ip-mac address cache for nats", func() { platform.CleanIPMacAddressCacheErr = errors.New("failed to run") handler.Start(func(req boshhandler.Request) (resp boshhandler.Response) { return nil }) defer handler.Stop() Expect(platform.CleanedIPMacAddressCache).To(Equal("127.0.0.1")) Expect(loggerErrBuf).To(ContainSubstring("ERROR - Cleaning ip-mac address cache for: 127.0.0.1")) Expect(client.ConnectedConnectionProvider()).ToNot(BeNil()) }) It("does not respond if the response is nil", func() { err := handler.Start(func(req boshhandler.Request) (resp boshhandler.Response) { return nil }) Expect(err).ToNot(HaveOccurred()) defer handler.Stop() subscription := client.Subscriptions("agent.my-agent-id")[0] subscription.Callback(&yagnats.Message{ Subject: "agent.my-agent-id", Payload: []byte(`{"method":"ping","arguments":["foo","bar"], "reply_to": "reply to me!"}`), }) Expect(client.PublishedMessageCount()).To(Equal(0)) }) It("responds with an error if the response is bigger than 1MB", func() { err := handler.Start(func(req boshhandler.Request) (resp boshhandler.Response) { // gets inflated by json.Marshal when enveloping size := 0 switch req.Method { case "small": size = 1024*1024 - 12 case "big": size = 1024 * 1024 default: panic("unknown request size") } chars := make([]byte, size) for i := range chars { chars[i] = 'A' } return boshhandler.NewValueResponse(string(chars)) }) Expect(err).ToNot(HaveOccurred()) defer handler.Stop() subscription := client.Subscriptions("agent.my-agent-id")[0] subscription.Callback(&yagnats.Message{ Subject: "agent.my-agent-id", Payload: []byte(`{"method":"small","arguments":[], "reply_to": "fake-reply-to"}`), }) subscription.Callback(&yagnats.Message{ Subject: "agent.my-agent-id", Payload: []byte(`{"method":"big","arguments":[], "reply_to": "fake-reply-to"}`), }) Expect(client.PublishedMessageCount()).To(Equal(1)) messages := client.PublishedMessages("fake-reply-to") Expect(len(messages)).To(Equal(2)) Expect(messages[0].Payload).To(MatchRegexp("value")) Expect(messages[1].Payload).To(Equal([]byte( `{"exception":{"message":"Response exceeded maximum allowed length"}}`))) }) It("can add additional handler funcs to receive requests", func() { var firstHandlerReq, secondHandlerRequest boshhandler.Request handler.Start(func(req boshhandler.Request) (resp boshhandler.Response) { firstHandlerReq = req return boshhandler.NewValueResponse("first-handler-resp") }) defer handler.Stop() handler.RegisterAdditionalFunc(func(req boshhandler.Request) (resp boshhandler.Response) { secondHandlerRequest = req return boshhandler.NewValueResponse("second-handler-resp") }) expectedPayload := []byte(`{"method":"ping","arguments":["foo","bar"], "reply_to": "fake-reply-to"}`) subscription := client.Subscriptions("agent.my-agent-id")[0] subscription.Callback(&yagnats.Message{ Subject: "agent.my-agent-id", Payload: expectedPayload, }) // Expected requests received by both handlers Expect(firstHandlerReq).To(Equal(boshhandler.Request{ ReplyTo: "fake-reply-to", Method: "ping", Payload: expectedPayload, })) Expect(secondHandlerRequest).To(Equal(boshhandler.Request{ ReplyTo: "fake-reply-to", Method: "ping", Payload: expectedPayload, })) // Bosh handler responses were sent Expect(client.PublishedMessageCount()).To(Equal(1)) messages := client.PublishedMessages("fake-reply-to") Expect(len(messages)).To(Equal(2)) Expect(messages[0].Payload).To(Equal([]byte(`{"value":"first-handler-resp"}`))) Expect(messages[1].Payload).To(Equal([]byte(`{"value":"second-handler-resp"}`))) }) It("has the correct connection info", func() { err := handler.Start(func(req boshhandler.Request) (res boshhandler.Response) { return }) Expect(err).ToNot(HaveOccurred()) defer handler.Stop() Expect(client.ConnectedConnectionProvider()).To(Equal(&yagnats.ConnectionInfo{ Addr: "127.0.0.1:1234", Username: "******", Password: "******", })) }) It("does not err when no username and password", func() { settingsService.Settings.Mbus = "nats://127.0.0.1:1234" handler = NewNatsHandler(settingsService, client, logger, platform) err := handler.Start(func(req boshhandler.Request) (res boshhandler.Response) { return }) Expect(err).ToNot(HaveOccurred()) defer handler.Stop() }) It("errs when has username without password", func() { settingsService.Settings.Mbus = "nats://[email protected]:1234" handler = NewNatsHandler(settingsService, client, logger, platform) err := handler.Start(func(req boshhandler.Request) (res boshhandler.Response) { return }) Expect(err).To(HaveOccurred()) defer handler.Stop() }) }) Describe("Send", func() { It("sends the message over nats to a subject that includes the target and topic", func() { errCh := make(chan error, 1) payload := map[string]string{"key1": "value1", "keyA": "valueA"} go func() { errCh <- handler.Send(boshhandler.HealthMonitor, boshhandler.Heartbeat, payload) }() var err error select { case err = <-errCh: } Expect(err).ToNot(HaveOccurred()) Expect(client.PublishedMessageCount()).To(Equal(1)) messages := client.PublishedMessages("hm.agent.heartbeat.my-agent-id") Expect(messages).To(HaveLen(1)) Expect(messages[0].Payload).To(Equal( []byte("{\"key1\":\"value1\",\"keyA\":\"valueA\"}"), )) }) }) }) }
. "github.com/onsi/ginkgo" . "github.com/onsi/gomega" . "github.com/cloudfoundry/bosh-agent/mbus" "github.com/cloudfoundry/bosh-agent/micro" fakeplatform "github.com/cloudfoundry/bosh-agent/platform/fakes" boshdir "github.com/cloudfoundry/bosh-agent/settings/directories" fakesettings "github.com/cloudfoundry/bosh-agent/settings/fakes" boshlog "github.com/cloudfoundry/bosh-utils/logger" ) var _ = Describe("HandlerProvider", func() { var ( settingsService *fakesettings.FakeSettingsService platform *fakeplatform.FakePlatform dirProvider boshdir.Provider logger boshlog.Logger provider HandlerProvider ) BeforeEach(func() { settingsService = &fakesettings.FakeSettingsService{} logger = boshlog.NewLogger(boshlog.LevelNone) platform = fakeplatform.NewFakePlatform() dirProvider = boshdir.NewProvider("/var/vcap") provider = NewHandlerProvider(settingsService, logger) }) Describe("Get", func() { It("returns nats handler", func() { settingsService.Settings.Mbus = "nats://lol"
import ( fakeplatform "github.com/cloudfoundry/bosh-agent/platform/fakes" boshsettings "github.com/cloudfoundry/bosh-agent/settings" fakesettings "github.com/cloudfoundry/bosh-agent/settings/fakes" boshassert "github.com/cloudfoundry/bosh-utils/assert" . "github.com/onsi/ginkgo" . "github.com/onsi/gomega" . "github.com/cloudfoundry/bosh-agent/agent/action" ) var _ = Describe("UnmountDiskAction", func() { var ( platform *fakeplatform.FakePlatform action UnmountDiskAction expectedDiskSettings boshsettings.DiskSettings ) BeforeEach(func() { platform = fakeplatform.NewFakePlatform() settingsService := &fakesettings.FakeSettingsService{ Settings: boshsettings.Settings{ Disks: boshsettings.Disks{ Persistent: map[string]interface{}{ "vol-123": map[string]interface{}{ "volume_id": "2", "path": "/dev/sdf", }, },
)) Expect(platform.SetupSSHPublicKeys["fake-user"]).To(Equal("fake-public-key")) } func buildSSHAction(settingsService boshsettings.Service) (*fakeplatform.FakePlatform, SSHAction) { platform := fakeplatform.NewFakePlatform() dirProvider := boshdirs.NewProvider("/foo") logger := boshlog.NewLogger(boshlog.LevelNone) action := NewSSH(settingsService, platform, dirProvider, logger) return platform, action } var _ = Describe("SSHAction", func() { var ( platform *fakeplatform.FakePlatform settingsService boshsettings.Service action SSHAction ) Context("Action setup", func() { BeforeEach(func() { settingsService = &fakesettings.FakeSettingsService{} platform, action = buildSSHAction(settingsService) }) It("ssh should be synchronous", func() { Expect(action.IsAsynchronous()).To(BeFalse()) }) It("is not persistent", func() { Expect(action.IsPersistent()).To(BeFalse())
"errors" . "github.com/cloudfoundry/bosh-agent/agent/action" "github.com/cloudfoundry/bosh-agent/platform/cert/fakes" fakeplatform "github.com/cloudfoundry/bosh-agent/platform/fakes" boshsettings "github.com/cloudfoundry/bosh-agent/settings" fakesettings "github.com/cloudfoundry/bosh-agent/settings/fakes" "github.com/cloudfoundry/bosh-utils/logger" "path/filepath" ) var _ = Describe("UpdateSettings", func() { var ( action UpdateSettingsAction certManager *fakes.FakeManager settingsService *fakesettings.FakeSettingsService log logger.Logger platform *fakeplatform.FakePlatform newUpdateSettings boshsettings.UpdateSettings ) BeforeEach(func() { log = logger.NewLogger(logger.LevelNone) certManager = new(fakes.FakeManager) settingsService = &fakesettings.FakeSettingsService{} platform = fakeplatform.NewFakePlatform() action = NewUpdateSettings(settingsService, platform, certManager, log) newUpdateSettings = boshsettings.UpdateSettings{} }) AssertActionIsAsynchronous(action) AssertActionIsNotPersistent(action)
"errors" . "github.com/cloudfoundry/bosh-agent/internal/github.com/onsi/ginkgo" . "github.com/cloudfoundry/bosh-agent/internal/github.com/onsi/gomega" . "github.com/cloudfoundry/bosh-agent/agent/action" fakeplatform "github.com/cloudfoundry/bosh-agent/platform/fakes" boshsettings "github.com/cloudfoundry/bosh-agent/settings" boshdirs "github.com/cloudfoundry/bosh-agent/settings/directories" fakesettings "github.com/cloudfoundry/bosh-agent/settings/fakes" ) var _ = Describe("MountDiskAction", func() { var ( settingsService *fakesettings.FakeSettingsService platform *fakeplatform.FakePlatform action MountDiskAction ) BeforeEach(func() { settingsService = &fakesettings.FakeSettingsService{} platform = fakeplatform.NewFakePlatform() dirProvider := boshdirs.NewProvider("/fake-base-dir") action = NewMountDisk(settingsService, platform, platform, dirProvider) }) It("is asynchronous", func() { Expect(action.IsAsynchronous()).To(BeTrue()) }) It("is not persistent", func() {
boshsettings "github.com/cloudfoundry/bosh-agent/settings" boshcrypto "github.com/cloudfoundry/bosh-utils/crypto" fakelogger "github.com/cloudfoundry/bosh-agent/logger/fakes" fakeplatform "github.com/cloudfoundry/bosh-agent/platform/fakes" fakesettings "github.com/cloudfoundry/bosh-agent/settings/fakes" fakeblobstore "github.com/cloudfoundry/bosh-utils/blobstore/fakes" fakesys "github.com/cloudfoundry/bosh-utils/system/fakes" ) var _ = Describe("SyncDNS", func() { var ( action SyncDNS fakeBlobstore *fakeblobstore.FakeBlobstore fakeSettingsService *fakesettings.FakeSettingsService fakePlatform *fakeplatform.FakePlatform fakeFileSystem *fakesys.FakeFileSystem logger *fakelogger.FakeLogger ) BeforeEach(func() { logger = &fakelogger.FakeLogger{} fakeBlobstore = fakeblobstore.NewFakeBlobstore() fakeSettingsService = &fakesettings.FakeSettingsService{} fakePlatform = fakeplatform.NewFakePlatform() fakeFileSystem = fakePlatform.GetFs().(*fakesys.FakeFileSystem) action = NewSyncDNS(fakeBlobstore, fakeSettingsService, fakePlatform, logger) }) AssertActionIsNotAsynchronous(action)
func init() { Describe("Start", func() { var ( jobSupervisor *fakejobsuper.FakeJobSupervisor applier *fakeappl.FakeApplier specService *fakeas.FakeV1Service platform *fakeplatform.FakePlatform settingsService *fakesettings.FakeSettingsService logger boshlog.Logger dualDCSupport *nimbus.DualDCSupport action StartAction ) BeforeEach(func() { jobSupervisor = fakejobsuper.NewFakeJobSupervisor() applier = fakeappl.NewFakeApplier() specService = fakeas.NewFakeV1Service() action = NewStart(jobSupervisor, applier, specService, dualDCSupport, platform) platform = fakeplatform.NewFakePlatform() logger = boshlog.NewLogger(boshlog.LevelNone) settingsService = &fakesettings.FakeSettingsService{} dualDCSupport = nimbus.NewDualDCSupport( platform.GetRunner(), platform.GetFs(), platform.GetDirProvider(), specService, settingsService, logger, ) action = NewStart(jobSupervisor, applier, specService, dualDCSupport, platform) }) It("is synchronous", func() { Expect(action.IsAsynchronous()).To(BeFalse()) }) It("is not persistent", func() { Expect(action.IsPersistent()).To(BeFalse()) }) It("returns started", func() { started, err := action.Run() Expect(err).ToNot(HaveOccurred()) Expect(started).To(Equal("started")) }) It("starts monitor services", func() { _, err := action.Run() Expect(err).ToNot(HaveOccurred()) Expect(jobSupervisor.Started).To(BeTrue()) }) It("configures jobs", func() { _, err := action.Run() Expect(err).ToNot(HaveOccurred()) Expect(applier.Configured).To(BeTrue()) }) It("apply errs if a job fails configuring", func() { applier.ConfiguredError = errors.New("fake error") _, err := action.Run() Expect(err).To(HaveOccurred()) Expect(err.Error()).To(ContainSubstring("Configuring jobs")) }) }) }
func describeHTTPMetadataService() { var ( metadataHeaders map[string]string dnsResolver *fakeinf.FakeDNSResolver platform *fakeplat.FakePlatform logger boshlog.Logger metadataService MetadataService ) BeforeEach(func() { metadataHeaders = make(map[string]string) metadataHeaders["key"] = "value" dnsResolver = &fakeinf.FakeDNSResolver{} platform = fakeplat.NewFakePlatform() logger = boshlog.NewLogger(boshlog.LevelNone) metadataService = NewHTTPMetadataService("fake-metadata-host", metadataHeaders, "/user-data", "/instanceid", "/ssh-keys", dnsResolver, platform, logger) }) ItEnsuresMinimalNetworkSetup := func(subject func() (string, error)) { Context("when no networks are configured", func() { BeforeEach(func() { platform.GetConfiguredNetworkInterfacesInterfaces = []string{} }) It("sets up DHCP network", func() { _, err := subject() Expect(err).ToNot(HaveOccurred()) Expect(platform.SetupNetworkingCalled).To(BeTrue()) Expect(platform.SetupNetworkingNetworks).To(Equal(boshsettings.Networks{ "eth0": boshsettings.Network{ Type: "dynamic", }, })) }) Context("when setting up DHCP fails", func() { BeforeEach(func() { platform.SetupNetworkingErr = errors.New("fake-network-error") }) It("returns an error", func() { _, err := subject() Expect(err).To(HaveOccurred()) Expect(err.Error()).To(ContainSubstring("fake-network-error")) }) }) }) } Describe("IsAvailable", func() { It("returns true", func() { Expect(metadataService.IsAvailable()).To(BeTrue()) }) }) Describe("GetPublicKey", func() { var ( ts *httptest.Server sshKeysPath string ) BeforeEach(func() { handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { defer GinkgoRecover() Expect(r.Method).To(Equal("GET")) Expect(r.URL.Path).To(Equal("/ssh-keys")) Expect(r.Header.Get("key")).To(Equal("value")) w.Write([]byte("fake-public-key")) }) ts = httptest.NewServer(handler) }) AfterEach(func() { ts.Close() }) Context("when the ssh keys path is present", func() { BeforeEach(func() { sshKeysPath = "/ssh-keys" metadataService = NewHTTPMetadataService(ts.URL, metadataHeaders, "/user-data", "/instanceid", sshKeysPath, dnsResolver, platform, logger) }) It("returns fetched public key", func() { publicKey, err := metadataService.GetPublicKey() Expect(err).NotTo(HaveOccurred()) Expect(publicKey).To(Equal("fake-public-key")) }) ItEnsuresMinimalNetworkSetup(func() (string, error) { return metadataService.GetPublicKey() }) }) Context("when the ssh keys path is not present", func() { BeforeEach(func() { sshKeysPath = "" metadataService = NewHTTPMetadataService(ts.URL, metadataHeaders, "/user-data", "/instanceid", sshKeysPath, dnsResolver, platform, logger) }) It("returns an empty ssh key", func() { publicKey, err := metadataService.GetPublicKey() Expect(err).NotTo(HaveOccurred()) Expect(publicKey).To(BeEmpty()) }) }) }) Describe("GetInstanceID", func() { var ( ts *httptest.Server instanceIDPath string ) BeforeEach(func() { handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { defer GinkgoRecover() Expect(r.Method).To(Equal("GET")) Expect(r.URL.Path).To(Equal("/instanceid")) Expect(r.Header.Get("key")).To(Equal("value")) w.Write([]byte("fake-instance-id")) }) ts = httptest.NewServer(handler) }) AfterEach(func() { ts.Close() }) Context("when the instance ID path is present", func() { BeforeEach(func() { instanceIDPath = "/instanceid" metadataService = NewHTTPMetadataService(ts.URL, metadataHeaders, "/user-data", instanceIDPath, "/ssh-keys", dnsResolver, platform, logger) }) It("returns fetched instance id", func() { instanceID, err := metadataService.GetInstanceID() Expect(err).NotTo(HaveOccurred()) Expect(instanceID).To(Equal("fake-instance-id")) }) ItEnsuresMinimalNetworkSetup(func() (string, error) { return metadataService.GetInstanceID() }) }) Context("when the instance ID path is not present", func() { BeforeEach(func() { instanceIDPath = "" metadataService = NewHTTPMetadataService(ts.URL, metadataHeaders, "/user-data", instanceIDPath, "/ssh-keys", dnsResolver, platform, logger) }) It("returns an empty instance ID", func() { instanceID, err := metadataService.GetInstanceID() Expect(err).NotTo(HaveOccurred()) Expect(instanceID).To(BeEmpty()) }) }) }) Describe("GetServerName", func() { var ( ts *httptest.Server serverName *string ) handlerFunc := func(w http.ResponseWriter, r *http.Request) { defer GinkgoRecover() Expect(r.Method).To(Equal("GET")) Expect(r.URL.Path).To(Equal("/user-data")) Expect(r.Header.Get("key")).To(Equal("value")) var jsonStr string if serverName == nil { jsonStr = `{}` } else { jsonStr = fmt.Sprintf(`{"server":{"name":"%s"}}`, *serverName) } w.Write([]byte(jsonStr)) } BeforeEach(func() { serverName = nil handler := http.HandlerFunc(handlerFunc) ts = httptest.NewServer(handler) metadataService = NewHTTPMetadataService(ts.URL, metadataHeaders, "/user-data", "/instanceid", "/ssh-keys", dnsResolver, platform, logger) }) AfterEach(func() { ts.Close() }) Context("when the server name is present in the JSON", func() { BeforeEach(func() { name := "fake-server-name" serverName = &name }) It("returns the server name", func() { name, err := metadataService.GetServerName() Expect(err).ToNot(HaveOccurred()) Expect(name).To(Equal("fake-server-name")) }) ItEnsuresMinimalNetworkSetup(func() (string, error) { return metadataService.GetServerName() }) }) Context("when the server name is not present in the JSON", func() { BeforeEach(func() { serverName = nil }) It("returns an error", func() { name, err := metadataService.GetServerName() Expect(err).To(HaveOccurred()) Expect(name).To(BeEmpty()) }) }) }) Describe("GetRegistryEndpoint", func() { var ( ts *httptest.Server registryURL *string dnsServer *string ) handlerFunc := func(w http.ResponseWriter, r *http.Request) { defer GinkgoRecover() Expect(r.Method).To(Equal("GET")) Expect(r.URL.Path).To(Equal("/user-data")) Expect(r.Header.Get("key")).To(Equal("value")) var jsonStr string if dnsServer == nil { jsonStr = fmt.Sprintf(`{"registry":{"endpoint":"%s"}}`, *registryURL) } else { jsonStr = fmt.Sprintf(`{ "registry":{"endpoint":"%s"}, "dns":{"nameserver":["%s"]} }`, *registryURL, *dnsServer) } w.Write([]byte(jsonStr)) } BeforeEach(func() { url := "http://fake-registry.com" registryURL = &url dnsServer = nil handler := http.HandlerFunc(handlerFunc) ts = httptest.NewServer(handler) metadataService = NewHTTPMetadataService(ts.URL, metadataHeaders, "/user-data", "/instanceid", "/ssh-keys", dnsResolver, platform, logger) }) AfterEach(func() { ts.Close() }) ItEnsuresMinimalNetworkSetup(func() (string, error) { return metadataService.GetRegistryEndpoint() }) Context("when metadata contains a dns server", func() { BeforeEach(func() { server := "fake-dns-server-ip" dnsServer = &server }) Context("when registry endpoint is successfully resolved", func() { BeforeEach(func() { dnsResolver.RegisterRecord(fakeinf.FakeDNSRecord{ DNSServers: []string{"fake-dns-server-ip"}, Host: "http://fake-registry.com", IP: "http://fake-registry-ip", }) }) It("returns the successfully resolved registry endpoint", func() { endpoint, err := metadataService.GetRegistryEndpoint() Expect(err).ToNot(HaveOccurred()) Expect(endpoint).To(Equal("http://fake-registry-ip")) }) }) Context("when registry endpoint is not successfully resolved", func() { BeforeEach(func() { dnsResolver.LookupHostErr = errors.New("fake-lookup-host-err") }) It("returns error because it failed to resolve registry endpoint", func() { endpoint, err := metadataService.GetRegistryEndpoint() Expect(err).To(HaveOccurred()) Expect(err.Error()).To(ContainSubstring("fake-lookup-host-err")) Expect(endpoint).To(BeEmpty()) }) }) }) Context("when metadata does not contain dns servers", func() { It("returns fetched registry endpoint", func() { endpoint, err := metadataService.GetRegistryEndpoint() Expect(err).NotTo(HaveOccurred()) Expect(endpoint).To(Equal("http://fake-registry.com")) }) }) }) Describe("GetNetworks", func() { It("returns nil networks, since you don't need them for bootstrapping since your network must be set up before you can get the metadata", func() { Expect(metadataService.GetNetworks()).To(BeNil()) }) }) Describe("Retryable Metadata Service Request", func() { var ( ts *httptest.Server registryURL *string dnsServer *string ) createHandlerFunc := func(count int) func(http.ResponseWriter, *http.Request) { initialCount := 0 return func(w http.ResponseWriter, r *http.Request) { if initialCount < count { initialCount++ http.Error(w, http.StatusText(500), 500) return } var jsonStr string if dnsServer == nil { jsonStr = fmt.Sprintf(`{"registry":{"endpoint":"%s"}}`, *registryURL) } else { jsonStr = fmt.Sprintf(`{ "registry":{"endpoint":"%s"}, "dns":{"nameserver":["%s"]} }`, *registryURL, *dnsServer) } w.Write([]byte(jsonStr)) } } BeforeEach(func() { url := "http://fake-registry.com" registryURL = &url dnsServer = nil }) AfterEach(func() { ts.Close() }) Context("when server returns an HTTP Response with status code ==2xx (as defined by the request retryable) within 10 retries", func() { BeforeEach(func() { dnsResolver.RegisterRecord(fakeinf.FakeDNSRecord{ DNSServers: []string{"fake-dns-server-ip"}, Host: "http://fake-registry.com", IP: "http://fake-registry-ip", }) }) It("returns the successfully resolved registry endpoint", func() { handler := http.HandlerFunc(createHandlerFunc(9)) ts = httptest.NewServer(handler) metadataService = NewHTTPMetadataServiceWithCustomRetryDelay(ts.URL, metadataHeaders, "/user-data", "/instanceid", "/ssh-keys", dnsResolver, platform, logger, 0*time.Second) endpoint, err := metadataService.GetRegistryEndpoint() Expect(err).ToNot(HaveOccurred()) Expect(endpoint).To(Equal("http://fake-registry.com")) }) }) Context("when server returns an HTTP Response with status code !=2xx (as defined by the request retryable) more than 10 times", func() { It("returns an error containing the HTTP Response", func() { handler := http.HandlerFunc(createHandlerFunc(10)) ts = httptest.NewServer(handler) metadataService = NewHTTPMetadataServiceWithCustomRetryDelay(ts.URL, metadataHeaders, "/user-data", "/instanceid", "/ssh-keys", dnsResolver, platform, logger, 0*time.Second) _, err := metadataService.GetRegistryEndpoint() Expect(err).ToNot(BeNil()) Expect(err.Error()).To(Equal(fmt.Sprintf("Getting user data: Getting user data from url %s/user-data: Request failed, response: Response{ StatusCode: 500, Status: '500 Internal Server Error' }", ts.URL))) }) }) }) }
package infrastructure_test import ( "errors" . "github.com/onsi/ginkgo" . "github.com/onsi/gomega" . "github.com/cloudfoundry/bosh-agent/infrastructure" fakeplatform "github.com/cloudfoundry/bosh-agent/platform/fakes" boshlog "github.com/cloudfoundry/bosh-utils/logger" ) var _ = Describe("ConfigDriveSettingsSource", func() { var ( platform *fakeplatform.FakePlatform source *CDROMSettingsSource ) BeforeEach(func() { settingsFileName := "fake-settings-file-name" platform = fakeplatform.NewFakePlatform() logger := boshlog.NewLogger(boshlog.LevelNone) source = NewCDROMSettingsSource(settingsFileName, platform, logger) }) Describe("PublicSSHKeyForUsername", func() { It("returns an empty string", func() { publicKey, err := source.PublicSSHKeyForUsername("fake-username") Expect(err).ToNot(HaveOccurred()) Expect(publicKey).To(Equal("")) })
package infrastructure_test import ( . "github.com/onsi/ginkgo" . "github.com/onsi/gomega" . "github.com/cloudfoundry/bosh-agent/infrastructure" fakeplat "github.com/cloudfoundry/bosh-agent/platform/fakes" boshlog "github.com/cloudfoundry/bosh-utils/logger" ) var _ = Describe("SettingsSourceFactory", func() { Describe("New", func() { var ( options SettingsOptions platform *fakeplat.FakePlatform logger boshlog.Logger factory SettingsSourceFactory ) BeforeEach(func() { options = SettingsOptions{} platform = fakeplat.NewFakePlatform() logger = boshlog.NewLogger(boshlog.LevelNone) }) JustBeforeEach(func() { factory = NewSettingsSourceFactory(options, platform, logger) }) Context("when UseRegistry is set to true", func() { BeforeEach(func() {
func describeHTTPRegistry() { var ( metadataService *fakeinf.FakeMetadataService registry Registry platform *fakeplat.FakePlatform ) BeforeEach(func() { metadataService = &fakeinf.FakeMetadataService{} platform = &fakeplat.FakePlatform{} registry = NewHTTPRegistry(metadataService, platform, false) }) Describe("GetSettings", func() { var ( ts *httptest.Server settingsJSON string ) BeforeEach(func() { boshRegistryHandler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { GinkgoRecover() Expect(r.Method).To(Equal("GET")) Expect(r.URL.Path).To(Equal("/instances/fake-identifier/settings")) w.Write([]byte(settingsJSON)) }) ts = httptest.NewServer(boshRegistryHandler) }) AfterEach(func() { ts.Close() }) Describe("Network bootstrapping", func() { BeforeEach(func() { settingsJSON = `{"settings": "{\"agent_id\":\"my-agent-id\"}"}` metadataService.InstanceID = "fake-identifier" metadataService.RegistryEndpoint = ts.URL registry = NewHTTPRegistry(metadataService, platform, false) }) Context("when the metadata has Networks information", func() { It("configures the network with those settings before hitting the registry", func() { networkSettings := boshsettings.Networks{ "net1": boshsettings.Network{IP: "1.2.3.4"}, "net2": boshsettings.Network{IP: "2.3.4.5"}, } metadataService.Networks = networkSettings _, err := registry.GetSettings() Expect(err).ToNot(HaveOccurred()) Expect(platform.SetupNetworkingCalled).To(BeTrue()) Expect(platform.SetupNetworkingNetworks).To(Equal(networkSettings)) }) }) Context("when the metadata has no Networks information", func() { It("does no network configuration for now (the stemcell set up dhcp already)", func() { metadataService.Networks = boshsettings.Networks{} _, err := registry.GetSettings() Expect(err).ToNot(HaveOccurred()) Expect(platform.SetupNetworkingCalled).To(BeFalse()) }) }) Context("when the metadata service fails to get Networks information", func() { It("wraps the error", func() { metadataService.Networks = boshsettings.Networks{} metadataService.NetworksErr = errors.New("fake-get-networks-err") _, err := registry.GetSettings() Expect(err).To(HaveOccurred()) Expect(err.Error()).To(Equal("Getting networks: fake-get-networks-err")) }) }) Context("when the SetupNetworking fails", func() { It("wraps the error", func() { networkSettings := boshsettings.Networks{ "net1": boshsettings.Network{IP: "1.2.3.4"}, "net2": boshsettings.Network{IP: "2.3.4.5"}, } metadataService.Networks = networkSettings platform.SetupNetworkingErr = errors.New("fake-setup-networking-error") _, err := registry.GetSettings() Expect(err).To(HaveOccurred()) Expect(err.Error()).To(Equal("Setting up networks: fake-setup-networking-error")) }) }) }) Context("when registry is configured to not use server name as id", func() { BeforeEach(func() { registry = NewHTTPRegistry(metadataService, platform, false) metadataService.InstanceID = "fake-identifier" metadataService.RegistryEndpoint = ts.URL }) It("returns settings fetched from http server based on instance id", func() { settingsJSON = `{"settings": "{\"agent_id\":\"my-agent-id\"}"}` settings, err := registry.GetSettings() Expect(err).ToNot(HaveOccurred()) Expect(settings).To(Equal(boshsettings.Settings{AgentID: "my-agent-id"})) }) It("returns error if registry settings wrapper cannot be parsed", func() { settingsJSON = "invalid-json" settings, err := registry.GetSettings() Expect(err).To(HaveOccurred()) Expect(err.Error()).To(ContainSubstring("Unmarshalling settings wrapper")) Expect(settings).To(Equal(boshsettings.Settings{})) }) It("returns error if registry settings wrapper contains invalid json", func() { settingsJSON = `{"settings": "invalid-json"}` settings, err := registry.GetSettings() Expect(err).To(HaveOccurred()) Expect(err.Error()).To(ContainSubstring("Unmarshalling wrapped settings")) Expect(settings).To(Equal(boshsettings.Settings{})) }) It("returns error if metadata service fails to return instance id", func() { metadataService.GetInstanceIDErr = errors.New("fake-get-instance-id-err") settings, err := registry.GetSettings() Expect(err).To(HaveOccurred()) Expect(err.Error()).To(ContainSubstring("fake-get-instance-id-err")) Expect(settings).To(Equal(boshsettings.Settings{})) }) It("returns error if metadata service fails to return registry endpoint", func() { metadataService.GetRegistryEndpointErr = errors.New("fake-get-registry-endpoint-err") settings, err := registry.GetSettings() Expect(err).To(HaveOccurred()) Expect(err.Error()).To(ContainSubstring("fake-get-registry-endpoint-err")) Expect(settings).To(Equal(boshsettings.Settings{})) }) Describe("setting fields", func() { It("unmarshalls JSON properly", func() { settingsJSON = `{ "agent_id": "my-agent-id", "blobstore": { "options": { "bucket_name": "george", "encryption_key": "optional encryption key", "access_key_id": "optional access key id", "secret_access_key": "optional secret access key", "port": 443 }, "provider": "s3" }, "disks": { "ephemeral": "/dev/sdb", "persistent": { "vol-xxxxxx": "/dev/sdf" }, "system": "/dev/sda1" }, "env": { "bosh": { "password": "******" } }, "networks": { "netA": { "default": ["dns", "gateway"], "ip": "ww.ww.ww.ww", "dns": [ "xx.xx.xx.xx", "yy.yy.yy.yy" ] }, "netB": { "dns": [ "zz.zz.zz.zz" ] } }, "mbus": "https://*****:*****@0.0.0.0:6868", "ntp": [ "0.north-america.pool.ntp.org", "1.north-america.pool.ntp.org" ], "vm": { "name": "vm-abc-def" } }` settingsJSON = strings.Replace(settingsJSON, `"`, `\"`, -1) settingsJSON = strings.Replace(settingsJSON, "\n", "", -1) settingsJSON = strings.Replace(settingsJSON, "\t", "", -1) settingsJSON = fmt.Sprintf(`{"settings": "%s"}`, settingsJSON) expectedSettings := boshsettings.Settings{ AgentID: "my-agent-id", Blobstore: boshsettings.Blobstore{ Type: "s3", Options: map[string]interface{}{ "bucket_name": "george", "encryption_key": "optional encryption key", "access_key_id": "optional access key id", "secret_access_key": "optional secret access key", "port": 443.0, }, }, Disks: boshsettings.Disks{ Ephemeral: "/dev/sdb", Persistent: map[string]interface{}{"vol-xxxxxx": "/dev/sdf"}, System: "/dev/sda1", }, Env: boshsettings.Env{ Bosh: boshsettings.BoshEnv{ Password: "******", }, }, Networks: boshsettings.Networks{ "netA": boshsettings.Network{ Default: []string{"dns", "gateway"}, IP: "ww.ww.ww.ww", DNS: []string{"xx.xx.xx.xx", "yy.yy.yy.yy"}, }, "netB": boshsettings.Network{ DNS: []string{"zz.zz.zz.zz"}, }, }, Mbus: "https://*****:*****@0.0.0.0:6868", Ntp: []string{ "0.north-america.pool.ntp.org", "1.north-america.pool.ntp.org", }, VM: boshsettings.VM{ Name: "vm-abc-def", }, } metadataService.InstanceID = "fake-identifier" metadataService.RegistryEndpoint = ts.URL settings, err := registry.GetSettings() Expect(err).ToNot(HaveOccurred()) Expect(settings).To(Equal(expectedSettings)) }) }) }) Context("when registry is configured to use server name as id", func() { BeforeEach(func() { registry = NewHTTPRegistry(metadataService, platform, true) metadataService.ServerName = "fake-identifier" metadataService.RegistryEndpoint = ts.URL }) It("returns settings fetched from http server based on server name", func() { settingsJSON = `{"settings": "{\"agent_id\":\"my-agent-id\"}"}` settings, err := registry.GetSettings() Expect(err).ToNot(HaveOccurred()) Expect(settings).To(Equal(boshsettings.Settings{AgentID: "my-agent-id"})) }) It("returns error if registry settings wrapper cannot be parsed", func() { settingsJSON = "invalid-json" settings, err := registry.GetSettings() Expect(err).To(HaveOccurred()) Expect(err.Error()).To(ContainSubstring("Unmarshalling settings wrapper")) Expect(settings).To(Equal(boshsettings.Settings{})) }) It("returns error if registry settings wrapper contains invalid json", func() { settingsJSON = `{"settings": "invalid-json"}` settings, err := registry.GetSettings() Expect(err).To(HaveOccurred()) Expect(err.Error()).To(ContainSubstring("Unmarshalling wrapped settings")) Expect(settings).To(Equal(boshsettings.Settings{})) }) It("returns error if metadata service fails to return server name", func() { metadataService.GetServerNameErr = errors.New("fake-get-server-name-err") settings, err := registry.GetSettings() Expect(err).To(HaveOccurred()) Expect(err.Error()).To(ContainSubstring("fake-get-server-name-err")) Expect(settings).To(Equal(boshsettings.Settings{})) }) It("returns error if metadata service fails to return registry endpoint", func() { metadataService.GetRegistryEndpointErr = errors.New("fake-get-registry-endpoint-err") settings, err := registry.GetSettings() Expect(err).To(HaveOccurred()) Expect(err.Error()).To(ContainSubstring("fake-get-registry-endpoint-err")) Expect(settings).To(Equal(boshsettings.Settings{})) }) }) }) }
func describeHTTPMetadataService() { var ( dnsResolver *fakeinf.FakeDNSResolver platform *fakeplat.FakePlatform logger boshlog.Logger metadataService MetadataService ) BeforeEach(func() { dnsResolver = &fakeinf.FakeDNSResolver{} platform = fakeplat.NewFakePlatform() logger = boshlog.NewLogger(boshlog.LevelNone) metadataService = NewHTTPMetadataService("fake-metadata-host", dnsResolver, platform, logger) }) ItEnsuresMinimalNetworkSetup := func(subject func() (string, error)) { Context("when no networks are configured", func() { BeforeEach(func() { platform.GetConfiguredNetworkInterfacesInterfaces = []string{} }) It("sets up DHCP network", func() { _, err := subject() Expect(err).ToNot(HaveOccurred()) Expect(platform.SetupNetworkingCalled).To(BeTrue()) Expect(platform.SetupNetworkingNetworks).To(Equal(boshsettings.Networks{ "eth0": boshsettings.Network{ Type: "dynamic", }, })) }) Context("when setting up DHCP fails", func() { BeforeEach(func() { platform.SetupNetworkingErr = errors.New("fake-network-error") }) It("returns an error", func() { _, err := subject() Expect(err).To(HaveOccurred()) Expect(err.Error()).To(ContainSubstring("fake-network-error")) }) }) }) } Describe("IsAvailable", func() { It("returns true", func() { Expect(metadataService.IsAvailable()).To(BeTrue()) }) }) Describe("GetPublicKey", func() { var ( ts *httptest.Server ) BeforeEach(func() { handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { GinkgoRecover() Expect(r.Method).To(Equal("GET")) Expect(r.URL.Path).To(Equal("/latest/meta-data/public-keys/0/openssh-key")) w.Write([]byte("fake-public-key")) }) ts = httptest.NewServer(handler) metadataService = NewHTTPMetadataService(ts.URL, dnsResolver, platform, logger) }) AfterEach(func() { ts.Close() }) ItEnsuresMinimalNetworkSetup(func() (string, error) { return metadataService.GetPublicKey() }) It("returns fetched public key", func() { publicKey, err := metadataService.GetPublicKey() Expect(err).NotTo(HaveOccurred()) Expect(publicKey).To(Equal("fake-public-key")) }) }) Describe("GetInstanceID", func() { var ( ts *httptest.Server ) BeforeEach(func() { handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { GinkgoRecover() Expect(r.Method).To(Equal("GET")) Expect(r.URL.Path).To(Equal("/latest/meta-data/instance-id")) w.Write([]byte("fake-instance-id")) }) ts = httptest.NewServer(handler) metadataService = NewHTTPMetadataService(ts.URL, dnsResolver, platform, logger) }) AfterEach(func() { ts.Close() }) ItEnsuresMinimalNetworkSetup(func() (string, error) { return metadataService.GetInstanceID() }) It("returns fetched instance id", func() { publicKey, err := metadataService.GetInstanceID() Expect(err).NotTo(HaveOccurred()) Expect(publicKey).To(Equal("fake-instance-id")) }) }) Describe("GetServerName", func() { var ( ts *httptest.Server serverName *string ) handlerFunc := func(w http.ResponseWriter, r *http.Request) { GinkgoRecover() Expect(r.Method).To(Equal("GET")) Expect(r.URL.Path).To(Equal("/latest/user-data")) var jsonStr string if serverName == nil { jsonStr = `{}` } else { jsonStr = fmt.Sprintf(`{"server":{"name":"%s"}}`, *serverName) } w.Write([]byte(jsonStr)) } BeforeEach(func() { serverName = nil handler := http.HandlerFunc(handlerFunc) ts = httptest.NewServer(handler) metadataService = NewHTTPMetadataService(ts.URL, dnsResolver, platform, logger) }) AfterEach(func() { ts.Close() }) Context("when the server name is present in the JSON", func() { BeforeEach(func() { name := "fake-server-name" serverName = &name }) It("returns the server name", func() { name, err := metadataService.GetServerName() Expect(err).ToNot(HaveOccurred()) Expect(name).To(Equal("fake-server-name")) }) ItEnsuresMinimalNetworkSetup(func() (string, error) { return metadataService.GetServerName() }) }) Context("when the server name is not present in the JSON", func() { BeforeEach(func() { serverName = nil }) It("returns an error", func() { name, err := metadataService.GetServerName() Expect(err).To(HaveOccurred()) Expect(name).To(BeEmpty()) }) }) }) Describe("GetRegistryEndpoint", func() { var ( ts *httptest.Server registryURL *string dnsServer *string ) handlerFunc := func(w http.ResponseWriter, r *http.Request) { GinkgoRecover() Expect(r.Method).To(Equal("GET")) Expect(r.URL.Path).To(Equal("/latest/user-data")) var jsonStr string if dnsServer == nil { jsonStr = fmt.Sprintf(`{"registry":{"endpoint":"%s"}}`, *registryURL) } else { jsonStr = fmt.Sprintf(`{ "registry":{"endpoint":"%s"}, "dns":{"nameserver":["%s"]} }`, *registryURL, *dnsServer) } w.Write([]byte(jsonStr)) } BeforeEach(func() { url := "http://fake-registry.com" registryURL = &url dnsServer = nil handler := http.HandlerFunc(handlerFunc) ts = httptest.NewServer(handler) metadataService = NewHTTPMetadataService(ts.URL, dnsResolver, platform, logger) }) AfterEach(func() { ts.Close() }) ItEnsuresMinimalNetworkSetup(func() (string, error) { return metadataService.GetRegistryEndpoint() }) Context("when metadata contains a dns server", func() { BeforeEach(func() { server := "fake-dns-server-ip" dnsServer = &server }) Context("when registry endpoint is successfully resolved", func() { BeforeEach(func() { dnsResolver.RegisterRecord(fakeinf.FakeDNSRecord{ DNSServers: []string{"fake-dns-server-ip"}, Host: "http://fake-registry.com", IP: "http://fake-registry-ip", }) }) It("returns the successfully resolved registry endpoint", func() { endpoint, err := metadataService.GetRegistryEndpoint() Expect(err).ToNot(HaveOccurred()) Expect(endpoint).To(Equal("http://fake-registry-ip")) }) }) Context("when registry endpoint is not successfully resolved", func() { BeforeEach(func() { dnsResolver.LookupHostErr = errors.New("fake-lookup-host-err") }) It("returns error because it failed to resolve registry endpoint", func() { endpoint, err := metadataService.GetRegistryEndpoint() Expect(err).To(HaveOccurred()) Expect(err.Error()).To(ContainSubstring("fake-lookup-host-err")) Expect(endpoint).To(BeEmpty()) }) }) }) Context("when metadata does not contain dns servers", func() { It("returns fetched registry endpoint", func() { endpoint, err := metadataService.GetRegistryEndpoint() Expect(err).NotTo(HaveOccurred()) Expect(endpoint).To(Equal("http://fake-registry.com")) }) }) }) Describe("GetNetworks", func() { It("returns nil networks, since you don't need them for bootstrapping since your network must be set up before you can get the metadata", func() { Expect(metadataService.GetNetworks()).To(BeNil()) }) }) }
import ( . "github.com/onsi/ginkgo" . "github.com/onsi/gomega" . "github.com/cloudfoundry/bosh-agent/blobstore" boshlog "github.com/cloudfoundry/bosh-agent/logger" fakeplatform "github.com/cloudfoundry/bosh-agent/platform/fakes" boshsettings "github.com/cloudfoundry/bosh-agent/settings" boshdir "github.com/cloudfoundry/bosh-agent/settings/directories" boshuuid "github.com/cloudfoundry/bosh-agent/uuid" ) var _ = Describe("Provider", func() { var ( platform *fakeplatform.FakePlatform logger boshlog.Logger provider Provider ) BeforeEach(func() { platform = fakeplatform.NewFakePlatform() dirProvider := boshdir.NewDirectoriesProvider("/var/vcap") logger = boshlog.NewLogger(boshlog.LevelNone) provider = NewProvider(platform, dirProvider, logger) }) Describe("Get", func() { It("get dummy", func() { blobstore, err := provider.Get(boshsettings.Blobstore{ Type: boshsettings.BlobstoreTypeDummy, })
. "github.com/onsi/ginkgo" . "github.com/onsi/gomega" . "github.com/cloudfoundry/bosh-agent/agent/action" fakeplatform "github.com/cloudfoundry/bosh-agent/platform/fakes" boshsettings "github.com/cloudfoundry/bosh-agent/settings" boshdirs "github.com/cloudfoundry/bosh-agent/settings/directories" fakesettings "github.com/cloudfoundry/bosh-agent/settings/fakes" boshassert "github.com/cloudfoundry/bosh-utils/assert" boshlog "github.com/cloudfoundry/bosh-utils/logger" ) var _ = Describe("MountDiskAction", func() { var ( settingsService *fakesettings.FakeSettingsService platform *fakeplatform.FakePlatform action MountDiskAction logger boshlog.Logger ) BeforeEach(func() { settingsService = &fakesettings.FakeSettingsService{} platform = fakeplatform.NewFakePlatform() dirProvider := boshdirs.NewProvider("/fake-base-dir") logger = boshlog.NewLogger(boshlog.LevelNone) action = NewMountDisk(settingsService, platform, dirProvider, logger) }) AssertActionIsAsynchronous(action) AssertActionIsNotPersistent(action) AssertActionIsLoggable(action)
func init() { Describe("bootstrap", func() { Describe("Run", func() { var ( platform *fakeplatform.FakePlatform dirProvider boshdir.Provider settingsSource *fakeinf.FakeSettingsSource settingsService *fakesettings.FakeSettingsService ) BeforeEach(func() { platform = fakeplatform.NewFakePlatform() dirProvider = boshdir.NewProvider("/var/vcap") settingsSource = &fakeinf.FakeSettingsSource{} settingsService = &fakesettings.FakeSettingsService{} }) bootstrap := func() error { logger := boshlog.NewLogger(boshlog.LevelNone) return NewBootstrap(platform, dirProvider, settingsService, logger).Run() } It("sets up runtime configuration", func() { err := bootstrap() Expect(err).NotTo(HaveOccurred()) Expect(platform.SetupRuntimeConfigurationWasInvoked).To(BeTrue()) }) Describe("SSH tunnel setup for registry", func() { It("returns error without configuring ssh on the platform if getting public key fails", func() { settingsService.PublicKeyErr = errors.New("fake-get-public-key-err") err := bootstrap() Expect(err).To(HaveOccurred()) Expect(err.Error()).To(ContainSubstring("fake-get-public-key-err")) Expect(platform.SetupSSHCalled).To(BeFalse()) }) Context("when public key is not empty", func() { BeforeEach(func() { settingsService.PublicKey = "fake-public-key" }) It("gets the public key and sets up ssh via the platform", func() { err := bootstrap() Expect(err).NotTo(HaveOccurred()) Expect(platform.SetupSSHPublicKey).To(Equal("fake-public-key")) Expect(platform.SetupSSHUsername).To(Equal("vcap")) }) It("returns error if configuring ssh on the platform fails", func() { platform.SetupSSHErr = errors.New("fake-setup-ssh-err") err := bootstrap() Expect(err).To(HaveOccurred()) Expect(err.Error()).To(ContainSubstring("fake-setup-ssh-err")) }) }) Context("when public key key is empty", func() { BeforeEach(func() { settingsSource.PublicKey = "" }) It("gets the public key and does not setup SSH", func() { err := bootstrap() Expect(err).NotTo(HaveOccurred()) Expect(platform.SetupSSHCalled).To(BeFalse()) }) }) }) It("sets up hostname", func() { settingsService.Settings.AgentID = "foo-bar-baz-123" err := bootstrap() Expect(err).NotTo(HaveOccurred()) Expect(platform.SetupHostnameHostname).To(Equal("foo-bar-baz-123")) }) It("fetches initial settings", func() { err := bootstrap() Expect(err).NotTo(HaveOccurred()) Expect(settingsService.SettingsWereLoaded).To(BeTrue()) }) It("returns error from loading initial settings", func() { settingsService.LoadSettingsError = errors.New("fake-load-error") err := bootstrap() Expect(err).To(HaveOccurred()) Expect(err.Error()).To(ContainSubstring("fake-load-error")) }) It("sets up networking", func() { networks := boshsettings.Networks{ "bosh": boshsettings.Network{}, } settingsService.Settings.Networks = networks err := bootstrap() Expect(err).NotTo(HaveOccurred()) Expect(platform.SetupNetworkingNetworks).To(Equal(networks)) }) It("sets up ephemeral disk", func() { settingsService.Settings.Disks = boshsettings.Disks{ Ephemeral: "fake-ephemeral-disk-setting", } platform.GetEphemeralDiskPathRealPath = "/dev/sda" err := bootstrap() Expect(err).NotTo(HaveOccurred()) Expect(platform.SetupEphemeralDiskWithPathDevicePath).To(Equal("/dev/sda")) Expect(platform.GetEphemeralDiskPathSettings).To(Equal(boshsettings.DiskSettings{ VolumeID: "fake-ephemeral-disk-setting", Path: "fake-ephemeral-disk-setting", })) }) It("returns error if setting ephemeral disk fails", func() { platform.SetupEphemeralDiskWithPathErr = errors.New("fake-setup-ephemeral-disk-err") err := bootstrap() Expect(err).To(HaveOccurred()) Expect(err.Error()).To(ContainSubstring("fake-setup-ephemeral-disk-err")) }) It("sets up raw ephemeral disks if paths exist", func() { settingsService.Settings.Disks = boshsettings.Disks{ RawEphemeral: []boshsettings.DiskSettings{{Path: "/dev/xvdb"}, {Path: "/dev/xvdc"}}, } err := bootstrap() Expect(err).NotTo(HaveOccurred()) Expect(platform.SetupRawEphemeralDisksCallCount).To(Equal(1)) Expect(len(platform.SetupRawEphemeralDisksDevices)).To(Equal(2)) Expect(platform.SetupRawEphemeralDisksDevices[0].Path).To(Equal("/dev/xvdb")) Expect(platform.SetupRawEphemeralDisksDevices[1].Path).To(Equal("/dev/xvdc")) }) It("returns error if setting raw ephemeral disks fails", func() { platform.SetupRawEphemeralDisksErr = errors.New("fake-setup-raw-ephemeral-disks-err") err := bootstrap() Expect(platform.SetupRawEphemeralDisksCallCount).To(Equal(1)) Expect(err).To(HaveOccurred()) Expect(err.Error()).To(ContainSubstring("fake-setup-raw-ephemeral-disks-err")) }) It("sets up data dir", func() { err := bootstrap() Expect(err).NotTo(HaveOccurred()) Expect(platform.SetupDataDirCalled).To(BeTrue()) }) It("returns error if set up of data dir fails", func() { platform.SetupDataDirErr = errors.New("fake-setup-data-dir-err") err := bootstrap() Expect(err).To(HaveOccurred()) Expect(err.Error()).To(ContainSubstring("fake-setup-data-dir-err")) }) It("sets up tmp dir", func() { err := bootstrap() Expect(err).NotTo(HaveOccurred()) Expect(platform.SetupTmpDirCalled).To(BeTrue()) }) It("returns error if set up of tmp dir fails", func() { platform.SetupTmpDirErr = errors.New("fake-setup-tmp-dir-err") err := bootstrap() Expect(err).To(HaveOccurred()) Expect(err.Error()).To(ContainSubstring("fake-setup-tmp-dir-err")) }) It("mounts persistent disk", func() { settingsService.Settings.Disks = boshsettings.Disks{ Persistent: map[string]interface{}{ "vol-123": map[string]interface{}{ "volume_id": "2", "path": "/dev/sdb", }, }, } err := bootstrap() Expect(err).NotTo(HaveOccurred()) Expect(platform.MountPersistentDiskSettings).To(Equal(boshsettings.DiskSettings{ ID: "vol-123", VolumeID: "2", Path: "/dev/sdb", })) Expect(platform.MountPersistentDiskMountPoint).To(Equal(dirProvider.StoreDir())) }) It("errors if there is more than one persistent disk", func() { settingsService.Settings.Disks = boshsettings.Disks{ Persistent: map[string]interface{}{ "vol-123": "/dev/sdb", "vol-456": "/dev/sdc", }, } err := bootstrap() Expect(err).To(HaveOccurred()) }) It("does not try to mount when no persistent disk", func() { settingsService.Settings.Disks = boshsettings.Disks{ Persistent: map[string]interface{}{}, } err := bootstrap() Expect(err).NotTo(HaveOccurred()) Expect(platform.MountPersistentDiskSettings).To(Equal(boshsettings.DiskSettings{})) Expect(platform.MountPersistentDiskMountPoint).To(Equal("")) }) It("grows the root filesystem", func() { err := bootstrap() Expect(err).NotTo(HaveOccurred()) Expect(platform.SetupRootDiskCalledTimes).To(Equal(1)) }) It("returns an error if growing the root filesystem fails", func() { platform.SetupRootDiskError = errors.New("growfs failed") err := bootstrap() Expect(err).To(HaveOccurred()) Expect(platform.SetupRootDiskCalledTimes).To(Equal(1)) Expect(err.Error()).To(ContainSubstring("growfs failed")) }) It("sets root and vcap passwords", func() { settingsService.Settings.Env.Bosh.Password = "******" settingsService.Settings.Env.Bosh.KeepRootPassword = false err := bootstrap() Expect(err).NotTo(HaveOccurred()) Expect(2).To(Equal(len(platform.UserPasswords))) Expect("some-encrypted-password").To(Equal(platform.UserPasswords["root"])) Expect("some-encrypted-password").To(Equal(platform.UserPasswords["vcap"])) }) It("does not change root password if keep_root_password is set to true", func() { settingsService.Settings.Env.Bosh.Password = "******" settingsService.Settings.Env.Bosh.KeepRootPassword = true err := bootstrap() Expect(err).NotTo(HaveOccurred()) Expect(1).To(Equal(len(platform.UserPasswords))) Expect("some-encrypted-password").ToNot(Equal(platform.UserPasswords["root"])) Expect("some-encrypted-password").To(Equal(platform.UserPasswords["vcap"])) }) It("does not set password if not provided", func() { settingsService.Settings.Env.Bosh.KeepRootPassword = false err := bootstrap() Expect(err).NotTo(HaveOccurred()) Expect(0).To(Equal(len(platform.UserPasswords))) }) It("sets ntp", func() { settingsService.Settings.Ntp = []string{ "0.north-america.pool.ntp.org", "1.north-america.pool.ntp.org", } err := bootstrap() Expect(err).NotTo(HaveOccurred()) Expect(2).To(Equal(len(platform.SetTimeWithNtpServersServers))) Expect("0.north-america.pool.ntp.org").To(Equal(platform.SetTimeWithNtpServersServers[0])) Expect("1.north-america.pool.ntp.org").To(Equal(platform.SetTimeWithNtpServersServers[1])) }) It("setups up monit user", func() { err := bootstrap() Expect(err).NotTo(HaveOccurred()) Expect(platform.SetupMonitUserSetup).To(BeTrue()) }) It("starts monit", func() { err := bootstrap() Expect(err).NotTo(HaveOccurred()) Expect(platform.StartMonitStarted).To(BeTrue()) }) }) Describe("Network setup exercised by Run", func() { var ( settingsJSON string fs *fakesys.FakeFileSystem platform boshplatform.Platform boot Bootstrap defaultNetworkResolver boshsettings.DefaultNetworkResolver logger boshlog.Logger dirProvider boshdirs.Provider interfaceAddrsProvider *fakeip.FakeInterfaceAddressesProvider ) writeNetworkDevice := func(iface string, macAddress string, isPhysical bool) string { interfacePath := fmt.Sprintf("/sys/class/net/%s", iface) fs.WriteFile(interfacePath, []byte{}) if isPhysical { fs.WriteFile(fmt.Sprintf("/sys/class/net/%s/device", iface), []byte{}) } fs.WriteFileString(fmt.Sprintf("/sys/class/net/%s/address", iface), fmt.Sprintf("%s\n", macAddress)) return interfacePath } stubInterfaces := func(interfaces [][]string) { var interfacePaths []string for _, iface := range interfaces { interfaceName := iface[0] interfaceMAC := iface[1] interfaceType := iface[2] isPhysical := interfaceType == "physical" interfacePaths = append(interfacePaths, writeNetworkDevice(interfaceName, interfaceMAC, isPhysical)) } fs.SetGlob("/sys/class/net/*", interfacePaths) } BeforeEach(func() { fs = fakesys.NewFakeFileSystem() runner := fakesys.NewFakeCmdRunner() dirProvider = boshdirs.NewProvider("/var/vcap/bosh") linuxOptions := boshplatform.LinuxOptions{ CreatePartitionIfNoEphemeralDisk: true, } logger = boshlog.NewLogger(boshlog.LevelNone) diskManager := fakedisk.NewFakeDiskManager() diskManager.FakeMountsSearcher.SearchMountsMounts = []boshdisk.Mount{ {MountPoint: "/", PartitionPath: "rootfs"}, {MountPoint: "/", PartitionPath: "/dev/vda1"}, } // for the GrowRootFS call to findRootDevicePath runner.AddCmdResult( "readlink -f /dev/vda1", fakesys.FakeCmdResult{Stdout: "/dev/vda1"}, ) // for the createEphemeralPartitionsOnRootDevice call to findRootDevicePath runner.AddCmdResult( "readlink -f /dev/vda1", fakesys.FakeCmdResult{Stdout: "/dev/vda1"}, ) diskManager.FakeRootDevicePartitioner.GetDeviceSizeInBytesSizes["/dev/vda"] = 1024 * 1024 * 1024 udev := boshudev.NewConcreteUdevDevice(runner, logger) linuxCdrom := boshcdrom.NewLinuxCdrom("/dev/sr0", udev, runner) linuxCdutil := boshcdrom.NewCdUtil(dirProvider.SettingsDir(), fs, linuxCdrom, logger) compressor := boshcmd.NewTarballCompressor(runner, fs) copier := boshcmd.NewCpCopier(runner, fs, logger) sigarCollector := boshsigar.NewSigarStatsCollector(&sigar.ConcreteSigar{}) vitalsService := boshvitals.NewService(sigarCollector, dirProvider) ipResolver := boship.NewResolver(boship.NetworkInterfaceToAddrsFunc) arping := bosharp.NewArping(runner, fs, logger, boshplatform.ArpIterations, boshplatform.ArpIterationDelay, boshplatform.ArpInterfaceCheckDelay) interfaceConfigurationCreator := boshnet.NewInterfaceConfigurationCreator(logger) interfaceAddrsProvider = &fakeip.FakeInterfaceAddressesProvider{} interfaceAddressesValidator := boship.NewInterfaceAddressesValidator(interfaceAddrsProvider) dnsValidator := boshnet.NewDNSValidator(fs) fs.WriteFileString("/etc/resolv.conf", "8.8.8.8 4.4.4.4") ubuntuNetManager := boshnet.NewUbuntuNetManager(fs, runner, ipResolver, interfaceConfigurationCreator, interfaceAddressesValidator, dnsValidator, arping, logger) ubuntuCertManager := boshcert.NewUbuntuCertManager(fs, runner, 1, logger) monitRetryable := boshplatform.NewMonitRetryable(runner) monitRetryStrategy := boshretry.NewAttemptRetryStrategy(10, 1*time.Second, monitRetryable, logger) devicePathResolver := devicepathresolver.NewIdentityDevicePathResolver() routesSearcher := boshnet.NewCmdRoutesSearcher(runner) defaultNetworkResolver = boshnet.NewDefaultNetworkResolver(routesSearcher, ipResolver) state, err := boshplatform.NewBootstrapState(fs, "/tmp/agent_state.json") Expect(err).NotTo(HaveOccurred()) platform = boshplatform.NewLinuxPlatform( fs, runner, sigarCollector, compressor, copier, dirProvider, vitalsService, linuxCdutil, diskManager, ubuntuNetManager, ubuntuCertManager, monitRetryStrategy, devicePathResolver, 500*time.Millisecond, state, linuxOptions, logger, defaultNetworkResolver, ) }) JustBeforeEach(func() { settingsPath := filepath.Join("bosh", "settings.json") var settings boshsettings.Settings json.Unmarshal([]byte(settingsJSON), &settings) settingsSource := fakeinf.FakeSettingsSource{ PublicKey: "123", SettingsValue: settings, } settingsService := boshsettings.NewService( platform.GetFs(), settingsPath, settingsSource, platform, logger, ) boot = NewBootstrap( platform, dirProvider, settingsService, logger, ) }) Context("when a single network configuration is provided, with a MAC address", func() { BeforeEach(func() { settingsJSON = `{ "networks": { "netA": { "default": ["dns", "gateway"], "ip": "2.2.2.2", "dns": [ "8.8.8.8", "4.4.4.4" ], "netmask": "255.255.255.0", "gateway": "2.2.2.0", "mac": "aa:bb:cc" } } }` }) Context("and no physical network interfaces exist", func() { Context("and a single virtual network interface exists", func() { BeforeEach(func() { stubInterfaces([][]string{[]string{"lo", "aa:bb:cc", "virtual"}}) }) It("raises an error", func() { err := boot.Run() Expect(err).To(HaveOccurred()) Expect(err.Error()).To(ContainSubstring("Number of network settings '1' is greater than the number of network devices '0")) }) }) }) Context("and a single physical network interface exists", func() { BeforeEach(func() { stubInterfaces([][]string{[]string{"eth0", "aa:bb:cc", "physical"}}) interfaceAddrsProvider.GetInterfaceAddresses = []boship.InterfaceAddress{ boship.NewSimpleInterfaceAddress("eth0", "2.2.2.2"), } }) It("succeeds", func() { err := boot.Run() Expect(err).NotTo(HaveOccurred()) }) }) Context("and extra physical network interfaces exist", func() { BeforeEach(func() { stubInterfaces([][]string{[]string{"eth0", "aa:bb:cc", "physical"}, []string{"eth1", "aa:bb:dd", "physical"}}) interfaceAddrsProvider.GetInterfaceAddresses = []boship.InterfaceAddress{ boship.NewSimpleInterfaceAddress("eth0", "2.2.2.2"), } }) It("succeeds", func() { err := boot.Run() Expect(err).NotTo(HaveOccurred()) }) }) Context("and extra virtual network interfaces exist", func() { BeforeEach(func() { stubInterfaces([][]string{[]string{"eth0", "aa:bb:cc", "physical"}, []string{"lo", "aa:bb:ee", "virtual"}}) interfaceAddrsProvider.GetInterfaceAddresses = []boship.InterfaceAddress{ boship.NewSimpleInterfaceAddress("eth0", "2.2.2.2"), } }) It("succeeds", func() { err := boot.Run() Expect(err).ToNot(HaveOccurred()) }) }) }) Context("when a single network configuration is provided, without a MAC address", func() { BeforeEach(func() { settingsJSON = `{ "networks": { "netA": { "default": ["dns", "gateway"], "ip": "2.2.2.2", "dns": [ "8.8.8.8", "4.4.4.4" ], "netmask": "255.255.255.0", "gateway": "2.2.2.0" } } }` }) Context("and no physical network interfaces exist", func() { Context("and a single virtual network interface exists", func() { BeforeEach(func() { stubInterfaces([][]string{[]string{"lo", "aa:bb:cc", "virtual"}}) }) It("raises an error", func() { err := boot.Run() Expect(err).To(HaveOccurred()) Expect(err.Error()).To(ContainSubstring("Number of network settings '1' is greater than the number of network devices '0")) }) }) }) Context("and a single physical network interface exists", func() { BeforeEach(func() { stubInterfaces([][]string{[]string{"eth0", "aa:bb:cc", "physical"}}) interfaceAddrsProvider.GetInterfaceAddresses = []boship.InterfaceAddress{ boship.NewSimpleInterfaceAddress("eth0", "2.2.2.2"), } }) It("succeeds", func() { err := boot.Run() Expect(err).NotTo(HaveOccurred()) }) }) Context("and extra physical network interfaces exist", func() { BeforeEach(func() { stubInterfaces([][]string{[]string{"eth0", "aa:bb:cc", "physical"}, []string{"eth1", "aa:bb:dd", "physical"}}) interfaceAddrsProvider.GetInterfaceAddresses = []boship.InterfaceAddress{ boship.NewSimpleInterfaceAddress("eth0", "2.2.2.2"), } }) It("succeeds", func() { err := boot.Run() Expect(err).NotTo(HaveOccurred()) }) }) Context("and an extra virtual network interface exists", func() { BeforeEach(func() { stubInterfaces([][]string{[]string{"eth0", "aa:bb:cc", "physical"}, []string{"lo", "aa:bb:dd", "virtual"}}) interfaceAddrsProvider.GetInterfaceAddresses = []boship.InterfaceAddress{ boship.NewSimpleInterfaceAddress("eth0", "2.2.2.2"), } }) It("succeeds", func() { err := boot.Run() Expect(err).NotTo(HaveOccurred()) }) }) }) Context("when two network configurations are provided", func() { BeforeEach(func() { settingsJSON = `{ "networks": { "netA": { "default": ["dns", "gateway"], "ip": "2.2.2.2", "dns": [ "8.8.8.8", "4.4.4.4" ], "netmask": "255.255.255.0", "gateway": "2.2.2.0", "mac": "aa:bb:cc" }, "netB": { "default": ["dns", "gateway"], "ip": "3.3.3.3", "dns": [ "8.8.8.8", "4.4.4.4" ], "netmask": "255.255.255.0", "gateway": "3.3.3.0", "mac": "" } } }` }) Context("and a single physical network interface exists", func() { BeforeEach(func() { stubInterfaces([][]string{[]string{"eth0", "aa:bb:cc", "physical"}}) }) It("raises an error", func() { err := boot.Run() Expect(err).To(HaveOccurred()) Expect(err.Error()).To(ContainSubstring("Number of network settings '2' is greater than the number of network devices '1")) }) }) Context("and two physical network interfaces with matching MAC addresses exist", func() { BeforeEach(func() { stubInterfaces([][]string{[]string{"eth0", "aa:bb:cc", "physical"}, []string{"eth1", "aa:bb:dd", "physical"}}) interfaceAddrsProvider.GetInterfaceAddresses = []boship.InterfaceAddress{ boship.NewSimpleInterfaceAddress("eth0", "2.2.2.2"), boship.NewSimpleInterfaceAddress("eth1", "3.3.3.3"), } }) It("succeeds", func() { err := boot.Run() Expect(err).ToNot(HaveOccurred()) }) }) }) }) }) }
fakenotif "github.com/cloudfoundry/bosh-agent/notification/fakes" fakeplatform "github.com/cloudfoundry/bosh-agent/platform/fakes" fakesettings "github.com/cloudfoundry/bosh-agent/settings/fakes" fakeblobstore "github.com/cloudfoundry/bosh-utils/blobstore/fakes" ) //go:generate counterfeiter -o fakes/fake_clock.go ../../vendor/github.com/pivotal-golang/clock Clock var _ = Describe("concreteFactory", func() { var ( settingsService *fakesettings.FakeSettingsService platform *fakeplatform.FakePlatform blobstore *fakeblobstore.FakeBlobstore taskService *faketask.FakeService notifier *fakenotif.FakeNotifier applier *fakeappl.FakeApplier compiler *fakecomp.FakeCompiler jobSupervisor *fakejobsuper.FakeJobSupervisor specService *fakeas.FakeV1Service jobScriptProvider boshscript.JobScriptProvider factory Factory logger boshlog.Logger ) BeforeEach(func() { settingsService = &fakesettings.FakeSettingsService{} platform = fakeplatform.NewFakePlatform() blobstore = &fakeblobstore.FakeBlobstore{} taskService = &faketask.FakeService{} notifier = fakenotif.NewFakeNotifier() applier = fakeappl.NewFakeApplier() compiler = fakecomp.NewFakeCompiler()
import ( "errors" . "github.com/onsi/ginkgo" . "github.com/onsi/gomega" . "github.com/cloudfoundry/bosh-agent/agent/action" fakeplatform "github.com/cloudfoundry/bosh-agent/platform/fakes" fakesettings "github.com/cloudfoundry/bosh-agent/settings/fakes" ) var _ = Describe("prepareConfigureNetworks", func() { var ( action PrepareConfigureNetworksAction platform *fakeplatform.FakePlatform settingsService *fakesettings.FakeSettingsService ) BeforeEach(func() { platform = fakeplatform.NewFakePlatform() settingsService = &fakesettings.FakeSettingsService{} action = NewPrepareConfigureNetworks(platform, settingsService) }) AssertActionIsNotAsynchronous(action) AssertActionIsNotPersistent(action) AssertActionIsLoggable(action) AssertActionIsNotResumable(action) AssertActionIsNotCancelable(action)
. "github.com/cloudfoundry/bosh-agent/agent/action" boshsettings "github.com/cloudfoundry/bosh-agent/settings" fakelogger "github.com/cloudfoundry/bosh-agent/logger/fakes" fakeplatform "github.com/cloudfoundry/bosh-agent/platform/fakes" fakesettings "github.com/cloudfoundry/bosh-agent/settings/fakes" fakeblobstore "github.com/cloudfoundry/bosh-utils/blobstore/fakes" fakesys "github.com/cloudfoundry/bosh-utils/system/fakes" ) var _ = Describe("SyncDNS", func() { var ( syncDNS SyncDNS fakeBlobstore *fakeblobstore.FakeBlobstore fakeSettingsService *fakesettings.FakeSettingsService fakePlatform *fakeplatform.FakePlatform fakeFileSystem *fakesys.FakeFileSystem logger *fakelogger.FakeLogger ) BeforeEach(func() { logger = &fakelogger.FakeLogger{} fakeBlobstore = fakeblobstore.NewFakeBlobstore() fakeSettingsService = &fakesettings.FakeSettingsService{} fakePlatform = fakeplatform.NewFakePlatform() fakeFileSystem = fakePlatform.GetFs().(*fakesys.FakeFileSystem) syncDNS = NewSyncDNS(fakeBlobstore, fakeSettingsService, fakePlatform, logger) }) It("returns IsAsynchronous false", func() {
fakejobsuper "github.com/cloudfoundry/bosh-agent/jobsupervisor/fakes" fakenotif "github.com/cloudfoundry/bosh-agent/notification/fakes" fakeplatform "github.com/cloudfoundry/bosh-agent/platform/fakes" boshntp "github.com/cloudfoundry/bosh-agent/platform/ntp" fakesettings "github.com/cloudfoundry/bosh-agent/settings/fakes" ) var _ = Describe("concreteFactory", func() { var ( settingsService *fakesettings.FakeSettingsService platform *fakeplatform.FakePlatform blobstore *fakeblobstore.FakeBlobstore taskService *faketask.FakeService notifier *fakenotif.FakeNotifier applier *fakeappl.FakeApplier compiler *fakecomp.FakeCompiler jobSupervisor *fakejobsuper.FakeJobSupervisor specService *fakeas.FakeV1Service drainScriptProvider boshdrain.ScriptProvider jobScriptProvider boshscript.JobScriptProvider factory Factory logger boshlog.Logger ) BeforeEach(func() { settingsService = &fakesettings.FakeSettingsService{} platform = fakeplatform.NewFakePlatform() blobstore = &fakeblobstore.FakeBlobstore{} taskService = &faketask.FakeService{} notifier = fakenotif.NewFakeNotifier() applier = fakeappl.NewFakeApplier()
func describeConfigDriveMetadataService() { var ( metadataService MetadataService resolver *fakeinf.FakeDNSResolver platform *fakeplatform.FakePlatform logger boshlog.Logger ) updateMetadata := func(metadataContents MetadataContentsType) { metadataJSON, err := json.Marshal(metadataContents) Expect(err).ToNot(HaveOccurred()) platform.SetGetFilesContentsFromDisk("/fake-disk-path-1/fake-metadata-path", metadataJSON, nil) Expect(metadataService.IsAvailable()).To(BeTrue()) } updateUserdata := func(userdataContents string) { platform.SetGetFilesContentsFromDisk("/fake-disk-path-1/fake-userdata-path", []byte(userdataContents), nil) Expect(metadataService.IsAvailable()).To(BeTrue()) } BeforeEach(func() { resolver = &fakeinf.FakeDNSResolver{} platform = fakeplatform.NewFakePlatform() logger = boshlog.NewLogger(boshlog.LevelNone) diskPaths := []string{ "/fake-disk-path-1", "/fake-disk-path-2", } metadataService = NewConfigDriveMetadataService( resolver, platform, diskPaths, "fake-metadata-path", "fake-userdata-path", logger, ) userdataContents := fmt.Sprintf(`{"server":{"name":"fake-server-name"},"registry":{"endpoint":"fake-registry-endpoint"}}`) platform.SetGetFilesContentsFromDisk("/fake-disk-path-1/fake-userdata-path", []byte(userdataContents), nil) metadata := MetadataContentsType{ PublicKeys: map[string]PublicKeyType{ "0": PublicKeyType{ "openssh-key": "fake-openssh-key", }, }, InstanceID: "fake-instance-id", } updateMetadata(metadata) }) Describe("GetNetworks", func() { It("returns the network settings", func() { userdataContents := ` { "networks": { "network_1": {"type": "manual", "ip": "1.2.3.4", "netmask": "2.3.4.5", "gateway": "3.4.5.6", "default": ["dns"], "dns": ["8.8.8.8"], "mac": "fake-mac-address-1"}, "network_2": {"type": "dynamic", "default": ["dns"], "dns": ["8.8.8.8"], "mac": "fake-mac-address-2"} } }` updateUserdata(userdataContents) networks, err := metadataService.GetNetworks() Expect(err).ToNot(HaveOccurred()) Expect(networks).To(Equal(boshsettings.Networks{ "network_1": boshsettings.Network{ Type: "manual", IP: "1.2.3.4", Netmask: "2.3.4.5", Gateway: "3.4.5.6", Default: []string{"dns"}, DNS: []string{"8.8.8.8"}, Mac: "fake-mac-address-1", }, "network_2": boshsettings.Network{ Type: "dynamic", Default: []string{"dns"}, DNS: []string{"8.8.8.8"}, Mac: "fake-mac-address-2", }, })) }) It("returns a nil Networks if the settings are missing (from an old CPI version)", func() { userdataContents := `{}` updateUserdata(userdataContents) networks, err := metadataService.GetNetworks() Expect(err).ToNot(HaveOccurred()) Expect(networks).To(BeNil()) }) }) Describe("IsAvailable", func() { It("return true when it can load successfully", func() { Expect(metadataService.IsAvailable()).To(BeTrue()) }) It("returns an error if it fails to read meta-data.json from disk", func() { platform.SetGetFilesContentsFromDisk("/fake-disk-path-1/fake-metadata-path", []byte{}, errors.New("fake-read-disk-error")) Expect(metadataService.IsAvailable()).To(BeFalse()) }) It("tries to load meta-data.json from potential disk locations", func() { platform.SetGetFilesContentsFromDisk("/fake-disk-path-1/fake-metadata-path", []byte{}, errors.New("fake-read-disk-error")) Expect(metadataService.IsAvailable()).To(BeFalse()) Expect(platform.GetFileContentsFromDiskDiskPaths).To(ContainElement("/fake-disk-path-1")) Expect(platform.GetFileContentsFromDiskDiskPaths).To(ContainElement("/fake-disk-path-2")) }) It("returns an error if it fails to parse meta-data.json contents", func() { platform.SetGetFilesContentsFromDisk("/fake-disk-path-1/fake-metadata-path", []byte("broken"), nil) Expect(metadataService.IsAvailable()).To(BeFalse()) }) It("returns an error if it fails to read user_data from disk", func() { platform.SetGetFilesContentsFromDisk("/fake-disk-path-1/fake-userdata-path", []byte{}, errors.New("fake-read-disk-error")) Expect(metadataService.IsAvailable()).To(BeFalse()) }) It("returns an error if it fails to parse user_data contents", func() { platform.SetGetFilesContentsFromDisk("/fake-disk-path-1/fake-userdata-path", []byte("broken"), nil) Expect(metadataService.IsAvailable()).To(BeFalse()) }) Context("when disk paths are not given", func() { It("returns false", func() { metadataService = NewConfigDriveMetadataService( resolver, platform, []string{}, "fake-metadata-path", "fake-userdata-path", logger, ) Expect(metadataService.IsAvailable()).To(BeFalse()) }) }) }) Describe("GetPublicKey", func() { It("returns public key", func() { value, err := metadataService.GetPublicKey() Expect(err).ToNot(HaveOccurred()) Expect(value).To(Equal("fake-openssh-key")) }) It("returns an error if it fails to get ssh key", func() { updateMetadata(MetadataContentsType{}) value, err := metadataService.GetPublicKey() Expect(err).To(HaveOccurred()) Expect(err.Error()).To(ContainSubstring("Failed to load openssh-key from config drive metadata service")) Expect(value).To(Equal("")) }) }) Describe("GetInstanceID", func() { It("returns instance id", func() { value, err := metadataService.GetInstanceID() Expect(err).ToNot(HaveOccurred()) Expect(value).To(Equal("fake-instance-id")) }) It("returns an error if it fails to get instance id", func() { updateMetadata(MetadataContentsType{}) value, err := metadataService.GetInstanceID() Expect(err).To(HaveOccurred()) Expect(err.Error()).To(ContainSubstring("Failed to load instance-id from config drive metadata service")) Expect(value).To(Equal("")) }) }) Describe("GetServerName", func() { It("returns server name", func() { value, err := metadataService.GetServerName() Expect(err).ToNot(HaveOccurred()) Expect(value).To(Equal("fake-server-name")) }) It("returns an error if it fails to get server name", func() { updateUserdata("{}") value, err := metadataService.GetServerName() Expect(err).To(HaveOccurred()) Expect(err.Error()).To(ContainSubstring("Failed to load server name from config drive metadata service")) Expect(value).To(Equal("")) }) }) Describe("GetRegistryEndpoint", func() { It("returns an error if it fails to get registry endpoint", func() { updateUserdata("{}") value, err := metadataService.GetRegistryEndpoint() Expect(err).To(HaveOccurred()) Expect(err.Error()).To(ContainSubstring("Failed to load registry endpoint from config drive metadata service")) Expect(value).To(Equal("")) }) Context("when user_data does not contain a dns server", func() { It("returns registry endpoint", func() { value, err := metadataService.GetRegistryEndpoint() Expect(err).ToNot(HaveOccurred()) Expect(value).To(Equal("fake-registry-endpoint")) }) }) Context("when user_data contains a dns server", func() { BeforeEach(func() { userdataContents := fmt.Sprintf( `{"server":{"name":"%s"},"registry":{"endpoint":"%s"},"dns":{"nameserver":["%s"]}}`, "fake-server-name", "http://fake-registry.com", "fake-dns-server-ip", ) updateUserdata(userdataContents) }) Context("when registry endpoint is successfully resolved", func() { BeforeEach(func() { resolver.RegisterRecord(fakeinf.FakeDNSRecord{ DNSServers: []string{"fake-dns-server-ip"}, Host: "http://fake-registry.com", IP: "http://fake-registry-ip", }) }) It("returns the successfully resolved registry endpoint", func() { endpoint, err := metadataService.GetRegistryEndpoint() Expect(err).ToNot(HaveOccurred()) Expect(endpoint).To(Equal("http://fake-registry-ip")) }) }) Context("when registry endpoint is not successfully resolved", func() { BeforeEach(func() { resolver.LookupHostErr = errors.New("fake-lookup-host-err") }) It("returns error because it failed to resolve registry endpoint", func() { endpoint, err := metadataService.GetRegistryEndpoint() Expect(err).To(HaveOccurred()) Expect(err.Error()).To(ContainSubstring("fake-lookup-host-err")) Expect(endpoint).To(BeEmpty()) }) }) }) }) }