Golang env.LoadEnv函數代碼示例

func ExecuteSpecs(inParallel bool, args []string) {
	env.LoadEnv(false)
	conceptsDictionary, conceptParseResult := parser.CreateConceptsDictionary(false)
	parser.HandleParseResult(conceptParseResult)
	specsToExecute, specsSkipped := filter.GetSpecsToExecute(conceptsDictionary, args)
	if len(specsToExecute) == 0 {
		printExecutionStatus(nil, 0)
	}
	parallelInfo := &parallelInfo{inParallel: inParallel, numberOfStreams: NumberOfExecutionStreams}
	if !parallelInfo.isValid() {
		os.Exit(1)
	}
	manifest, err := manifest.ProjectManifest()
	if err != nil {
		execLogger.CriticalError(err)
	}
	runner := startApi()
	validateSpecs(manifest, specsToExecute, runner, conceptsDictionary)
	pluginHandler := plugin.StartPlugins(manifest)
	execution := newExecution(manifest, specsToExecute, runner, pluginHandler, parallelInfo, execLogger.Current())
	result := execution.start()
	execution.finish()
	exitCode := printExecutionStatus(result, specsSkipped)
	os.Exit(exitCode)
}

func executeSpecs(inParallel bool) {
	env.LoadEnv(*currentEnv, false)
	conceptsDictionary, conceptParseResult := createConceptsDictionary(false)
	handleParseResult(conceptParseResult)
	specsToExecute, specsSkipped := getSpecsToExecute(conceptsDictionary)
	if len(specsToExecute) == 0 {
		printExecutionStatus(nil, 0)
	}
	parallelInfo := &parallelInfo{inParallel: inParallel, numberOfStreams: *numberOfExecutionStreams}
	if !parallelInfo.isValid() {
		os.Exit(1)
	}
	manifest, err := getProjectManifest()
	if err != nil {
		handleCriticalError(err)
	}
	err, apiHandler := startAPIService(0)
	if err != nil {
		apiHandler.runner.kill(getCurrentLogger())
		handleCriticalError(errors.New(fmt.Sprintf("Failed to start gauge API. %s\n", err.Error())))
	}
	if apiHandler.runner == nil {
		handleCriticalError(errors.New("Failed to start a runner\n"))
	}

	validateSpecs(manifest, specsToExecute, apiHandler.runner, conceptsDictionary)
	pluginHandler := startPlugins(manifest)
	execution := newExecution(manifest, specsToExecute, apiHandler.runner, pluginHandler, parallelInfo, getCurrentLogger())
	result := execution.start()
	execution.finish()
	exitCode := printExecutionStatus(result, specsSkipped)
	os.Exit(exitCode)
}

func ExecuteSpecs(inParallel bool, args []string) int {
	if checkUpdatesDuringExecution && config.CheckUpdates() {
		i := &install.UpdateFacade{}
		i.BufferUpdateDetails()
		defer i.PrintUpdateBuffer()
	}

	env.LoadEnv(false)
	specsToExecute, conceptsDictionary := parseSpecs(args)
	manifest, err := manifest.ProjectManifest()
	if err != nil {
		logger.Fatal(err.Error())
	}
	runner := startApi()
	errMap := validateSpecs(manifest, specsToExecute, runner, conceptsDictionary)
	pluginHandler := plugin.StartPlugins(manifest)
	parallelInfo := &parallelInfo{inParallel: inParallel, numberOfStreams: NumberOfExecutionStreams}
	if !parallelInfo.isValid() {
		os.Exit(1)
	}
	execution := newExecution(&executionInfo{manifest, specsToExecute, runner, pluginHandler, parallelInfo, reporter.Current(), errMap})
	result := execution.start()
	execution.finish()
	exitCode := printExecutionStatus(result, errMap)
	return exitCode
}

