Golang bosh-logger.NewLogger类(方法)实例源码

func init() {
	Describe("Testing with Ginkgo", func() {
		It("running a successful task", func() {
			testRunningTask(GinkgoT(), TaskStateDone, 123, nil)
		})
		It("running a failing task", func() {

			testRunningTask(GinkgoT(), TaskStateFailed, nil, errors.New("Oops"))
		})
		It("start task generates task id", func() {

			var taskFunc = func() (value interface{}, err error) {
				return
			}

			service := NewAsyncTaskService(boshlog.NewLogger(boshlog.LEVEL_NONE))

			for expectedTaskId := 1; expectedTaskId < 20; expectedTaskId++ {
				task := service.StartTask(taskFunc)
				assert.Equal(GinkgoT(), fmt.Sprintf("%d", expectedTaskId), task.Id)
			}
		})
		It("processing many tasks simultaneously", func() {

			taskFunc := func() (value interface{}, err error) {
				time.Sleep(10 * time.Millisecond)
				return
			}

			service := NewAsyncTaskService(boshlog.NewLogger(boshlog.LEVEL_NONE))
			ids := []string{}

			for id := 1; id < 200; id++ {
				ids = append(ids, fmt.Sprintf("%d", id))
				go service.StartTask(taskFunc)
			}

			for {
				allDone := true

				for _, id := range ids {
					task, _ := service.FindTask(id)
					if task.State != TaskStateDone {
						allDone = false
						break
					}
				}

				if allDone {
					break
				}

				time.Sleep(200 * time.Millisecond)
			}
		})
	})
}

func getActionDispatcherDependencies() (logger boshlog.Logger, taskService *faketask.FakeService, actionFactory *fakeaction.FakeFactory, actionRunner *fakeaction.FakeRunner) {
	logger = boshlog.NewLogger(boshlog.LEVEL_NONE)
	taskService = &faketask.FakeService{}
	actionFactory = &fakeaction.FakeFactory{}
	actionRunner = &fakeaction.FakeRunner{}
	return
}

func getNewProvider() (provider provider) {
	dirProvider := boshsys.NewDirectoriesProvider("/var/vcap")
	fs := fakefs.NewFakeFileSystem()

	provider = NewProvider(boshlog.NewLogger(boshlog.LEVEL_NONE), fs, dirProvider)
	return
}

func buildAlertBuilder() (settingsService *fakesettings.FakeSettingsService, builder Builder) {
	logger := boshlog.NewLogger(boshlog.LEVEL_NONE)
	settingsService = &fakesettings.FakeSettingsService{}

	builder = NewBuilder(settingsService, logger)
	return
}

func TestGetReturnsAnAwsInfrastructure(t *testing.T) {
	provider := NewProvider(boshlog.NewLogger(boshlog.LEVEL_NONE))
	inf, err := provider.Get("aws")

	assert.NoError(t, err)
	assert.IsType(t, awsInfrastructure{}, inf)
}

func TestProcessingManyTasksSimultaneously(t *testing.T) {
	taskFunc := func() (value interface{}, err error) {
		time.Sleep(10 * time.Millisecond)
		return
	}

	service := NewAsyncTaskService(boshlog.NewLogger(boshlog.LEVEL_NONE))
	ids := []string{}

	for id := 1; id < 200; id++ {
		ids = append(ids, fmt.Sprintf("%d", id))
		go service.StartTask(taskFunc)
	}

	for {
		allDone := true

		for _, id := range ids {
			task, _ := service.FindTask(id)
			if task.State != TaskStateDone {
				allDone = false
				break
			}
		}

		if allDone {
			break
		}

		time.Sleep(200 * time.Millisecond)
	}
}

