def __GetEnvironmentVariable(self, name: str) -> str: # For cache entries we allow the variable to not be defined, but if it is defned we retrieve is as normal value = IOUtil.TryGetEnvironmentVariable(name) if value is None: raise EnvironmentError( "{0} environment variable not set".format(name)) value = IOUtil.NormalizePath(value) if value is None: raise EnvironmentError( "{0} environment variable not set".format(name)) if not IOUtil.IsAbsolutePath(value): raise EnvironmentError( "{0} environment path '{1}' is not absolute".format( name, value)) if value.endswith("/"): raise EnvironmentError( "{0} environment path '{1}' not allowed to end with '/' or '\'" .format(name, value)) # Create the directory if it didnt exist if not IOUtil.IsDirectory(value) and not IOUtil.Exists(value): self.__Log.LogPrint( "The directory '{0}' did not exist, creating it".format(value)) IOUtil.SafeMakeDirs(value) if not IOUtil.IsDirectory(value): raise EnvironmentError( "The {0} environment variable content '{1}' does not point to a valid directory" .format(name, value)) return value
def __TryCreateReadonlyCache( self, log: Log, basedUponXML: Optional[ XmlExperimentalDefaultThirdPartyInstallReadonlyCacheDirectory] ) -> Optional[ToolConfigExperimentalDefaultThirdPartyInstallDirectory]: entryName = "DefaultThirdPartyInstallReadonlyCacheDirectory" if basedUponXML is None: raise Exception( "No '{0}' was defined in the xml".format(entryName)) variableProcessor = VariableProcessor(log) env = variableProcessor.TryExtractLeadingEnvironmentVariableName( basedUponXML.Name, False) if env is None: raise Exception( "The {0} is expected to contain a environment variable '{1}'". format(entryName, basedUponXML.Name)) resolvedPath = IOUtil.TryGetEnvironmentVariable(env) if resolvedPath is None: log.LogPrintVerbose( 2, "Read only cache environment variable {0} not set, disabling cache" .format(env)) return None return ToolConfigExperimentalDefaultThirdPartyInstallDirectory( log, basedUponXML, entryName, True)
def Process(self, currentDirPath: str, toolConfig: ToolConfig, localToolConfig: LocalToolConfig) -> None: # Check if a environment variable has been set to disable this tool # This is for example done by FslBuild to prevent multiple executions of content building. toolEnabled = IOUtil.TryGetEnvironmentVariable(CONFIG_FSLBUILDCONTENT_ENABLED) featureList = localToolConfig.BuildPackageFilters.FeatureNameList config = Config(self.Log, toolConfig, localToolConfig.PackageConfigurationType, localToolConfig.BuildVariantsDict, localToolConfig.AllowDevelopmentPlugins) # Get the platform and see if its supported buildVariantConfig = BuildVariantConfigUtil.GetBuildVariantConfig(localToolConfig.BuildVariantsDict) generator = self.ToolAppContext.PluginConfigContext.GetGeneratorPluginById(localToolConfig.PlatformName, localToolConfig.Generator, buildVariantConfig, False, config.ToolConfig.CMakeConfiguration, localToolConfig.GetUserCMakeConfig()) PlatformUtil.CheckBuildPlatform(generator.PlatformName) generatorContext = GeneratorContext(config, self.ErrorHelpManager, localToolConfig.BuildPackageFilters.RecipeFilterManager, config.ToolConfig.Experimental, generator) config.LogPrint("Active platform: {0}".format(generator.PlatformName)) discoverFeatureList = '*' in featureList topLevelPackage = None if discoverFeatureList or localToolConfig.Project is None: if discoverFeatureList: config.LogPrint("No features specified, so using package to determine them") topLevelPackage = self.__ResolveAndGetTopLevelPackage(generatorContext, config, currentDirPath, toolConfig.GetMinimalConfig(), localToolConfig.Recursive) if discoverFeatureList: featureList = [entry.Name for entry in topLevelPackage.ResolvedAllUsedFeatures] #if localToolConfig.Project is None: # executeablePackage = PackageListUtil.FindFirstExecutablePackage(packages) # localToolConfig.Project = executeablePackage.ShortName if localToolConfig.Validate: Validate.ValidatePlatform(config, localToolConfig.PlatformName, featureList) if topLevelPackage is None: topLevelPackage = self.__ResolveAndGetTopLevelPackage(generatorContext, config, currentDirPath, toolConfig.GetMinimalConfig(), localToolConfig.Recursive) RecipeBuilder.ValidateInstallationForPackages(config, generatorContext, topLevelPackage.ResolvedBuildOrder) if toolEnabled is not None and not ParseUtil.ParseBool(toolEnabled): if self.Log.Verbosity > 0: print("FslBuildContent has been disabled by environment variable {0} set to {1}".format(CONFIG_FSLBUILDCONTENT_ENABLED, toolEnabled)) return locations = toolConfig.PackageConfiguration[localToolConfig.PackageConfigurationType].Locations if not localToolConfig.Recursive or topLevelPackage is None: location = self.__TryFindLocation(locations, currentDirPath) if location is None: raise Exception("Could not locate location for {0}".format(currentDirPath)) packagePath = PackagePath(currentDirPath, location) ContentBuilder.Build(config, packagePath, featureList, localToolConfig.Output) else: # Location not found, but its ok since '-r' was specified and we have a top level package for foundPackage in topLevelPackage.ResolvedBuildOrder: if foundPackage.Type == PackageType.Executable: foundFeatureList = [entry.Name for entry in foundPackage.ResolvedAllUsedFeatures] if foundPackage.Path is None: raise Exception("Invalid package") ContentBuilder.Build(config, foundPackage.Path, foundFeatureList)
def __init__(self, basicConfig: BasicConfig, recipeFilterManager: RecipeFilterManager, experimental: Optional[ToolConfigExperimental], generator: GeneratorPlugin) -> None: cmakeGenerator = CMakeTypes.TryDetermineCMakeGenerator(generator) cmakeGeneratorShortName = None if cmakeGenerator is not None: cmakeGeneratorShortName = CMakeTypes.TryGetCompilerShortIdFromGeneratorName( cmakeGenerator) shortCompilerName = "NotDefined" if cmakeGeneratorShortName is None else cmakeGeneratorShortName if cmakeGeneratorShortName is None: if basicConfig.Verbosity >= 2: basicConfig.LogPrintWarning( "No CMake short generator id has been defined, defaulting to '{0}'" .format(shortCompilerName)) recipeBuilderSetup = None allowDownloads = False if experimental is not None: targetLocation = ResolvedPath( experimental.DefaultThirdPartyInstallDirectory.DynamicName, experimental.DefaultThirdPartyInstallDirectory.ResolvedPath) installReadonlySource = experimental.DefaultThirdPartyInstallReadonlyCacheDirectory readonlyCachePath = None if installReadonlySource is None else installReadonlySource.ResolvedPath # type: Optional[str] recipeBuilderSetup = RecipeBuilderSetup(targetLocation, readonlyCachePath) if IOUtil.TryGetEnvironmentVariable( experimental.DisableDownloadEnv) != None: allowDownloads = False basicConfig.LogPrint( "Downloads disabled since the environment variable {0} was defined" .format(experimental.DisableDownloadEnv)) elif experimental.AllowDownloads: allowDownloads = True else: basicConfig.LogPrint( "Downloads disabled since the project has it disabled by default" ) super().__init__(basicConfig, generator.PlatformName, generator.PlatformName, shortCompilerName, recipeBuilderSetup) #allowDownload=True, disableDownloadEnv=None self.BasicConfig = basicConfig self.Generator = generator # for now the generator is also the platform and the existing code use that name so maintain compatibility for now self.Platform = generator self.AllowDownloads = allowDownloads self.RecipeFilterManager = recipeFilterManager
def __init__(self, log: Log, errorHelpManager: ErrorHelpManager, recipeFilterManager: RecipeFilterManager, experimental: Optional[ToolConfigExperimental], generator: GeneratorPlugin) -> None: if generator.CMakeConfig is None: raise Exception("Invalid generator") recipeBuilderSetup = None allowDownloads = False if experimental is not None: targetLocation = ResolvedPath( experimental.DefaultThirdPartyInstallDirectory.DynamicName, experimental.DefaultThirdPartyInstallDirectory.ResolvedPath) installReadonlySource = experimental.DefaultThirdPartyInstallReadonlyCacheDirectory readonlyCachePath = None if installReadonlySource is None else installReadonlySource.ResolvedPath # type: Optional[str] recipeBuilderSetup = RecipeBuilderSetup(targetLocation, readonlyCachePath) if IOUtil.TryGetEnvironmentVariable( experimental.DisableDownloadEnv) is not None: allowDownloads = False log.LogPrint( "Downloads disabled since the environment variable {0} was defined" .format(experimental.DisableDownloadEnv)) elif experimental.AllowDownloads: allowDownloads = True else: log.LogPrint( "Downloads disabled since the project has it disabled by default" ) validVariableDict = {} # type: Dict[str, object] validVariableDict['PlatformName'] = generator.PlatformName validVariableDict['IsCMakeBuild'] = generator.IsCMake generatorInfo = GeneratorInfo(generator.IsCMake, generator.CMakeConfig.AllowFindPackage, validVariableDict) super().__init__(log, errorHelpManager, generator.PlatformName, generator.PlatformName, generatorInfo, generator.CMakeConfig, recipeBuilderSetup) #allowDownload=True, disableDownloadEnv=None self.Log = log self.Generator = generator # for now the generator is also the platform and the existing code use that name so maintain compatibility for now self.Platform = generator self.AllowDownloads = allowDownloads self.RecipeFilterManager = recipeFilterManager
def DetectBuildPlatform() -> str: sdkPlatformName = IOUtil.TryGetEnvironmentVariable('FSL_PLATFORM_NAME') if os.name == 'posix': if not sdkPlatformName: raise EnvironmentError( "Please make sure that the environment variable FSL_PLATFORM_NAME is set" ) if sdkPlatformName not in g_posixPlatforms: raise EnvironmentError( "Please make sure that the environment variable FSL_PLATFORM_NAME is set to one of these {0}" .format(g_posixPlatforms)) elif os.name == 'nt': if not sdkPlatformName: return PlatformNameString.WINDOWS if sdkPlatformName not in g_ntPlatforms: raise EnvironmentError( "Please make sure that the environment variable FSL_PLATFORM_NAME is set to one of these {0}" .format(g_ntPlatforms)) else: raise EnvironmentError("Unsupported build environment") return sdkPlatformName
def Process(self, currentDirPath: str, toolConfig: ToolConfig, localToolConfig: LocalToolConfig) -> None: # Check if a environment variable has been set to disable this tool # This is for example done by FslBuild to prevent multiple executions of content building. toolEnabled = IOUtil.TryGetEnvironmentVariable( CONFIG_FSLBUILDCONTENT_ENABLED) featureList = localToolConfig.BuildPackageFilters.FeatureNameList config = Config(self.Log, toolConfig, localToolConfig.PackageConfigurationType, localToolConfig.BuildVariantsDict, localToolConfig.AllowDevelopmentPlugins) # Get the platform and see if its supported platform = PluginConfig.GetGeneratorPluginById( localToolConfig.PlatformName, False) PlatformUtil.CheckBuildPlatform(platform.Name) generatorContext = GeneratorContext(config, config.ToolConfig.Experimental, platform) config.LogPrint("Active platform: {0}".format(platform.Name)) discoverFeatureList = '*' in featureList topLevelPackage = None if discoverFeatureList or localToolConfig.Project is None: if discoverFeatureList: config.LogPrint( "No features specified, so using package to determine them" ) topLevelPackage = self.__ResolveAndGetTopLevelPackage( generatorContext, config, currentDirPath, toolConfig.GetMinimalConfig(), localToolConfig.Recursive) if discoverFeatureList: featureList = [ entry.Name for entry in topLevelPackage.ResolvedAllUsedFeatures ] #if localToolConfig.Project is None: # executeablePackage = PackageListUtil.FindFirstExecutablePackage(packages) # localToolConfig.Project = executeablePackage.ShortName if localToolConfig.Validate: Validate.ValidatePlatform(config, localToolConfig.PlatformName, featureList) if topLevelPackage is None: topLevelPackage = self.__ResolveAndGetTopLevelPackage( generatorContext, config, currentDirPath, toolConfig.GetMinimalConfig(), localToolConfig.Recursive) RecipeBuilder.ValidateInstallationForPackages( config, generatorContext, topLevelPackage.ResolvedBuildOrder) if toolEnabled is not None and not ParseUtil.ParseBool(toolEnabled): if self.Log.Verbosity > 0: print( "FslBuildContent has been disabled by environment variable %s set to %s" % (CONFIG_FSLBUILDCONTENT_ENABLED, toolEnabled)) return ContentBuilder.Build(config, currentDirPath, featureList)
def __init__(self, source: str, variableDict: Optional[VariableDict], environmentVariableResolver: Optional[ FormatStringEnvironmentVariableResolver] = None, noVariableResolve: bool = False, noEnvVariableResolve: bool = False) -> None: super().__init__() self.SplitList = [] # type: List[str] self.VarCommandList = [] # type: List[LookupVariableCommand] self.EnvCommandList = [ ] # type: List[LookupEnvironmentVariableCommand] if source == "": self.SplitList.append("") return state = ParseState.Scanning startSplitIndex = 0 blockStartIndex = 0 for index, ch in enumerate(source): if state == ParseState.Scanning: if ch == '$': state = ParseState.CommandStart elif state == ParseState.CommandStart: if ch == '{': state = ParseState.VariableBlock if startSplitIndex < index - 1: self.SplitList.append(source[startSplitIndex:index - 1]) startSplitIndex = index - 1 blockStartIndex = index + 1 elif ch == '(': state = ParseState.EnvBlock if startSplitIndex < index - 1: self.SplitList.append(source[startSplitIndex:index - 1]) startSplitIndex = index - 1 blockStartIndex = index + 1 #stringEndSplitIndex = blockStartIndex-2 elif state == ParseState.VariableBlock: if ch == '}': state = ParseState.Scanning self.SplitList.append(source[startSplitIndex:index + 1]) startSplitIndex = index + 1 # Do the report lookup variableName = (source[blockStartIndex:index]) if not Util.IsValidCStyleName(variableName): raise FormatStringInvalidVariableNameException( variableName) if noVariableResolve: variableValue = VariableReport( "*NotDefined*", ["*NotDefined*"], None) # type: Optional[VariableReport] else: variableValue = variableDict.TryGetVariableReport( variableName) if variableDict is not None else None if variableValue is None: raise FormatStringUndefinedVariableNameException( variableName) self.VarCommandList.append( LookupVariableCommand(variableName, variableValue, len(self.SplitList) - 1)) #stringEndSplitIndex = blockStartIndex elif state == ParseState.EnvBlock: if ch == ')': state = ParseState.Scanning self.SplitList.append(source[startSplitIndex:index + 1]) startSplitIndex = index + 1 envName = source[blockStartIndex:index] if not Util.IsValidCStyleName(envName): raise FormatStringInvalidVariableNameException(envName) if noEnvVariableResolve: envValue = "*NotDefined*" # type: Optional[str] elif environmentVariableResolver is None: envValue = IOUtil.TryGetEnvironmentVariable(envName) else: envValue = environmentVariableResolver(envName) if envValue is None: raise FormatStringUndefinedEnvironmentVariableNameException( envName) self.EnvCommandList.append( LookupEnvironmentVariableCommand( envName, envValue, len(self.SplitList) - 1)) if startSplitIndex < len(source): self.SplitList.append(source[startSplitIndex:]) if state != ParseState.Scanning and state != ParseState.CommandStart: if state == ParseState.VariableBlock: raise FormatStringVariableMissingTerminationException( "The string '{0}' is missing a terminating '}}' ".format( source)) elif state == ParseState.EnvBlock: raise FormatStringEnvironmentVariableMissingTerminationException( "The string '{0}' is missing a terminating ')' ".format( source)) raise FormatStringInvalidException( "The string '{0}' contained invalid format codes".format( source))