예제 #1
0
def __TestGetPackageLoader(config: Config, files: List[str],
                           platformId: str) -> PackageLoader:
    packageFilters = PackageFilters()
    platformGeneratorPlugin = PluginConfig.GetGeneratorPluginById(
        platformId, GeneratorType.Default, True,
        config.ToolConfig.CMakeConfiguration, None)
    return PackageLoader(config, files, platformGeneratorPlugin)
예제 #2
0
def __PrepareGeneratorPlugins(lowLevelToolConfig: LowLevelToolConfig,
                              toolCommonArgConfig: ToolCommonArgConfig) -> List[str]:
    generatorPlugins = PluginConfig.GetGeneratorPlugins(lowLevelToolConfig.AllowDevelopmentPlugins)
    generatorIds = [entry.Id for entry in generatorPlugins]
    if toolCommonArgConfig.AllowPlaformAll:
        generatorIds.append(PluginSharedValues.PLATFORM_ID_ALL)
    return generatorIds
    def Process(self, currentDirPath: str, toolConfig: ToolConfig, localToolConfig: LocalToolConfig) -> None:
        config = Config(self.Log, toolConfig, localToolConfig.PackageConfigurationType,
                        localToolConfig.BuildVariantsDict, localToolConfig.AllowDevelopmentPlugins)

        if localToolConfig.DryRun:
            config.ForceDisableAllWrite()
        if localToolConfig.IgnoreNotSupported:
            config.IgnoreNotSupported = True

        # Get the platform and see if its supported
        platformGeneratorPlugin = PluginConfig.GetGeneratorPluginById(localToolConfig.PlatformName, localToolConfig.Generator, False,
                                                                      config.ToolConfig.CMakeConfiguration, localToolConfig.GetUserCMakeConfig())
        PlatformUtil.CheckBuildPlatform(platformGeneratorPlugin.PlatformName)

        config.LogPrint("Active platform: {0}".format(platformGeneratorPlugin.PlatformName))

        theFiles = MainFlow.DoGetFiles(config, toolConfig.GetMinimalConfig(), currentDirPath, localToolConfig.Recursive)

        generatorContext = GeneratorContext(config, localToolConfig.BuildPackageFilters.RecipeFilterManager, config.ToolConfig.Experimental, platformGeneratorPlugin)
        PluginConfig.SetLegacyGeneratorType(localToolConfig.GenType)

        packageFilters = localToolConfig.BuildPackageFilters
        packages = MainFlow.DoGenerateBuildFilesNoAll(config, theFiles, platformGeneratorPlugin, packageFilters)

        topLevelPackage = PackageListUtil.GetTopLevelPackage(packages)

        requestedFiles = None if config.IsSDKBuild else theFiles

        # We need the generator to be able to examine its support

        if localToolConfig.ListFeatures or localToolConfig.ListVariants or localToolConfig.ListExtensions or localToolConfig.ListRequirements:
            if localToolConfig.ListFeatures:
                Builder.ShowFeatureList(self.Log, config, topLevelPackage, requestedFiles)
            if localToolConfig.ListVariants:
                Builder.ShowVariantList(self.Log, topLevelPackage, requestedFiles, platformGeneratorPlugin)
            if localToolConfig.ListExtensions:
                Builder.ShowExtensionList(self.Log, topLevelPackage, requestedFiles)
            if localToolConfig.ListRequirements:
                Builder.ShowRequirementList(self.Log, config, topLevelPackage, requestedFiles)
        else:
            if localToolConfig.BuildPackageFilters is None or localToolConfig.BuildPackageFilters.ExtensionNameList is None:
                raise Exception("localToolConfig.BuildPackageFilters.ExtensionNameList not set")
            Builder.BuildPackages(generatorContext, config, packages,
                                  localToolConfig.BuildVariantsDict, localToolConfig.RemainingArgs, localToolConfig.ForAllExe,
                                  platformGeneratorPlugin, localToolConfig.EnableContentBuilder, localToolConfig.ForceClaimInstallArea,
                                  localToolConfig.BuildThreads, localToolConfig.Command)
예제 #4
0
    def Process(self, currentDirPath: str, toolConfig: ToolConfig,
                localToolConfig: LocalToolConfig) -> None:
        config = Config(self.Log, toolConfig, 'sdk',
                        localToolConfig.BuildVariantsDict,
                        localToolConfig.AllowDevelopmentPlugins)
        if localToolConfig.DryRun:
            config.ForceDisableAllWrite()

        if localToolConfig.ToCDepth < 1:
            localToolConfig.ToCDepth = 1
        elif localToolConfig.ToCDepth > 4:
            localToolConfig.ToCDepth = 4

        config.PrintTitle()

        # Get the platform and see if its supported
        platform = PluginConfig.GetGeneratorPluginById(
            localToolConfig.PlatformName, False)
        PlatformUtil.CheckBuildPlatform(platform.Name)

        config.LogPrint("Active platform: {0}".format(platform.Name))

        packageFilters = localToolConfig.BuildPackageFilters

        theFiles = MainFlow.DoGetFiles(config, toolConfig.GetMinimalConfig(),
                                       currentDirPath,
                                       localToolConfig.Recursive)
        generatorContext = GeneratorContext(config,
                                            config.ToolConfig.Experimental,
                                            platform)
        packages = MainFlow.DoGetPackages(generatorContext, config, theFiles,
                                          packageFilters)
        #topLevelPackage = PackageListUtil.GetTopLevelPackage(packages)
        #featureList = [entry.Name for entry in topLevelPackage.ResolvedAllUsedFeatures]

        for rootDir in config.ToolConfig.RootDirectories:
            readmePath = IOUtil.Join(rootDir.ResolvedPath, "README.md")
            packageReadMeLines = TryLoadReadMe(config, readmePath)
            result = ProcessPackages(self.ToolAppContext, config, packages,
                                     rootDir, localToolConfig.ExtractArguments,
                                     toolConfig.BuildDocConfiguration)
            if packageReadMeLines is not None:
                packageReadMeLinesNew = TryReplaceSection(
                    config, packageReadMeLines, "AG_DEMOAPPS", result,
                    readmePath)
                if packageReadMeLinesNew is not None:
                    packageReadMeLines = packageReadMeLinesNew

                packageReadMeLinesNew = TryInsertTableOfContents(
                    config, packageReadMeLines, localToolConfig.ToCDepth,
                    readmePath)
                if packageReadMeLinesNew is not None:
                    packageReadMeLines = packageReadMeLinesNew

                SaveReadMe(config, readmePath, packageReadMeLines)
            elif config.Verbosity > 2:
                config.LogPrintWarning("No README.md found in {0}".format(
                    rootDir.ResolvedPath))