func main() {
	flag.Parse()
	project_init.SetWorkingDir(*workingDir)
	initPackageFlags()
	validGaugeProject := true
	err := config.SetProjectRoot(flag.Args())
	if err != nil {
		validGaugeProject = false
	}
	env.LoadEnv(true)
	logger.Initialize(*verbosity, *logLevel, *simpleConsoleOutput)
	if *gaugeVersion {
		version.PrintVersion()
	} else if *daemonize {
		if validGaugeProject {
			api.RunInBackground(*apiPort)
		} else {
			logger.Log.Error(err.Error())
		}
	} else if *specFilesToFormat != "" {
		if validGaugeProject {
			formatter.FormatSpecFilesIn(*specFilesToFormat)
		} else {
			logger.Log.Error(err.Error())
		}
	} else if *initialize != "" {
		project_init.InitializeProject(*initialize)
	} else if *installZip != "" && *installPlugin != "" {
		install.InstallPluginZip(*installZip, *installPlugin)
	} else if *installPlugin != "" {
		install.DownloadAndInstallPlugin(*installPlugin, *installVersion)
	} else if *uninstallPlugin != "" {
		install.UninstallPlugin(*uninstallPlugin)
	} else if *installAll {
		install.InstallAllPlugins()
	} else if *update != "" {
		install.UpdatePlugin(*update)
	} else if *addPlugin != "" {
		install.AddPluginToProject(*addPlugin, *pluginArgs)
	} else if *refactorSteps != "" {
		if validGaugeProject {
			startChan := api.StartAPI()
			refactor.RefactorSteps(*refactorSteps, newStepName(), startChan)
		} else {
			logger.Log.Error(err.Error())
		}
	} else {
		if len(flag.Args()) == 0 {
			printUsage()
		} else if validGaugeProject {
			if *distribute != -1 {
				*doNotRandomize = true
			}
			execution.ExecuteSpecs(*parallel, flag.Args())
		} else {
			logger.Log.Error("Could not set project root: %s", err.Error())
			os.Exit(1)
		}
	}
}

func main() {
	flag.Parse()
	projectInit.SetWorkingDir(*workingDir)
	initPackageFlags()
	validGaugeProject := true
	err := config.SetProjectRoot(flag.Args())
	if err != nil {
		validGaugeProject = false
	}
	env.LoadEnv(*currentEnv)
	logger.Initialize(*logLevel)
	if *gaugeVersion {
		printVersion()
	} else if *initialize != "" {
		projectInit.InitializeProject(*initialize)
	} else if *installZip != "" && *installPlugin != "" {
		install.InstallPluginZip(*installZip, *installPlugin)
	} else if *installPlugin != "" {
		install.DownloadAndInstallPlugin(*installPlugin, *pluginVersion, "Successfully installed plugin => %s")
	} else if *uninstallPlugin != "" {
		install.UninstallPlugin(*uninstallPlugin, *pluginVersion)
	} else if *installAll {
		install.InstallAllPlugins()
	} else if *update != "" {
		install.DownloadAndInstallPlugin(*update, *pluginVersion, "Successfully updated plugin => %s")
	} else if *updateAll {
		install.UpdatePlugins()
	} else if *checkUpdates {
		install.PrintUpdateInfoWithDetails()
	} else if *addPlugin != "" {
		install.AddPluginToProject(*addPlugin, *pluginArgs)
	} else if *listTemplates {
		projectInit.ListTemplates()
	} else if flag.NFlag() == 0 && len(flag.Args()) == 0 {
		printUsage()
		os.Exit(0)
	} else if validGaugeProject {
		if *refactorSteps != "" {
			startChan := api.StartAPI()
			if len(flag.Args()) != 1 {
				logger.Error("flag needs two arguments: --refactor\n.Usage : gauge --refactor {old step} {new step}")
				os.Exit(1)
			}
			refactor.RefactorSteps(*refactorSteps, flag.Args()[0], startChan)
		} else if *daemonize {
			api.RunInBackground(*apiPort)
		} else if *specFilesToFormat != "" {
			formatter.FormatSpecFilesIn(*specFilesToFormat)
		} else if *validate {
			execution.Validate(flag.Args())
		} else {
			exitCode := execution.ExecuteSpecs(flag.Args())
			os.Exit(exitCode)
		}
	} else {
		logger.Error(err.Error())
		os.Exit(1)
	}
}

func (agent *rephraseRefactorer) startRunner() (*gaugeApiMessageHandler, error) {
	env.LoadEnv(*currentEnv, false)
	err, apiHandler := startAPIService(0)
	if err != nil {
		return nil, errors.New(fmt.Sprintf("Failed to connect to test runner: %s", err))
	}
	return apiHandler, nil
}

func ParseAndValidateSpecs(args []string) {
	env.LoadEnv(false)
	specsToExecute, conceptsDictionary := parseSpecs(args)
	manifest, err := manifest.ProjectManifest()
	if err != nil {
		logger.Fatal(err.Error())
	}
	runner := startApi()
	errMap := validateSpecs(manifest, specsToExecute, runner, conceptsDictionary)
	runner.Kill()
	if len(errMap.stepErrs) > 0 {
		os.Exit(1)
	}
	logger.Info("No error found.")
	os.Exit(0)
}

