Esempio n. 1
0
func StartRunnerAndMakeConnection(manifest *manifest.Manifest, log *logger.GaugeLogger, killChannel chan bool) (*TestRunner, error) {
	port, err := conn.GetPortFromEnvironmentVariable(common.GaugePortEnvName)
	if err != nil {
		port = 0
	}
	gaugeConnectionHandler, connHandlerErr := conn.NewGaugeConnectionHandler(port, nil)
	if connHandlerErr != nil {
		return nil, connHandlerErr
	}
	testRunner, err := startRunner(manifest, strconv.Itoa(gaugeConnectionHandler.ConnectionPortNumber()), log, killChannel)
	if err != nil {
		return nil, err
	}

	runnerConnection, connectionError := gaugeConnectionHandler.AcceptConnection(config.RunnerConnectionTimeout(), testRunner.ErrorChannel)
	testRunner.Connection = runnerConnection
	if connectionError != nil {
		log.Debug("Runner connection error: %s", connectionError)
		err := testRunner.killRunner()
		if err != nil {
			log.Debug("Error while killing runner: %s", err)
		}
		return nil, connectionError
	}
	return testRunner, nil
}
Esempio n. 2
0
func printStatus(executionResult *gauge_messages.ProtoExecutionResult, logger *logger.GaugeLogger) {
	logger.Error("Error Message: %s", executionResult.GetErrorMessage())

	stacktrace := executionResult.GetStackTrace()
	stacktrace = strings.Replace(stacktrace, "\n", "\n\t", -1)
	logger.Error("Stacktrace: %s", stacktrace)
}
Esempio n. 3
0
func waitAndGetErrorMessage(errChannel chan error, cmd *exec.Cmd, log *logger.GaugeLogger) {
	go func() {
		err := cmd.Wait()
		if err != nil {
			log.Debug("Runner exited with error: %s", err)
			errChannel <- errors.New(fmt.Sprintf("Runner exited with error: %s\n", err.Error()))
		}
	}()
}
Esempio n. 4
0
func (e *parallelSpecExecution) startStream(specs *specList, log *logger.GaugeLogger, suiteResultChannel chan *result.SuiteResult) {
	defer e.wg.Done()
	testRunner, err := runner.StartRunnerAndMakeConnection(e.manifest, log, make(chan bool))
	if err != nil {
		log.Error("Failed to start runner. Reason: %s", err.Error())
		suiteResultChannel <- &result.SuiteResult{UnhandledErrors: []error{errors.New(fmt.Sprintf("Failed to start runner. %s", err.Error()))}}
		return
	}
	simpleExecution := newSimpleExecution(&executionInfo{e.manifest, make([]*parser.Specification, 0), testRunner, e.pluginHandler, nil, log, e.errMaps})
	result := simpleExecution.executeStream(specs)
	suiteResultChannel <- result
}
Esempio n. 5
0
func setStepFailure(executionInfo *gauge_messages.ExecutionInfo, logger *logger.GaugeLogger) {
	setScenarioFailure(executionInfo)
	logger.Error("Failed step: %s", executionInfo.CurrentStep.Step.GetActualStepText())
	executionInfo.CurrentStep.IsFailed = proto.Bool(true)
}
Esempio n. 6
0
func printStatus(executionResult *gauge_messages.ProtoExecutionResult, logger logger.GaugeLogger) {
	logger.Error("Error Message: %s", executionResult.GetErrorMessage())
	stacktrace := executionResult.GetStackTrace()
	logger.Error("Stacktrace: %s", stacktrace)
}