예제 #5
0
def __TestGenerateBuildFiles(config: Config, files: List[str],
                             platformId: str) -> Dict[str, List[Package]]:
    packageFilters = PackageFilters()
    platform = PluginConfig.GetGeneratorPluginById(platformId, True)
    buildFilesDict = DoGenerateBuildFiles3(config, files, platform,
                                           packageFilters)
    return {
        dictKey: dictValue[0]
        for dictKey, dictValue in buildFilesDict.items()
    }
예제 #6
0
def __TestGetPackageLoader(config: Config, files: List[str],
                           platformId: str) -> PackageLoader:
    packageFilters = PackageFilters()
    #generatorCMakeConfig = __GetTestGeneratorCMakeConfig()
    log = config  # type: Log
    pluginConfigContext = PluginConfig.InitPluginConfigContext(
        log, config.ToolConfig.ToolVersion, allowDevelopmentPlugins=True)
    buildVariantConfig = BuildVariantConfig.Debug
    platformGeneratorPlugin = pluginConfigContext.GetGeneratorPluginById(
        platformId, GeneratorType.Default, buildVariantConfig, True,
        config.ToolConfig.CMakeConfiguration, None)
    return PackageLoader(config, files, platformGeneratorPlugin)
예제 #7
0
def DoGenerateBuildFiles3(config: Config, files: List[str], platformGeneratorPlugin: GeneratorPlugin,
                          packageFilters: PackageFilters) -> MultiPlatformPackageResultType:
    config.LogPrint("- Generating build files")

    isSDKBuild = len(files) <= 0
    packageLoader = PackageLoader(config, files, platformGeneratorPlugin)
    if platformGeneratorPlugin.Id != PluginSharedValues.PLATFORM_ID_ALL:
        raise Exception("This requires: PLATFORM_ID_ALL")
    resDict = {} # type: MultiPlatformPackageResultType
    for entry in PluginConfig.GetGeneratorPlugins(config.AllowDevelopmentPlugins):
        if not config.IsTestMode or not entry.InDevelopment:
            packages = __ResolveAndGenerate(config, entry, copy.deepcopy(packageLoader), packageFilters, isSDKBuild)
            resDict[entry.Name] = (packages, entry)
    return resDict
예제 #8
0
def __TestGenerateBuildFiles(config: Config, files: List[str],
                             platformId: str) -> Dict[str, List[Package]]:
    errorHelpManager = ErrorHelpManager()
    packageFilters = PackageFilters()
    log = config  # type: Log
    #generatorCMakeConfig = __GetTestGeneratorCMakeConfig()
    pluginConfigContext = PluginConfig.InitPluginConfigContext(
        log, config.ToolConfig.ToolVersion, allowDevelopmentPlugins=True)
    buildVariantConfig = BuildVariantConfig.Debug
    platform = pluginConfigContext.GetGeneratorPluginById(
        platformId, GeneratorType.Default, buildVariantConfig, True,
        config.ToolConfig.CMakeConfiguration, None)
    buildFilesDict = DoGenerateBuildFiles3(pluginConfigContext, config,
                                           errorHelpManager, files, platform,
                                           packageFilters)
    return {
        dictKey: dictValue[0]
        for dictKey, dictValue in buildFilesDict.items()
    }