func main() {
	flag.Parse()
	setWorkingDir(*workingDir)
	validGaugeProject := true
	err := config.SetProjectRoot(flag.Args())
	if err != nil {
		validGaugeProject = false
	}
	env.LoadEnv(*currentEnv, true)
	logger.Initialize(*verbosity, *logLevel)
	if *gaugeVersion {
		printVersion()
	} else if *daemonize && validGaugeProject {
		runInBackground()
	} else if *specFilesToFormat != "" && validGaugeProject {
		formatSpecFilesIn(*specFilesToFormat)
	} else if *initialize != "" {
		initializeProject(*initialize)
	} else if *installZip != "" && *install != "" {
		installPluginZip(*installZip, *install)
	} else if *install != "" {
		downloadAndInstallPlugin(*install, *installVersion)
	} else if *installAll {
		installAllPlugins()
	} else if *update != "" {
		updatePlugin(*update)
	} else if *addPlugin != "" {
		addPluginToProject(*addPlugin)
	} else if *refactor != "" && validGaugeProject {
		refactorSteps(*refactor, newStepName())
	} else {
		if len(flag.Args()) == 0 {
			printUsage()
		} else if validGaugeProject {
			if *distribute != -1 {
				*doNotRandomize = true
			}
			executeSpecs(*parallel)
		} else {
			logger.Log.Error("Could not set project root: %s", err.Error())
			os.Exit(1)
		}
	}
}

func RunInBackground(apiPort string) {
	var port int
	var err error
	if apiPort != "" {
		port, err = strconv.Atoi(apiPort)
		os.Setenv(common.ApiPortEnvVariableName, apiPort)
		if err != nil {
			execLogger.CriticalError(errors.New(fmt.Sprintf("Failed to parse the port number :", apiPort, "\n", err.Error())))
		}
	} else {
		env.LoadEnv(false)
		port, err = conn.GetPortFromEnvironmentVariable(common.ApiPortEnvVariableName)
		if err != nil {
			execLogger.CriticalError(errors.New(fmt.Sprintf("Failed to start API Service. %s \n", err.Error())))
		}
	}
	var wg sync.WaitGroup
	runAPIServiceIndefinitely(port, &wg)
	wg.Wait()
}

func ExecuteSpecs(inParallel bool, args []string) {
	env.LoadEnv(false)
	specsToExecute, conceptsDictionary := parseSpecs(args)
	manifest, err := manifest.ProjectManifest()
	if err != nil {
		logger.Log.Critical(err.Error())
	}
	runner := startApi()
	errMap := validateSpecs(manifest, specsToExecute, runner, conceptsDictionary)
	pluginHandler := plugin.StartPlugins(manifest)
	parallelInfo := &parallelInfo{inParallel: inParallel, numberOfStreams: NumberOfExecutionStreams}
	if !parallelInfo.isValid() {
		os.Exit(1)
	}
	execution := newExecution(&executionInfo{manifest, specsToExecute, runner, pluginHandler, parallelInfo, &logger.Log, errMap})
	result := execution.start()
	execution.finish()
	exitCode := printExecutionStatus(result, errMap)
	os.Exit(exitCode)
}

func RunInBackground(apiPort string) {
	var port int
	var err error
	if apiPort != "" {
		port, err = strconv.Atoi(apiPort)
		if err != nil {
			logger.Fatal(fmt.Sprintf("Invalid port number: %s", apiPort))
		}
		os.Setenv(common.APIPortEnvVariableName, apiPort)
	} else {
		env.LoadEnv(false)
		port, err = conn.GetPortFromEnvironmentVariable(common.APIPortEnvVariableName)
		if err != nil {
			logger.Fatal(fmt.Sprintf("Failed to start API Service. %s \n", err.Error()))
		}
	}
	var wg sync.WaitGroup
	runAPIServiceIndefinitely(port, &wg)
	wg.Wait()
}

func ExecuteSpecs(inParallel bool, args []string) {
	env.LoadEnv(false)
	specsToExecute, conceptsDictionary := parseSpecs(args)
	manifest, err := manifest.ProjectManifest()
	if err != nil {
		logger.Log.Critical(err.Error())
	}
	runner := startApi()
	errMap := validateSpecs(manifest, specsToExecute, runner, conceptsDictionary)
	pluginHandler := plugin.StartPlugins(manifest)
	parallelInfo := &parallelInfo{inParallel: inParallel, numberOfStreams: NumberOfExecutionStreams}
	if !parallelInfo.isValid() {
		os.Exit(1)
	}
	execution := newExecution(&executionInfo{manifest, specsToExecute, runner, pluginHandler, parallelInfo, &logger.Log, errMap})
	result := execution.start()
	// TODO: Remove this logger line below when plugins call tell the difference between their status messages and user-generated sysouts
	logger.Log.Debug("\n")
	execution.finish()
	exitCode := printExecutionStatus(result, errMap)
	os.Exit(exitCode)
}

func StartAPI() *runner.StartChannels {
	env.LoadEnv(false)
	startChan := &runner.StartChannels{RunnerChan: make(chan *runner.TestRunner), ErrorChan: make(chan error), KillChan: make(chan bool)}
	go StartAPIService(0, startChan)
	return startChan
}

