Exemple #1
0
func (a agent) runMbusHandler(errChan chan error) {
	handlerFunc := func(req boshmbus.Request) (resp boshmbus.Response) {
		switch req.Method {
		case "get_task", "ping", "get_state", "ssh", "start":
			action := a.actionFactory.Create(req.Method)
			value, err := action.Run(req.GetPayload())

			if err != nil {
				err = bosherr.WrapError(err, "Action Failed %s", req.Method)
				resp = boshmbus.NewExceptionResponse(err.Error())
				boshlog.Error("Agent", err.Error())
				return
			}
			resp = boshmbus.NewValueResponse(value)
		case "apply", "fetch_logs", "stop", "drain":
			task := a.taskService.StartTask(func() (value interface{}, err error) {
				action := a.actionFactory.Create(req.Method)
				value, err = action.Run(req.GetPayload())
				return
			})

			resp = boshmbus.NewValueResponse(TaskValue{
				AgentTaskId: task.Id,
				State:       string(task.State),
			})
		default:
			resp = boshmbus.NewExceptionResponse("unknown message %s", req.Method)
			boshlog.Error("Agent", "Unknown action %s", req.Method)
		}

		return
	}
	errChan <- a.mbusHandler.Run(handlerFunc)
}
Exemple #2
0
func TestError(t *testing.T) {
	_, stderr := captureOutputs(func() {
		logger := NewLogger(LEVEL_ERROR)
		logger.Error("TAG", "some %s info to log", "awesome")
	})

	matcher, _ := regexp.Compile(expectedLogFormat("TAG", "ERROR - some awesome info to log"))
	assert.True(t, matcher.Match(stderr))
}
Exemple #3
0
func main() {
	app := boshapp.New()
	err := app.Run(os.Args)

	if err != nil {
		logger.Error("Main", err.Error())
		os.Exit(1)
	}
}
Exemple #4
0
func TestLogLevelError(t *testing.T) {
	stdout, stderr := captureOutputs(func() {
		logger := NewLogger(LEVEL_ERROR)
		logger.Debug("DEBUG", "some debug log")
		logger.Info("INFO", "some info log")
		logger.Error("ERROR", "some error log")
	})

	assert.NotContains(t, string(stdout), "DEBUG")
	assert.NotContains(t, string(stdout), "INFO")
	assert.Contains(t, string(stderr), "ERROR")
}
Exemple #5
0
func (service asyncTaskService) processTasks() {
	for {
		task := <-service.taskChan

		value, err := task.taskFunc()

		if err != nil {
			task.Error = err.Error()
			task.State = TaskStateFailed

			boshlog.Error("Task Service", "Failed processing task #%s got: %s", task.Id, err.Error())
		} else {
			task.Value = value
			task.State = TaskStateDone
		}

		service.taskSem <- func() {
			service.currentTasks[task.Id] = task
		}
	}
}
	It("debug with details", func() {
		stdout, _ := captureOutputs(func() {
			logger := NewLogger(LevelDebug)
			logger.DebugWithDetails("TAG", "some info to log", "awesome")
		})

		matcher, _ := regexp.Compile(expectedLogFormat("TAG", "DEBUG - some info to log"))
		Expect(matcher.Match(stdout)).To(BeTrue())

		assert.Contains(GinkgoT(), string(stdout), "\n********************\nawesome\n********************")
	})

	It("error", func() {
		_, stderr := captureOutputs(func() {
			logger := NewLogger(LevelError)
			logger.Error("TAG", "some %s info to log", "awesome")
		})

		matcher, _ := regexp.Compile(expectedLogFormat("TAG", "ERROR - some awesome info to log"))
		Expect(matcher.Match(stderr)).To(BeTrue())
	})

	It("error with details", func() {
		_, stderr := captureOutputs(func() {
			logger := NewLogger(LevelError)
			logger.ErrorWithDetails("TAG", "some error to log", "awesome")
		})

		matcher, _ := regexp.Compile(expectedLogFormat("TAG", "ERROR - some error to log"))
		Expect(matcher.Match(stderr)).To(BeTrue())
Exemple #7
0
func init() {
	Describe("Testing with Ginkgo", func() {
		It("info", func() {
			stdout, _ := captureOutputs(func() {
				logger := NewLogger(LEVEL_INFO)
				logger.Info("TAG", "some %s info to log", "awesome")
			})

			matcher, _ := regexp.Compile(expectedLogFormat("TAG", "INFO - some awesome info to log"))
			assert.True(GinkgoT(), matcher.Match(stdout))
		})
		It("debug", func() {

			stdout, _ := captureOutputs(func() {
				logger := NewLogger(LEVEL_DEBUG)
				logger.Debug("TAG", "some %s info to log", "awesome")
			})

			matcher, _ := regexp.Compile(expectedLogFormat("TAG", "DEBUG - some awesome info to log"))
			assert.True(GinkgoT(), matcher.Match(stdout))
		})
		It("debug with details", func() {

			stdout, _ := captureOutputs(func() {
				logger := NewLogger(LEVEL_DEBUG)
				logger.DebugWithDetails("TAG", "some info to log", "awesome")
			})

			matcher, _ := regexp.Compile(expectedLogFormat("TAG", "DEBUG - some info to log"))
			assert.True(GinkgoT(), matcher.Match(stdout))

			assert.Contains(GinkgoT(), string(stdout), "\n********************\nawesome\n********************")
		})
		It("error", func() {

			_, stderr := captureOutputs(func() {
				logger := NewLogger(LEVEL_ERROR)
				logger.Error("TAG", "some %s info to log", "awesome")
			})

			matcher, _ := regexp.Compile(expectedLogFormat("TAG", "ERROR - some awesome info to log"))
			assert.True(GinkgoT(), matcher.Match(stderr))
		})
		It("error with details", func() {

			_, stderr := captureOutputs(func() {
				logger := NewLogger(LEVEL_ERROR)
				logger.ErrorWithDetails("TAG", "some error to log", "awesome")
			})

			matcher, _ := regexp.Compile(expectedLogFormat("TAG", "ERROR - some error to log"))
			assert.True(GinkgoT(), matcher.Match(stderr))

			assert.Contains(GinkgoT(), string(stderr), "\n********************\nawesome\n********************")
		})
		It("log level debug", func() {

			stdout, stderr := captureOutputs(func() {
				logger := NewLogger(LEVEL_DEBUG)
				logger.Debug("DEBUG", "some debug log")
				logger.Info("INFO", "some info log")
				logger.Error("ERROR", "some error log")
			})

			assert.Contains(GinkgoT(), string(stdout), "DEBUG")
			assert.Contains(GinkgoT(), string(stdout), "INFO")
			assert.Contains(GinkgoT(), string(stderr), "ERROR")
		})
		It("log level info", func() {

			stdout, stderr := captureOutputs(func() {
				logger := NewLogger(LEVEL_INFO)
				logger.Debug("DEBUG", "some debug log")
				logger.Info("INFO", "some info log")
				logger.Error("ERROR", "some error log")
			})

			assert.NotContains(GinkgoT(), string(stdout), "DEBUG")
			assert.Contains(GinkgoT(), string(stdout), "INFO")
			assert.Contains(GinkgoT(), string(stderr), "ERROR")
		})
		It("log level error", func() {

			stdout, stderr := captureOutputs(func() {
				logger := NewLogger(LEVEL_ERROR)
				logger.Debug("DEBUG", "some debug log")
				logger.Info("INFO", "some info log")
				logger.Error("ERROR", "some error log")
			})

			assert.NotContains(GinkgoT(), string(stdout), "DEBUG")
			assert.NotContains(GinkgoT(), string(stdout), "INFO")
			assert.Contains(GinkgoT(), string(stderr), "ERROR")
		})
	})
}