func testRunningTask(t *testing.T, expectedState TaskState, withValue interface{}, withErr error) {
	service := NewAsyncTaskService(boshlog.NewLogger(boshlog.LEVEL_NONE))

	taskIsFinished := false

	task := service.StartTask(func() (value interface{}, err error) {
		for !taskIsFinished {
		}
		value = withValue
		err = withErr
		return
	})

	assert.Equal(t, "1", task.Id)
	assert.Equal(t, "running", task.State)

	taskIsFinished = true

	updatedTask, _ := service.FindTask(task.Id)

	for updatedTask.State != expectedState {
		time.Sleep(time.Nanosecond)
		updatedTask, _ = service.FindTask(task.Id)
	}
	assert.Equal(t, expectedState, updatedTask.State)
	assert.Equal(t, withValue, updatedTask.Value)

	if withErr != nil {
		assert.Equal(t, withErr.Error(), updatedTask.Error)
	} else {
		assert.Equal(t, "", updatedTask.Error)
	}
}

func TestHandlerProviderGetReturnsAnErrorIfNotSupported(t *testing.T) {
	settings := &fakesettings.FakeSettingsService{MbusUrl: "foo://0.0.0.0"}
	logger := boshlog.NewLogger(boshlog.LEVEL_NONE)
	provider := NewHandlerProvider(settings, logger)
	_, err := provider.Get()

	assert.Error(t, err)
}

func buildMonit() (fs *fakesys.FakeFileSystem, runner *fakesys.FakeCmdRunner, client *fakemonit.FakeMonitClient, monit monit) {
	fs = &fakesys.FakeFileSystem{}
	runner = &fakesys.FakeCmdRunner{}
	client = fakemonit.NewFakeMonitClient()
	logger := boshlog.NewLogger(boshlog.LEVEL_NONE)
	monit = NewMonit(fs, runner, client, logger)
	return
}

func buildProvider(mbusUrl string) (provider mbusHandlerProvider, platform *fakeplatform.FakePlatform, dirProvider boshdir.DirectoriesProvider) {
	settings := &fakesettings.FakeSettingsService{MbusUrl: mbusUrl}
	logger := boshlog.NewLogger(boshlog.LEVEL_NONE)
	provider = NewHandlerProvider(settings, logger)

	platform = fakeplatform.NewFakePlatform()
	dirProvider = boshdir.NewDirectoriesProvider("/var/vcap")
	return
}

func buildProvider(mbusUrl string) (deps providerDeps, provider MbusHandlerProvider) {
	deps.settings = &fakesettings.FakeSettingsService{MbusUrl: mbusUrl}
	deps.logger = boshlog.NewLogger(boshlog.LEVEL_NONE)
	provider = NewHandlerProvider(deps.settings, deps.logger)

	deps.platform = fakeplatform.NewFakePlatform()
	deps.dirProvider = boshdir.NewDirectoriesProvider("/var/vcap")
	return
}

func TestHandlerProviderGetReturnsNatsHandler(t *testing.T) {
	settings := &fakesettings.FakeSettingsService{MbusUrl: "nats://0.0.0.0"}

	logger := boshlog.NewLogger(boshlog.LEVEL_NONE)
	provider := NewHandlerProvider(settings, logger)
	handler, err := provider.Get()

	assert.NoError(t, err)
	assert.IsType(t, natsHandler{}, handler)
}

func TestStartTaskGeneratesTaskId(t *testing.T) {
	var taskFunc = func() (value interface{}, err error) {
		return
	}

	service := NewAsyncTaskService(boshlog.NewLogger(boshlog.LEVEL_NONE))

	for expectedTaskId := 1; expectedTaskId < 20; expectedTaskId++ {
		task := service.StartTask(taskFunc)
		assert.Equal(t, fmt.Sprintf("%d", expectedTaskId), task.Id)
	}
}