func main() {
	flag.Parse()
	util.SetWorkingDir(*workingDir)
	initPackageFlags()
	validGaugeProject := true
	err := config.SetProjectRoot(flag.Args())
	if err != nil {
		validGaugeProject = false
	}
	env.LoadEnv(*currentEnv)
	logger.Initialize(*logLevel)
	if *gaugeVersion && *machineReadable {
		printJSONVersion()
	} else if *machineReadable {
		fmt.Printf("flag '--machine-readable' can only be used with '--version' or '-v'\n\n")
		fmt.Printf("Usage:\n\n")
		flag.PrintDefaults()
		os.Exit(1)
	} else if *gaugeVersion {
		printVersion()
	} else if *initialize != "" {
		projectInit.InitializeProject(*initialize)
	} else if *installZip != "" && *installPlugin != "" {
		install.HandleInstallResult(install.InstallPluginFromZipFile(*installZip, *installPlugin), *installPlugin, true)
	} else if *installPlugin != "" {
		install.HandleInstallResult(install.InstallPlugin(*installPlugin, *pluginVersion), *installPlugin, true)
	} else if *uninstallPlugin != "" {
		install.UninstallPlugin(*uninstallPlugin, *pluginVersion)
	} else if *installAll {
		install.InstallAllPlugins()
	} else if *update != "" {
		install.HandleUpdateResult(install.InstallPlugin(*update, *pluginVersion), *update, true)
	} else if *updateAll {
		install.UpdatePlugins()
	} else if *checkUpdates {
		install.PrintUpdateInfoWithDetails()
	} else if *addPlugin != "" {
		install.AddPluginToProject(*addPlugin, *pluginArgs)
	} else if *listTemplates {
		projectInit.ListTemplates()
	} else if flag.NFlag() == 0 && len(flag.Args()) == 0 {
		printUsage()
		os.Exit(0)
	} else if validGaugeProject {
		var specDirs = []string{common.SpecsDirectoryName}
		if len(flag.Args()) > 0 {
			specDirs = flag.Args()
		}
		if *refactorSteps != "" {
			refactorInit(flag.Args())
		} else if *daemonize {
			api.RunInBackground(*apiPort, specDirs)
		} else if *specFilesToFormat != "" {
			formatter.FormatSpecFilesIn(*specFilesToFormat)
		} else if *validate {
			validation.Validate(flag.Args())
		} else {
			exitCode := execution.ExecuteSpecs(specDirs)
			os.Exit(exitCode)
		}
	} else {
		logger.Fatalf(err.Error())
	}
}

func main() {
	flag.Parse()
	projectInit.SetWorkingDir(*workingDir)
	initPackageFlags()
	validGaugeProject := true
	err := config.SetProjectRoot(flag.Args())
	if err != nil {
		validGaugeProject = false
	}
	env.LoadEnv(true)
	logger.Initialize(*verbosity, *logLevel)
	if *gaugeVersion {
		version.PrintVersion()
	} else if *daemonize {
		if validGaugeProject {
			api.RunInBackground(*apiPort)
		} else {
			logger.Error(err.Error())
		}
	} else if *specFilesToFormat != "" {
		if validGaugeProject {
			formatter.FormatSpecFilesIn(*specFilesToFormat)
		} else {
			logger.Error(err.Error())
		}
	} else if *initialize != "" {
		projectInit.InitializeProject(*initialize)
	} else if *installZip != "" && *installPlugin != "" {
		install.InstallPluginZip(*installZip, *installPlugin)
	} else if *installPlugin != "" {
		install.DownloadAndInstallPlugin(*installPlugin, *pluginVersion, "Successfully installed plugin => %s")
	} else if *uninstallPlugin != "" {
		install.UninstallPlugin(*uninstallPlugin, *pluginVersion)
	} else if *installAll {
		install.InstallAllPlugins()
	} else if *update != "" {
		install.DownloadAndInstallPlugin(*update, *pluginVersion, "Successfully updated plugin => %s")
	} else if *updateAll {
		install.UpdatePlugins()
	} else if *checkUpdates {
		install.PrintUpdateInfoWithDetails()
	} else if *addPlugin != "" {
		install.AddPluginToProject(*addPlugin, *pluginArgs)
	} else if *refactorSteps != "" {
		if validGaugeProject {
			startChan := api.StartAPI()
			refactor.RefactorSteps(*refactorSteps, newStepName(), startChan)
		} else {
			logger.Error(err.Error())
		}
	} else if *check {
		if validGaugeProject {
			execution.CheckSpecs(flag.Args())
		} else {
			logger.Error(err.Error())
		}
	} else {
		if len(flag.Args()) == 0 {
			printUsage()
		}
		if validGaugeProject {
			exitCode := execution.ExecuteSpecs(*parallel, flag.Args())
			os.Exit(exitCode)
		} else {
			logger.Error(err.Error())
		}
	}
}