예제 #9
0
    def Process(self, currentDirPath: str, toolConfig: ToolConfig, localToolConfig: LocalToolConfig) -> None:
        config = Config(self.Log, toolConfig, localToolConfig.PackageConfigurationType,
                        localToolConfig.BuildVariantsDict, localToolConfig.AllowDevelopmentPlugins)

        # Disable downloads and writes
        if config.ToolConfig.Experimental is not None:
            config.ToolConfig.Experimental.AllowDownloads = False
        config.ForceDisableAllWrite()
        if localToolConfig.IgnoreNotSupported:
            config.IgnoreNotSupported = True

        self.Log.PrintTitle()

        if not localToolConfig.ForceYes and not self.__AskYesNo("Delete all build directories"):
            return

        packageFilters = localToolConfig.BuildPackageFilters

        generator = PluginConfig.GetGeneratorPluginById(localToolConfig.PlatformName, False)

        theFiles = MainFlow.DoGetFiles(config, toolConfig.GetMinimalConfig(), currentDirPath, localToolConfig.Recursive)
        generatorContext = GeneratorContext(config, config.ToolConfig.Experimental, generator)
        packages = MainFlow.DoGetPackages(generatorContext, config, theFiles, packageFilters, autoAddRecipeExternals=False)

        topLevelPackage = PackageListUtil.GetTopLevelPackage(packages)
        requestedFiles = None if config.IsSDKBuild else theFiles

        self.Log.LogPrint("Deleting package build directories")
        for package in topLevelPackage.ResolvedBuildOrder:
            if package.AbsoluteBuildPath is not None:
                # While the path is most likely normalized we force it here
                removePath = IOUtil.NormalizePath(package.AbsoluteBuildPath)
                if IOUtil.IsDirectory(removePath):
                    self.Log.LogPrint("- Deleting '{0}'".format(removePath))
                    drive, tail = os.path.splitdrive(removePath)
                    driveId = IOUtil.NormalizePath(drive).lower()
                    removePathId = removePath.lower()
                    # some basic checks to prevent deletes of '/' or a drive letter.
                    if  ('../' in removePath or '/..' in removePath or removePath == '/' or removePath == '..' or
                         len(removePath) <= 0 or removePathId==driveId or removePath.endswith('/')):
                        raise Exception("Invalid path format '{0}'".format(removePath))
                    IOUtil.SafeRemoveDirectoryTree(removePath)
    def Process(self, currentDirPath: str, toolConfig: ToolConfig,
                localToolConfig: LocalToolConfig) -> None:
        config = Config(self.Log, toolConfig,
                        localToolConfig.PackageConfigurationType,
                        localToolConfig.BuildVariantsDict,
                        localToolConfig.AllowDevelopmentPlugins)

        packageFilters = localToolConfig.BuildPackageFilters

        platform = PluginConfig.GetGeneratorPluginById(
            localToolConfig.PlatformName, localToolConfig.Generator, False,
            config.ToolConfig.CMakeConfiguration,
            localToolConfig.GetUserCMakeConfig())
        theFiles = []  # type: List[str]
        if not localToolConfig.VoidBuild:
            theFiles = MainFlow.DoGetFiles(config,
                                           toolConfig.GetMinimalConfig(),
                                           currentDirPath,
                                           localToolConfig.Recursive)
        else:
            self.Log.LogPrintVerbose(1, "Doing a void build")
        generatorContext = GeneratorContext(config,
                                            packageFilters.RecipeFilterManager,
                                            config.ToolConfig.Experimental,
                                            platform)
        packages = MainFlow.DoGetPackages(generatorContext, config, theFiles,
                                          packageFilters)
        #packages = DoExperimentalGetRecipes(generatorContext, config, [])
        #topLevelPackage = PackageListUtil.GetTopLevelPackage(packages)

        builderConfig = BuilderConfig()
        builderConfig.Settings.PreDeleteBuild = localToolConfig.PreDeleteBuild
        builderConfig.Settings.PostDeleteBuild = localToolConfig.PostDeleteBuild
        builderConfig.Settings.CheckBuildCommands = localToolConfig.CheckBuildCommands
        builderConfig.Settings.ForceClaimInstallArea = localToolConfig.ForceClaimInstallArea
        builderConfig.Settings.BuildThreads = localToolConfig.BuildThreads

        RecipeBuilder.BuildPackages(config, generatorContext, builderConfig,
                                    packages)
예제 #11
0
def DoGenerateBuildFiles(
    config: Config, files: List[str], platformGeneratorPlugin: GeneratorPlugin,
    packageFilters: PackageFilters
) -> Union[List[Package], MultiPlatformPackageResultType]:
    config.LogPrint("- Generating build files")

    isSDKBuild = len(files) <= 0
    packageLoader = PackageLoader(config, files, platformGeneratorPlugin)
    res = []  # type: Union[List[Package], MultiPlatformPackageResultType]
    if platformGeneratorPlugin.PlatformId == PluginSharedValues.PLATFORM_ID_ALL:
        resDict = {}  # type: MultiPlatformPackageResultType
        for entry in PluginConfig.GetGeneratorPlugins(
                config.AllowDevelopmentPlugins):
            if not config.IsTestMode or not entry.InDevelopment:
                packages = __ResolveAndGenerate(config, entry,
                                                copy.deepcopy(packageLoader),
                                                packageFilters, isSDKBuild)
            resDict[entry.PlatformName] = (packages, entry)
        res = resDict
    else:
        res = __ResolveAndGenerate(config, platformGeneratorPlugin,
                                   packageLoader, packageFilters, isSDKBuild)

    return res
예제 #12
0
def __TestGenerateBuildFilesAllPlatforms(
        config: Config, files: List[str]) -> Dict[str, List[Package]]:
    res = {}  # type: Dict[str, List[Package]]
    for platformId in PackageConfig.APPROVED_PLATFORM_NAMES:
        errorHelpManager = ErrorHelpManager()
        packageFilters = PackageFilters()
        log = config  # type: Log
        #generatorCMakeConfig = __GetTestGeneratorCMakeConfig()
        pluginConfigContext = PluginConfig.InitPluginConfigContext(
            log, config.ToolConfig.ToolVersion, allowDevelopmentPlugins=True)
        pluginConfigContext.SetVSVersion(
            str(config.ToolConfig.GetVisualStudioDefaultVersion()))

        buildVariantConfig = BuildVariantConfig.Debug
        platform = pluginConfigContext.GetGeneratorPluginById(
            platformId, GeneratorType.Default, buildVariantConfig,
            config.ToolConfig.DefaultPackageLanguage,
            config.ToolConfig.CMakeConfiguration, None, False)
        resultTuple = DoGenerateBuildFilesNow(pluginConfigContext, config,
                                              errorHelpManager, files,
                                              platform, packageFilters)
        if resultTuple is not None:
            res[platformId] = resultTuple[0]
    return res
