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))
