func PerformHandlerWithJSON(rawJSON []byte, handler Func, maxResponseLength int, logger boshlog.Logger) ([]byte, Request, error) {
	var request Request

	err := json.Unmarshal(rawJSON, &request)
	if err != nil {
		return []byte{}, request, bosherr.WrapError(err, "Unmarshalling JSON payload")
	}

	request.Payload = rawJSON

	logger.Info(mbusHandlerLogTag, "Received request with action %s", request.Method)
	logger.DebugWithDetails(mbusHandlerLogTag, "Payload", request.Payload)

	response := handler(request)
	if response == nil {
		logger.Info(mbusHandlerLogTag, "Nil response returned from handler")
		return []byte{}, request, nil
	}

	respJSON, err := marshalResponse(response, maxResponseLength, logger)
	if err != nil {
		return respJSON, request, err
	}

	logger.Info(mbusHandlerLogTag, "Responding")
	logger.DebugWithDetails(mbusHandlerLogTag, "Payload", respJSON)

	return respJSON, request, nil
}
Exemple #2
0
func runAgent(logger logger.Logger) chan error {
	errCh := make(chan error, 1)
	go func() {
		defer logger.HandlePanic("Main")

		logger.Debug(mainLogTag, "Starting agent")

		fs := boshsys.NewOsFileSystem(logger)
		app := boshapp.New(logger, fs)

		err := app.Setup(os.Args)
		if err != nil {
			logger.Error(mainLogTag, "App setup %s", err.Error())
			errCh <- err
			return
		}

		err = app.Run()
		if err != nil {
			logger.Error(mainLogTag, "App run %s", err.Error())
			errCh <- err
			return
		}
	}()
	return errCh
}
Exemple #3
0
func (i *installation) stopRegistryNice(logger boshlog.Logger, stage biui.Stage) {
	err := stage.Perform("Stopping registry", func() error {
		return i.StopRegistry()
	})
	if err != nil {
		logger.Warn("installation", "Registry failed to stop: %s", err)
	}
}
Exemple #4
0
func fail(err error, ui biui.UI, logger boshlog.Logger, callback func()) {
	logger.Error(mainLogTag, err.Error())
	ui.ErrorLinef("")
	ui.ErrorLinef(biuifmt.MultilineError(err))
	if callback != nil {
		callback()
	}
	os.Exit(1)
}
func mustLoadConfig(fs boshsys.FileSystem, logger boshlog.Logger) Config {
	flag.Parse()

	config, err := NewConfigFromPath(*configPathOpt, fs)
	if err != nil {
		logger.Error(mainLogTag, "Failed to load config %s", err)
		os.Exit(1)
	}

	return config
}
func BuildErrorWithJSON(msg string, logger boshlog.Logger) ([]byte, error) {
	response := NewExceptionResponse(bosherr.Error(msg))

	respJSON, err := json.Marshal(response)
	if err != nil {
		return respJSON, bosherr.WrapError(err, "Marshalling JSON")
	}

	logger.Info(mbusHandlerLogTag, "Building error", msg)

	return respJSON, nil
}
func NewSignalableLogger(logger boshlog.Logger, signalChannel chan os.Signal) (boshlog.Logger, chan bool) {
	doneChannel := make(chan bool, 1)
	go func() {
		for {
			<-signalChannel
			fmt.Println("Received SIGHUP - toggling debug output")
			logger.ToggleForcedDebug()
			doneChannel <- true
		}
	}()
	return logger, doneChannel
}
func NewSignalableLogger(writerLogger logger.Logger, signalChannel chan os.Signal) (logger.Logger, chan bool) {
	doneChannel := make(chan bool, 1)
	go func() {
		for {
			<-signalChannel
			writerLogger.Error("Received SIGSEGV", "Dumping goroutines...")
			stackTrace := make([]byte, 10000)
			runtime.Stack(stackTrace, true)
			writerLogger.Error("Received SIGSEGV", string(stackTrace))
			doneChannel <- true
		}
	}()
	return writerLogger, doneChannel
}
func NewProvider(
	platform boshplatform.Platform,
	client boshmonit.Client,
	logger boshlog.Logger,
	dirProvider boshdir.Provider,
	handler boshhandler.Handler,
) (p Provider) {
	fs := platform.GetFs()
	runner := platform.GetRunner()
	timeService := clock.NewClock()
	monitJobSupervisor := NewMonitJobSupervisor(
		fs,
		runner,
		client,
		logger,
		dirProvider,
		jobSupervisorListenPort,
		MonitReloadOptions{
			MaxTries:               3,
			MaxCheckTries:          6,
			DelayBetweenCheckTries: 5 * time.Second,
		},
		timeService,
	)

	network, err := platform.GetDefaultNetwork()
	var machineIP string
	if err != nil {
		machineIP, _ = os.Hostname()
		logger.Debug("providerWindows", "Initializing jobsupervisor.provider_windows: %s, using hostname \"%s\"instead of IP", err, machineIP)
	} else {
		machineIP = network.IP
	}

	p.supervisors = map[string]JobSupervisor{
		"monit":      monitJobSupervisor,
		"dummy":      NewDummyJobSupervisor(),
		"dummy-nats": NewDummyNatsJobSupervisor(handler),
		"windows": NewWindowsJobSupervisor(runner, dirProvider, fs, logger, jobSupervisorListenPort,
			make(chan bool), machineIP),
	}

	return
}
func NewRandomizer(
	actionFactory bltaction.Factory,
	cliRunnerFactory bltclirunner.Factory,
	fs boshsys.FileSystem,
	logger boshlog.Logger,
) Randomizer {
	seed := time.Now().Unix()
	logger.Debug("randomizer", "Using random seed: %d", seed)
	rand.Seed(seed)

	return &randomizer{
		actionFactory:    actionFactory,
		cliRunnerFactory: cliRunnerFactory,
		state:            [][]ActionInfo{},
		maxDelayInMilliseconds: 5000,
		fs:     fs,
		logger: logger,
	}
}
func (c *tempRootConfigurator) PrepareAndSetTempRoot(path string, logger logger.Logger) error {
	logger.Info("tempRootConfigurator", "Preparing temp root: %s", path)

	if c.fs.FileExists(path) {
		logger.Info("tempRootConfigurator", "Path exists, deleting")
		err := c.fs.RemoveAll(path)
		if err != nil {
			return err
		}
	}

	logger.Info("tempRootConfigurator", "Setting file system temp root")
	err := c.fs.ChangeTempRoot(path)
	if err != nil {
		return err
	}

	return nil
}
func marshalResponse(response Response, maxResponseLength int, logger boshlog.Logger) ([]byte, error) {
	respJSON, err := json.Marshal(response)
	if err != nil {
		logger.Error(mbusHandlerLogTag, "Failed to marshal response: %s", err.Error())
		return respJSON, bosherr.WrapError(err, "Marshalling JSON response")
	}

	if maxResponseLength == UnlimitedResponseLength {
		return respJSON, nil
	}

	if len(respJSON) > maxResponseLength {
		respJSON, err = json.Marshal(response.Shorten())
		if err != nil {
			logger.Error(mbusHandlerLogTag, "Failed to marshal response: %s", err.Error())
			return respJSON, bosherr.WrapError(err, "Marshalling JSON response")
		}
	}

	if len(respJSON) > maxResponseLength {
		respJSON, err = BuildErrorWithJSON(responseMaxLengthErrMsg, logger)
		if err != nil {
			logger.Error(mbusHandlerLogTag, "Failed to build 'max length exceeded' response: %s", err.Error())
			return respJSON, bosherr.WrapError(err, "Building error")
		}
	}

	return respJSON, nil
}
func Fail(err error, logger boshlog.Logger) {
	logger.Error("main", err.Error())
	os.Exit(1)
}