예제 #13
0
def __Run(appFlowFactory: AToolAppFlowFactory, strToolAppTitle: str,
          toolCommonArgConfig: ToolCommonArgConfig,
          lowLevelToolConfig: LowLevelToolConfig,
          allowStandaloneMode: bool) -> None:

    log = Log(strToolAppTitle,
              lowLevelToolConfig.VerbosityLevel,
              showAppTitleIfVerbose=True)

    generatorIds = __PrepareGeneratorPlugins(lowLevelToolConfig,
                                             toolCommonArgConfig)

    try:
        defaultPlatform = DetectBuildPlatform()
    except (Exception) as ex:
        print("ERROR: {0}".format(ex))
        if lowLevelToolConfig.DebugEnabled:
            raise
        sys.exit(1)

    ### Do the actual command line parsing
    parser = __CreateParser(toolCommonArgConfig, allowStandaloneMode)
    if toolCommonArgConfig.AddPlatformArg:
        parser.add_argument('-p',
                            '--platform',
                            default=defaultPlatform,
                            help='Select build platform: {0}'.format(
                                ", ".join(generatorIds)))
    if toolCommonArgConfig.AllowForceClaimInstallArea:
        parser.add_argument(
            '--ForceClaimInstallArea',
            action='store_true',
            help=
            'Override the security checks on the install area allowing us to use it even though its not empty. This means the existing content can be lost.'
        )

    #parser.add_argument('--NativeGen', action='store_true',  help='Force use the native build generator')

    toolConfig = None
    baseConfig = None
    try:
        basicConfig = BasicConfig(log)
        currentDir = lowLevelToolConfig.CurrentDir

        # Try to locate a project root configuration file
        projectRootConfig = GetProjectRootConfig(lowLevelToolConfig,
                                                 basicConfig, currentDir)
        toolConfigFile = projectRootConfig.ToolConfigFile

        # Get the path to the toolconfig file if necessary and load the tool config file
        toolConfigPath = __GetToolConfigPath(toolConfigFile)
        toolConfig = ToolConfig(basicConfig, toolConfigPath, projectRootConfig)
        baseConfig = BaseConfig(log, toolConfig)
    except (Exception) as ex:
        print("ERROR: {0}".format(ex))
        if lowLevelToolConfig.DebugEnabled:
            raise
        sys.exit(1)

    buildTiming = None
    try:
        defaultVSVersion = toolConfig.GetVisualStudioDefaultVersion()
        #if toolCommonArgConfig.AllowVSVersion:
        parser.add_argument(
            '--VSVersion',
            default=str(defaultVSVersion),
            help=
            'Choose a specific visual studio version (2015,2017), This project defaults to: {0}'
            .format(defaultVSVersion))

        userTag = appFlowFactory.CreateUserTag(baseConfig)
        appFlowFactory.AddCustomArguments(parser, toolConfig, userTag)

        args = parser.parse_args()

        #if toolCommonArgConfig.AllowVSVersion:
        PluginConfig.SetVSVersion(args.VSVersion)

        #if toolCommonArgConfig.AddPlatformArg and args.platform.lower() != PluginSharedValues.PLATFORM_ID_ALL:
        #PluginConfig.SetForceUseNativeGenerator(True)
        #PluginConfig.SetForceUseNativeGenerator(args.NativeGen)

        if toolCommonArgConfig.ProcessRemainingArgs:
            args.RemainingArgs = __ProcessRemainingArgs(args.RemainingArgs)
        if toolCommonArgConfig.SupportBuildTime and args.BuildTime:
            buildTiming = BuildTimer()

        if toolCommonArgConfig.AddBuildFiltering and args.Recipes == DefaultValue.Recipes:
            if projectRootConfig.XmlExperimental is not None:
                tmpResult = projectRootConfig.XmlExperimental.TryGetRecipesDefaultValue(
                    defaultPlatform)
                if tmpResult is not None:
                    args.Recipes = "[{0}]".format(tmpResult)

        toolAppConfig = __CreateToolAppConfig(args, defaultPlatform,
                                              toolCommonArgConfig,
                                              defaultVSVersion)
        toolAppContext = ToolAppContext(log, lowLevelToolConfig, toolAppConfig)
        toolAppFlow = appFlowFactory.Create(toolAppContext)
        toolAppFlow.ProcessFromCommandLine(args, currentDir, toolConfig,
                                           userTag)

        if buildTiming:
            PrintBuildTiming(buildTiming)
    except GroupedException as ex:
        if buildTiming:
            PrintBuildTiming(buildTiming)
        for entry in ex.ExceptionList:
            print("ERROR: {0}".format(entry))
        if lowLevelToolConfig.DebugEnabled:
            raise
        for entry in ex.ExceptionList:
            if isinstance(entry, ExitException):
                sys.exit(entry.ExitCode)
        sys.exit(1)
    except AggregateException as ex:
        if buildTiming:
            PrintBuildTiming(buildTiming)
        for entry in ex.ExceptionList:
            print("ERROR: {0}".format(entry))
        if lowLevelToolConfig.DebugEnabled:
            if len(ex.ExceptionList) > 0:
                raise ex.ExceptionList[0]
            raise
        for entry in ex.ExceptionList:
            if isinstance(entry, ExitException):
                sys.exit(entry.ExitCode)
        sys.exit(1)
    except ExitException as ex:
        sys.exit(ex.ExitCode)
    except Exception as ex:
        if buildTiming:
            PrintBuildTiming(buildTiming)
        print("ERROR: {0}".format(ex))
        if lowLevelToolConfig.DebugEnabled:
            raise
        sys.exit(1)
    def Process(self, currentDirPath: str, toolConfig: ToolConfig,
                localToolConfig: LocalToolConfig) -> None:
        config = Config(self.Log, toolConfig,
                        localToolConfig.PackageConfigurationType,
                        localToolConfig.BuildVariantsDict,
                        localToolConfig.AllowDevelopmentPlugins)

        if localToolConfig.DryRun:
            config.ForceDisableAllWrite()
        if localToolConfig.IgnoreNotSupported:
            config.IgnoreNotSupported = True

        if localToolConfig.Graph:
            PluginConfig.EnableGraph()

        theFiles = MainFlow.DoGetFiles(config, toolConfig.GetMinimalConfig(),
                                       currentDirPath,
                                       localToolConfig.Recursive)

        PluginConfig.SetGeneratorType(localToolConfig.GenType)

        platformGeneratorPlugin = PluginConfig.GetGeneratorPluginById(
            localToolConfig.PlatformName, True)
        generatorContext = GeneratorContext(config,
                                            config.ToolConfig.Experimental,
                                            platformGeneratorPlugin)
        packages = MainFlow.DoGenerateBuildFiles(
            config, theFiles, platformGeneratorPlugin,
            localToolConfig.BuildPackageFilters)

        # If the platform was manually switched, then check if the build platform is supported,
        # if its not disable recipe building and log a warning
        if localToolConfig.DefaultPlatformName != localToolConfig.PlatformName:
            if not PlatformUtil.TryCheckBuildPlatform(
                    localToolConfig.PlatformName):
                self.Log.DoPrintWarning(
                    "Build recipes not supported for '{0}' on this OS".format(
                        localToolConfig.PlatformName))
                localToolConfig.DontBuildRecipes = True

        if localToolConfig.ListVariants or localToolConfig.ListBuildVariants:
            requestedFiles = None if config.IsSDKBuild else theFiles
            if not isinstance(packages, dict):
                self.__DoShowList(packages, requestedFiles,
                                  localToolConfig.ListVariants,
                                  localToolConfig.ListBuildVariants,
                                  platformGeneratorPlugin)
            else:
                for platformName, platformResult in packages.items():
                    platformPackageList = platformResult[0]
                    if len(platformPackageList) > 0:
                        self.Log.DoPrint("Generator: {0}".format(platformName))
                        try:
                            self.Log.PushIndent()
                            self.__DoShowList(
                                platformPackageList, requestedFiles,
                                localToolConfig.ListVariants,
                                localToolConfig.ListBuildVariants,
                                platformResult[1])
                        finally:
                            self.Log.PopIndent()
        elif not localToolConfig.DontBuildRecipes:
            if not isinstance(packages, dict):
                self.__DoBuildRecipes(config, generatorContext, packages,
                                      localToolConfig.ForceClaimInstallArea,
                                      localToolConfig.BuildThreads)
            else:
                for platformName, platformResult in packages.items():
                    platformPackageList = platformResult[0]
                    if len(platformPackageList
                           ) > 0 and PlatformUtil.TryCheckBuildPlatform(
                               platformName):
                        self.Log.DoPrint("Generator: {0}".format(platformName))
                        tempPlatformGeneratorPlugin = PluginConfig.GetGeneratorPluginById(
                            platformName, True)
                        tempGeneratorContext = GeneratorContext(
                            config, config.ToolConfig.Experimental,
                            tempPlatformGeneratorPlugin)
                        try:
                            self.Log.PushIndent()
                            self.__DoBuildRecipes(
                                config, tempGeneratorContext,
                                platformPackageList,
                                localToolConfig.ForceClaimInstallArea,
                                localToolConfig.BuildThreads)
                        finally:
                            self.Log.PopIndent()
    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
        generator = PluginConfig.GetGeneratorPluginById(
            localToolConfig.PlatformName, localToolConfig.Generator, False,
            config.ToolConfig.CMakeConfiguration,
            localToolConfig.GetUserCMakeConfig())
        PlatformUtil.CheckBuildPlatform(generator.PlatformName)
        generatorContext = GeneratorContext(
            config, 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
        location = self.__FindLocation(locations, currentDirPath)
        packagePath = PackagePath(currentDirPath, location)

        ContentBuilder.Build(config, packagePath, featureList,
                             localToolConfig.Output)
예제 #16
0
    def Process(self, currentDirPath: str, toolConfig: ToolConfig,
                localToolConfig: LocalToolConfig) -> None:
        config = Config(self.Log, toolConfig,
                        localToolConfig.PackageConfigurationType,
                        localToolConfig.BuildVariantsDict,
                        localToolConfig.AllowDevelopmentPlugins)

        # create a config we control and that can be used to just build the tool recipe's
        configToolCheck = Config(self.Log, toolConfig,
                                 PluginSharedValues.TYPE_DEFAULT,
                                 localToolConfig.BuildVariantsDict,
                                 localToolConfig.AllowDevelopmentPlugins)
        if localToolConfig.DryRun:
            config.ForceDisableAllWrite()
            configToolCheck.ForceDisableAllWrite()

        self.__CheckUserArgs(localToolConfig.ClangFormatArgs, "formatArgs")
        self.__CheckUserArgs(localToolConfig.ClangTidyArgs, "tidyArgs")
        self.__CheckUserArgs(localToolConfig.ClangTidyPostfixArgs,
                             "tidyPostfixArgs")

        applyClangFormat = toolConfig.ClangFormatConfiguration is not None and localToolConfig.ClangFormat
        applyClangTidy = toolConfig.ClangTidyConfiguration is not None and localToolConfig.ClangTidy

        if localToolConfig.IgnoreNotSupported or (
            (localToolConfig.ScanSource or applyClangFormat)
                and not applyClangTidy):
            config.IgnoreNotSupported = True
            configToolCheck.IgnoreNotSupported = True

        packageFilters = localToolConfig.BuildPackageFilters

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

        packageRecipeResultManager = None  # type: Optional[PackageRecipeResultManager]
        toolPackageNames = []
        if applyClangFormat or applyClangTidy:
            if applyClangFormat:
                if toolConfig.ClangFormatConfiguration is None:
                    raise Exception("internal error")
                toolPackageNames.append(
                    toolConfig.ClangFormatConfiguration.RecipePackageName)
            if applyClangTidy:
                if toolConfig.ClangTidyConfiguration is None:
                    raise Exception("internal error")
                toolPackageNames.append(
                    toolConfig.ClangTidyConfiguration.RecipePackageName)
            packageRecipeResultManager = ForceCheckBuildTools(
                configToolCheck, generatorContext, toolPackageNames)

        searchDir = currentDirPath
        if localToolConfig.File is not None and IOUtil.IsAbsolutePath(
                localToolConfig.File):
            searchDir = IOUtil.GetDirectoryName(localToolConfig.File)
        closestGenFilePath = FileFinder.TryFindClosestFileInRoot(
            config, toolConfig, searchDir, config.GenFileName)
        if closestGenFilePath is None:
            closestGenFilePath = searchDir

        if (self.Log.Verbosity >= 4):
            self.Log.LogPrint("Closest '{0}' file path: '{1}'".format(
                toolConfig.GenFileName, closestGenFilePath))

        packageProcess = None  # type: Optional[MainFlow.PackageLoadAndResolveProcess]
        packages = None
        discoverFeatureList = '*' in packageFilters.FeatureNameList
        if discoverFeatureList or localToolConfig.Project is None or localToolConfig.ScanSource or applyClangFormat or applyClangTidy:
            if discoverFeatureList:
                config.LogPrint(
                    "No features specified, so using package to determine them"
                )
            if localToolConfig.ScanSource or applyClangFormat or applyClangTidy or discoverFeatureList:
                packageProcess = self.__CreatePackageProcess(
                    config, toolConfig.GetMinimalConfig(), closestGenFilePath,
                    localToolConfig.Recursive, generatorContext.Platform,
                    toolPackageNames)
                packageProcess.Resolve(generatorContext, packageFilters,
                                       applyClangTidy, False)
                packages = packageProcess.Packages
                topLevelPackage = PackageListUtil.GetTopLevelPackage(packages)
                if discoverFeatureList:
                    packageFilters.FeatureNameList = [
                        entry.Name
                        for entry in topLevelPackage.ResolvedAllUsedFeatures
                    ]

        customPackageFileFilter = None  # type: Optional[CustomPackageFileFilter]
        if not localToolConfig.ScanSource and not applyClangFormat and not applyClangTidy:
            Validate.ValidatePlatform(config, localToolConfig.PlatformName,
                                      packageFilters.FeatureNameList)
            if packageProcess is None:
                packageProcess = self.__CreatePackageProcess(
                    config, toolConfig.GetMinimalConfig(), closestGenFilePath,
                    localToolConfig.Recursive, generatorContext.Platform,
                    toolPackageNames)
            if not packageProcess.IsFullResolve or packages is None:
                # For now this requires a full resolve (but basically it only requires basic + files)
                packages = packageProcess.Resolve(generatorContext,
                                                  packageFilters,
                                                  applyClangTidy, True)

            topLevelPackage = PackageListUtil.GetTopLevelPackage(packages)
            RecipeBuilder.ValidateInstallationForPackages(
                config, generatorContext, topLevelPackage.ResolvedBuildOrder)
        else:
            if localToolConfig.File is not None:
                # Delay extension validation
                customPackageFileFilter = CustomPackageFileFilter(
                    localToolConfig.File)

        theTopLevelPackage = None  # type: Optional[Package]
        filteredPackageList = []  # type: List[Package]
        if applyClangTidy or applyClangFormat or localToolConfig.ScanSource:
            addExternals = applyClangTidy
            filteredPackageList, theTopLevelPackage = self.__PreparePackages(
                self.Log, localToolConfig, packageProcess, generatorContext,
                packageFilters, addExternals, packages, config.IsSDKBuild,
                applyClangTidy, config)
            if len(filteredPackageList) <= 0:
                self.Log.DoPrint("No supported packages left to process")
                return

        if applyClangTidy:
            self.__ApplyClangTidy(self.Log, toolConfig, localToolConfig,
                                  packageRecipeResultManager,
                                  theTopLevelPackage, filteredPackageList,
                                  platform, config, generatorContext,
                                  customPackageFileFilter)

        if applyClangFormat:
            self.__ApplyClangFormat(self.Log, toolConfig, localToolConfig,
                                    packageRecipeResultManager,
                                    filteredPackageList,
                                    customPackageFileFilter)

        # Scan source after 'format' to ensure we dont warn about stuff that has been fixed
        if localToolConfig.ScanSource:
            self.__ApplyScanSource(self.Log, localToolConfig,
                                   config.IsSDKBuild, config.DisableWrite,
                                   filteredPackageList,
                                   customPackageFileFilter)
예제 #17
0
def __TestGetPackageLoader(config: Config, files: List[str], platformId: str) -> PackageLoader:
    packageFilters = PackageFilters()
    platformGeneratorPlugin = PluginConfig.GetGeneratorPluginById(platformId, True)
    return PackageLoader(config, files, platformGeneratorPlugin)
예제 #18
0
    def __ToolMainEx(self,
                     currentDir: str,
                     toolConfig: ToolConfig,
                     localToolConfig: LocalToolConfig,
                     templateDict: Dict[str, List[XmlNewTemplateFile]],
                     performSanityCheck: bool = False) -> None:

        config = Config(self.Log, toolConfig, 'sdk',
                        localToolConfig.BuildVariantsDict,
                        localToolConfig.AllowDevelopmentPlugins)
        #config.ForceDisableAllWrite()

        config.PrintTitle()

        packageFilters = localToolConfig.BuildPackageFilters

        reservedProjectNames = set()  # type: Set[str]
        packages = None  # type: Optional[List[Package]]
        if not localToolConfig.NoParse:
            # Get the platform and see if its supported
            platform = PluginConfig.GetGeneratorPluginById(
                localToolConfig.PlatformName, False)
            PlatformUtil.CheckBuildPlatform(platform.Name)
            config.LogPrint("Active platform: {0}".format(platform.Name))
            generatorContext = GeneratorContext(config,
                                                config.ToolConfig.Experimental,
                                                platform)
            packages = ParsePackages(generatorContext, config,
                                     toolConfig.GetMinimalConfig(), currentDir,
                                     packageFilters)

        # Reserve the name of all packages
        if not packages is None:
            for package in packages:
                reservedProjectNames.add(package.Name)

        currentDir, projectName = DetermineDirAndProjectName(
            currentDir, localToolConfig.ProjectName)
        localConfig = LocalConfig(config, currentDir, projectName,
                                  localToolConfig.Template,
                                  localToolConfig.Force, templateDict,
                                  reservedProjectNames,
                                  localToolConfig.Language)
        configVariant = localConfig.ConfigVariant

        if not localToolConfig.AllowOverwrite:
            if os.path.isdir(configVariant.ProjectPath):
                raise EnvironmentError(
                    "The project directory already exist: '{0}', you can use '{1}' to overwrite it."
                    .format(configVariant.ProjectPath, g_allowOverwriteOption))
            elif os.path.exists(configVariant.ProjectPath):
                raise EnvironmentError(
                    "A file named '{0}' already exist, you can use '{1}' to overwrite it."
                    .format(configVariant.ProjectPath, g_allowOverwriteOption))

        visualStudioGUID = localToolConfig.VisualStudioGUID
        if packages:
            visualStudioGUID = GenerateGUID(config, packages, visualStudioGUID)

        GenerateProject(config, localConfig, configVariant, visualStudioGUID,
                        localToolConfig.GenFileOnly)

        if not localToolConfig.NoBuildGen:
            config.DoPrint("Generating build files")
            projectConfig = Config(self.Log, toolConfig,
                                   PluginSharedValues.TYPE_DEFAULT,
                                   localToolConfig.BuildVariantsDict,
                                   localToolConfig.AllowDevelopmentPlugins)

            theFiles = MainFlow.DoGetFiles(projectConfig,
                                           toolConfig.GetMinimalConfig(),
                                           configVariant.ProjectPath)
            platformGeneratorPlugin = PluginConfig.GetGeneratorPluginById(
                localToolConfig.PlatformName, False)
            MainFlow.DoGenerateBuildFiles(projectConfig, theFiles,
                                          platformGeneratorPlugin,
                                          packageFilters)

            if performSanityCheck:
                self.__PerformSanityCheck(config, currentDir,
                                          localConfig.ProjectName,
                                          localConfig.Template)
예제 #19
0
def __RunStandalone(appFlowFactory: AToolAppFlowFactory, strToolAppTitle: str,
                    toolCommonArgConfig: ToolCommonArgConfig,
                    lowLevelToolConfig: LowLevelToolConfig) -> None:
    log = Log(strToolAppTitle,
              lowLevelToolConfig.VerbosityLevel,
              showAppTitleIfVerbose=True)

    pluginConfigContext = PluginConfig.InitPluginConfigContext(
        log, CurrentVersion, lowLevelToolConfig.AllowDevelopmentPlugins)
    generatorIds = __PrepareGeneratorPlugins(pluginConfigContext,
                                             lowLevelToolConfig,
                                             toolCommonArgConfig)

    ### Do the actual command line parsing
    parser = __CreateParser(toolCommonArgConfig, True)
    if toolCommonArgConfig.AddPlatformArg:
        parser.add_argument('-p',
                            '--platform',
                            required=True,
                            help='Select build platform: {0}'.format(
                                ", ".join(generatorIds)))

    buildTiming = None
    errorHelpManager = ErrorHelpManager()
    try:
        userTag = appFlowFactory.CreateStandaloneUserTag()
        appFlowFactory.AddCustomStandaloneArguments(parser, userTag)

        args = parser.parse_args()

        if toolCommonArgConfig.ProcessRemainingArgs:
            args.RemainingArgs = __ProcessRemainingArgs(args.RemainingArgs)
        if toolCommonArgConfig.SupportBuildTime and args.BuildTime:
            buildTiming = BuildTimer()

        currentDir = lowLevelToolConfig.CurrentDir

        toolAppConfig = __CreateToolAppConfig(args, args.platform,
                                              toolCommonArgConfig, 0)
        toolAppContext = ToolAppContext(log, errorHelpManager,
                                        lowLevelToolConfig, toolAppConfig,
                                        pluginConfigContext)
        toolAppFlow = appFlowFactory.Create(toolAppContext)

        toolAppFlow.ProcessFromStandaloneCommandLine(args, currentDir, userTag)

        if buildTiming:
            PrintBuildTiming(buildTiming)
    except GroupedException as ex:
        __OnErrorInfo(buildTiming, errorHelpManager)
        for entry in ex.ExceptionList:
            print("ERROR: {0}".format(entry))
        if lowLevelToolConfig.DebugEnabled:
            raise
        for entry in ex.ExceptionList:
            if isinstance(entry, ExitException):
                sys.exit(entry.ExitCode)
        sys.exit(1)
    except AggregateException as ex:
        __OnErrorInfo(buildTiming, errorHelpManager)
        for entry in ex.ExceptionList:
            print("ERROR: {0}".format(entry))
        if lowLevelToolConfig.DebugEnabled:
            if len(ex.ExceptionList) > 0:
                raise ex.ExceptionList[0]
            raise
        for entry in ex.ExceptionList:
            if isinstance(entry, ExitException):
                sys.exit(entry.ExitCode)
        sys.exit(1)
    except ExitException as ex:
        __OnErrorInfo(buildTiming, errorHelpManager)
        sys.exit(ex.ExitCode)
    except Exception as ex:
        __OnErrorInfo(buildTiming, errorHelpManager)
        print("ERROR: {0}".format(ex))
        if lowLevelToolConfig.DebugEnabled:
            raise
        sys.exit(1)
예제 #20
0
    def Process(self, currentDirPath: str, toolConfig: ToolConfig,
                localToolConfig: LocalToolConfig) -> None:
        config = Config(self.Log, toolConfig, 'sdk',
                        localToolConfig.BuildVariantsDict,
                        localToolConfig.AllowDevelopmentPlugins)
        if localToolConfig.DryRun:
            config.ForceDisableAllWrite()

        if localToolConfig.ToCDepth < 1:
            localToolConfig.ToCDepth = 1
        elif localToolConfig.ToCDepth > 4:
            localToolConfig.ToCDepth = 4

        config.PrintTitle()

        # Get the generator and see if its supported
        generator = PluginConfig.GetGeneratorPluginById(
            localToolConfig.PlatformName, localToolConfig.Generator, False,
            config.ToolConfig.CMakeConfiguration,
            localToolConfig.GetUserCMakeConfig())
        PlatformUtil.CheckBuildPlatform(generator.PlatformName)

        config.LogPrint("Active platform: {0}".format(generator.PlatformName))

        packageFilters = localToolConfig.BuildPackageFilters

        theFiles = MainFlow.DoGetFiles(config, toolConfig.GetMinimalConfig(),
                                       currentDirPath,
                                       localToolConfig.Recursive)
        generatorContext = GeneratorContext(config,
                                            packageFilters.RecipeFilterManager,
                                            config.ToolConfig.Experimental,
                                            generator)
        packages = MainFlow.DoGetPackages(generatorContext, config, theFiles,
                                          packageFilters)
        #topLevelPackage = PackageListUtil.GetTopLevelPackage(packages)
        #featureList = [entry.Name for entry in topLevelPackage.ResolvedAllUsedFeatures]

        for projectContext in config.ToolConfig.ProjectInfo.Contexts:
            rootDir = self.__TryLocateRootDirectory(
                config.ToolConfig.RootDirectories, projectContext.Location)
            if rootDir is None:
                raise Exception(
                    "Root directory not found for location {0}".format(
                        projectContext.Location))
            readmePath = IOUtil.Join(rootDir.ResolvedPath, "README.md")
            packageReadMeLines = TryLoadReadMe(config, readmePath)
            result = ProcessPackages(self.ToolAppContext, config, packages,
                                     rootDir, localToolConfig.ExtractArguments,
                                     toolConfig.BuildDocConfiguration,
                                     currentDirPath)
            if packageReadMeLines is not None:
                projectCaption = "# {0} {1}".format(
                    projectContext.ProjectName, projectContext.ProjectVersion)
                packageReadMeLinesNew = TryReplaceSection(
                    config, packageReadMeLines, "AG_PROJECT_CAPTION",
                    [projectCaption], readmePath)
                if packageReadMeLinesNew is not None:
                    packageReadMeLines = packageReadMeLinesNew

                packageReadMeLinesNew = TryReplaceSection(
                    config, packageReadMeLines, "AG_DEMOAPPS", result,
                    readmePath)
                if packageReadMeLinesNew is not None:
                    packageReadMeLines = packageReadMeLinesNew

                packageReadMeLinesNew = TryInsertTableOfContents(
                    config, packageReadMeLines, localToolConfig.ToCDepth,
                    readmePath)
                if packageReadMeLinesNew is not None:
                    packageReadMeLines = packageReadMeLinesNew

                SaveReadMe(config, readmePath, packageReadMeLines)
            elif config.Verbosity > 2:
                config.LogPrintWarning("No README.md found in {0}".format(
                    rootDir.ResolvedPath))
예제 #21
0
    def Process(self, currentDirPath: str, toolConfig: ToolConfig,
                localToolConfig: LocalToolConfig) -> None:
        config = Config(self.Log, toolConfig,
                        localToolConfig.PackageConfigurationType,
                        localToolConfig.BuildVariantsDict,
                        localToolConfig.AllowDevelopmentPlugins)

        #if localToolConfig.DryRun:
        #    config.ForceDisableAllWrite()
        if localToolConfig.IgnoreNotSupported:
            config.IgnoreNotSupported = True

        self.Log.PrintTitle()

        packageFilters = localToolConfig.BuildPackageFilters

        generator = PluginConfig.GetGeneratorPluginById(
            localToolConfig.PlatformName, False)

        theFiles = MainFlow.DoGetFiles(config, toolConfig.GetMinimalConfig(),
                                       currentDirPath,
                                       localToolConfig.Recursive)
        generatorContext = GeneratorContext(config,
                                            config.ToolConfig.Experimental,
                                            generator)
        packages = MainFlow.DoGetPackages(generatorContext,
                                          config,
                                          theFiles,
                                          packageFilters,
                                          autoAddRecipeExternals=False)

        topLevelPackage = PackageListUtil.GetTopLevelPackage(packages)
        requestedFiles = None if config.IsSDKBuild else theFiles

        if localToolConfig.SaveJson is not None:
            if localToolConfig.BuildPackageFilters.ExtensionNameList is None:
                raise Exception(
                    "Invalid config missing ExtensionNameList filters")
            config.LogPrint("Saving to json file '{0}'".format(
                localToolConfig.SaveJson))

            generatorConfig = GeneratorConfig(config.SDKConfigTemplatePath,
                                              config.ToolConfig)
            InfoSaver.SavePackageMetaDataToJson(
                generatorContext, generatorConfig, localToolConfig.SaveJson,
                config, topLevelPackage, localToolConfig.PackageTypeList,
                localToolConfig.IncludeGeneratorReport)

        if localToolConfig.ListFeatures:
            Builder.ShowFeatureList(self.Log, config, topLevelPackage,
                                    requestedFiles)
        if localToolConfig.ListVariants:
            requestedFiles = None if config.IsSDKBuild else theFiles
            Builder.ShowVariantList(self.Log, topLevelPackage, requestedFiles,
                                    generator)
        if localToolConfig.ListBuildVariants:
            Builder.ShowBuildVariantList(self.Log, generator)
        if localToolConfig.ListExtensions:
            Builder.ShowExtensionList(self.Log, topLevelPackage,
                                      requestedFiles)
        if localToolConfig.ListRequirements:
            Builder.ShowRequirementList(self.Log, config, topLevelPackage,
                                        requestedFiles)
        if localToolConfig.ListRecipes:
            RecipeInfo.ShowRecipeList(self.Log, topLevelPackage,
                                      requestedFiles)