func init() {
	Describe("Testing with Ginkgo", func() {
		It("services in group returns slice of service", func() {

			expectedServices := []Service{
				{
					Monitored: true,
					Status:    "running",
				},
				{
					Monitored: false,
					Status:    "unknown",
				},
				{
					Monitored: true,
					Status:    "starting",
				},
				{
					Monitored: true,
					Status:    "failing",
				},
			}
			monitStatusFilePath, _ := filepath.Abs("../../../../fixtures/monit_status_with_multiple_services.xml")
			Expect(monitStatusFilePath).ToNot(BeNil())

			file, err := os.Open(monitStatusFilePath)
			Expect(err).ToNot(HaveOccurred())
			defer file.Close()

			handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
				io.Copy(w, file)
				Expect(r.Method).To(Equal("GET"))
				Expect(r.URL.Path).To(Equal("/_status2"))
				Expect(r.URL.Query().Get("format")).To(Equal("xml"))
			})
			ts := httptest.NewServer(handler)
			defer ts.Close()

			logger := boshlog.NewLogger(boshlog.LEVEL_NONE)
			client := NewHttpClient(ts.Listener.Addr().String(), "fake-user", "fake-pass", http.DefaultClient, 1*time.Millisecond, logger)

			status, err := client.Status()
			Expect(err).ToNot(HaveOccurred())

			services := status.ServicesInGroup("vcap")
			Expect(len(expectedServices)).To(Equal(len(services)))

			for i, expectedService := range expectedServices {
				Expect(expectedService).To(Equal(services[i]))
			}
		})
	})
}

func buildMonitJobSupervisor() (deps monitJobSupDeps, monit monitJobSupervisor) {
	deps = monitJobSupDeps{
		fs:          &fakesys.FakeFileSystem{},
		runner:      &fakesys.FakeCmdRunner{},
		client:      fakemonit.NewFakeMonitClient(),
		logger:      boshlog.NewLogger(boshlog.LEVEL_NONE),
		dirProvider: boshdir.NewDirectoriesProvider("/var/vcap"),
	}

	monit = NewMonitJobSupervisor(deps.fs, deps.runner, deps.client, deps.logger, deps.dirProvider)
	return
}

func main() {
	logger := boshlog.NewLogger(boshlog.LEVEL_DEBUG)
	defer logger.HandlePanic("Main")

	app := boshapp.New(logger)
	err := app.Run(os.Args)

	if err != nil {
		logger.Error("Main", err.Error())
		os.Exit(1)
	}
}

func buildAgent() (deps agentDeps, agent Agent) {
	deps = agentDeps{
		logger:           boshlog.NewLogger(boshlog.LEVEL_NONE),
		handler:          &fakembus.FakeHandler{},
		platform:         fakeplatform.NewFakePlatform(),
		actionDispatcher: &FakeActionDispatcher{},
		alertBuilder:     fakealert.NewFakeAlertBuilder(),
		jobSupervisor:    fakejobsup.NewFakeJobSupervisor(),
	}

	agent = New(deps.logger, deps.handler, deps.platform, deps.actionDispatcher, deps.alertBuilder, deps.jobSupervisor, 5*time.Millisecond)
	return
}

func main() {
	logger := boshlog.NewLogger(boshlog.LEVEL_DEBUG)
	defer logger.HandlePanic("Main")
	logger.Debug("main", "Starting agent")

	app := boshapp.New(logger)
	app.Setup(os.Args)
	err := app.Run()

	if err != nil {
		logger.Error("Main", err.Error())
		os.Exit(1)
	}
}

func startServer() (serverURL string, handler HttpsHandler, fs *fakesys.FakeFileSystem) {
	serverURL = "https://user:[email protected]:6900"
	mbusUrl, _ := url.Parse(serverURL)
	logger := boshlog.NewLogger(boshlog.LEVEL_NONE)
	fs = fakesys.NewFakeFileSystem()
	dirProvider := boshdir.NewDirectoriesProvider("/var/vcap")
	handler = NewHttpsHandler(mbusUrl, logger, fs, dirProvider)

	go handler.Start(func(req boshhandler.Request) (resp boshhandler.Response) {
		receivedRequest = req
		return boshhandler.NewValueResponse("expected value")
	})
	return
}

func startServer() (serverURL string) {
	port := getHttpsHandlerPort()
	serverURL = fmt.Sprintf("https://user:[email protected]:%d", port)

	mbusUrl, _ := url.Parse(serverURL)
	logger := boshlog.NewLogger(boshlog.LEVEL_NONE)
	handler := newHttpsHandler(mbusUrl, logger)

	go handler.Start(func(req Request) (resp Response) {
		receivedRequest = req
		return NewValueResponse("expected value")
	})
	defer handler.Stop()
	return
}