protected BaseApplication(
Func <IHostBuilder, IHostBuilder>?configureHost = null,
Action <IServiceCollection>?configureServices = null,
Action <HostBuilderContext, ILoggingBuilder>?configureLogging = null,
string?alreadyRunningMessage = null,
int waitAfterOldInstanceKillMilliseconds = 0,
NewInstanceHandling newInstanceHandling = NewInstanceHandling.Restart,
CultureInfo?startupCulture = null)
{
var cultureManager = new CultureManager();
var applicationTerminator = new ApplicationTerminator();
var assemblyInfoProvider = new AssemblyInfoProvider(new EntryAssemblyProvider(), new SpecialPathsProvider());
_applicationBootstrapper = new ApplicationStartupBootstrapper(
cultureManager,
applicationTerminator,
ShowMessage,
CreateMutex,
RegisterDependencies,
assemblyInfoProvider,
configureHost,
configureServices,
configureLogging,
alreadyRunningMessage,
waitAfterOldInstanceKillMilliseconds,
newInstanceHandling,
startupCulture);
DispatcherUnhandledException += App_DispatcherUnhandledException;
}
public void UnityEngineExtensionAssemblyPathIsFound(string assemblyName)
{
var paths = AssemblyInfoProvider.GetPrecompiledAssemblyPaths(PrecompiledAssemblyTypes.UnityEngine);
var result = paths.FirstOrDefault(path => path.EndsWith(assemblyName));
Assert.NotNull(result);
}
internal static Payload GetDefaultPayload()
{
var taskContext = new TaskContext()
{
StageId = 1,
PartitionId = 2,
AttemptNumber = 1,
AttemptId = 100L,
Port = 9999,
Secret = "secret"
};
var broadcastVars = new BroadcastVariables()
{
DecryptionServerNeeded = true,
DecryptionServerPort = 9999,
Secret = "secret"
};
return(new Payload()
{
SplitIndex = 10,
Version = AssemblyInfoProvider.MicrosoftSparkAssemblyInfo().AssemblyVersion,
TaskContext = taskContext,
SparkFilesDir = "directory",
IncludeItems = new[] { "file1", "file2" },
BroadcastVariables = broadcastVars
});
}
public void PackageAssemblyPathIsFound()
{
// check mono cecil is found
var paths = AssemblyInfoProvider.GetPrecompiledAssemblyPaths(PrecompiledAssemblyTypes.UserAssembly);
var result = paths.FirstOrDefault(path => path.EndsWith("Mono.Cecil.dll"));
Assert.NotNull(result);
}
public void UnityEngineAssemblyPathIsFound(string assemblyRelativePath)
{
var paths = AssemblyInfoProvider.GetPrecompiledAssemblyPaths(PrecompiledAssemblyTypes.UnityEngine);
var expectedPath = EditorApplication.applicationContentsPath + assemblyRelativePath;
var result = paths.FirstOrDefault(path => path.Equals(expectedPath));
Assert.NotNull(result);
}
private AssemblyInfo ReadAssemblyInfo(string assemblyInfoFile)
{
using (var stream = new MemoryStream(Encoding.UTF8.GetBytes(assemblyInfoFile)))
{
var assemblyInfoProvider = new AssemblyInfoProvider();
return(assemblyInfoProvider.ReadAssemblyInfo(stream));
}
}
private string WriteAssemblyInfoFile(AssemblyInfo assemblyInfo, string sourceFile)
{
using (var inputStream = new MemoryStream(Encoding.UTF8.GetBytes(sourceFile)))
{
var assemblyInfoProvider = new AssemblyInfoProvider();
return(assemblyInfoProvider.MergeAssemblyInfo(assemblyInfo, inputStream));
}
}
public void CanResolveDefaultAssemblyAssetPath()
{
var assembly = CompilationPipeline.GetAssemblies(AssembliesType.Player).FirstOrDefault(a => a.name.Equals(Path.GetFileNameWithoutExtension(AssemblyInfo.DefaultAssemblyFileName)));
var assemblyInfo = AssemblyInfoProvider.GetAssemblyInfoFromAssemblyPath(assembly.outputPath);
var path = AssemblyInfoProvider.ResolveAssetPath(assemblyInfo, Path.Combine(Application.dataPath, "somefile"));
Assert.True(path.Equals("Assets/somefile"));
}
public void DefaultAssemblyInfoIsCorrect()
{
var assembly = CompilationPipeline.GetAssemblies(AssembliesType.Player).FirstOrDefault(a => a.name.Equals(Path.GetFileNameWithoutExtension(AssemblyInfo.DefaultAssemblyFileName)));
var assemblyInfo = AssemblyInfoProvider.GetAssemblyInfoFromAssemblyPath(assembly.outputPath);
Assert.IsTrue(assemblyInfo.path.Equals("Library/ScriptAssemblies/Assembly-CSharp.dll"));
Assert.IsNull(assemblyInfo.asmDefPath);
Assert.IsFalse(assemblyInfo.readOnly);
}
public void PackageAssemblyInfoIsCorrect()
{
var assembly = CompilationPipeline.GetAssemblies(AssembliesType.Editor).FirstOrDefault(a => a.name.Equals("Unity.ProjectAuditor.Editor"));
var assemblyInfo = AssemblyInfoProvider.GetAssemblyInfoFromAssemblyPath(assembly.outputPath);
Assert.IsTrue(assemblyInfo.path.Equals("Library/ScriptAssemblies/Unity.ProjectAuditor.Editor.dll"));
Assert.IsTrue(assemblyInfo.asmDefPath.Equals(Unity.ProjectAuditor.Editor.ProjectAuditor.PackagePath + "/Editor/Unity.ProjectAuditor.Editor.asmdef"));
Assert.IsTrue(assemblyInfo.relativePath.Equals(Unity.ProjectAuditor.Editor.ProjectAuditor.PackagePath));
}
protected override void Load(MSBuildBasedProject project, string configuration, string platform)
{
var assemblyInfoFileName = GetAssemblyInfoFileName(project);
if (string.IsNullOrEmpty(assemblyInfoFileName))
{
assemblyInfo = new AssemblyInfo();
MessageService.ShowError("${res:Dialog.ProjectOptions.AssemblyInfo.AssemblyInfoNotFound}");
}
else
{
var assemblyInfoProvider = new AssemblyInfoProvider();
assemblyInfo = assemblyInfoProvider.ReadAssemblyInfo(assemblyInfoFileName);
}
var assemblyInfoViewModel = new AssemblyInfoViewModel(assemblyInfo);
assemblyInfoViewModel.PropertyChanged += OnAssemblyInfoChanged;
DataContext = assemblyInfoViewModel;
base.Load(project, configuration, platform);
}
public ConfigurationServiceTests()
{
var version = new Version(AssemblyInfoProvider.MicrosoftSparkAssemblyInfo().AssemblyVersion);
_workerDirEnvVars = new WorkerDirEnvVars
{
WorkerDir = new EnvVar(ConfigurationService.DefaultWorkerDirEnvVarName),
WorkerMajorMinorBuildDir = new EnvVar(
string.Format(
ConfigurationService.WorkerVerDirEnvVarNameFormat,
$"{version.Major}_{version.Minor}_{version.Build}")),
WorkerMajorMinorDir = new EnvVar(
string.Format(
ConfigurationService.WorkerVerDirEnvVarNameFormat,
$"{version.Major}_{version.Minor}")),
WorkerMajorDir = new EnvVar(
string.Format(ConfigurationService.WorkerVerDirEnvVarNameFormat, version.Major))
};
Environment.SetEnvironmentVariable(_workerDirEnvVars.WorkerDir.Name, null);
Environment.SetEnvironmentVariable(_workerDirEnvVars.WorkerMajorMinorBuildDir.Name, null);
Environment.SetEnvironmentVariable(_workerDirEnvVars.WorkerMajorMinorDir.Name, null);
Environment.SetEnvironmentVariable(_workerDirEnvVars.WorkerMajorDir.Name, null);
}
void AnalyzeMethodBody(AssemblyInfo assemblyInfo, MethodDefinition caller, Action <CallInfo> onCallFound, Action <ProjectIssue> onIssueFound)
{
if (!caller.DebugInformation.HasSequencePoints)
{
return;
}
Profiler.BeginSample("ScriptAuditor.AnalyzeMethodBody");
var callerNode = new CallTreeNode(caller);
var perfCriticalContext = IsPerformanceCriticalContext(caller);
foreach (var inst in caller.Body.Instructions.Where(i => m_OpCodes.Contains(i.OpCode)))
{
SequencePoint s = null;
for (var i = inst; i != null; i = i.Previous)
{
s = caller.DebugInformation.GetSequencePoint(i);
if (s != null)
{
break;
}
}
Location location = null;
if (s != null && !s.IsHidden)
{
location = new Location(AssemblyInfoProvider.ResolveAssetPath(assemblyInfo, s.Document.Url), s.StartLine);
callerNode.location = location;
}
else
{
// sequence point not found. Assuming caller.IsHideBySig == true
}
if (inst.OpCode == OpCodes.Call || inst.OpCode == OpCodes.Callvirt)
{
onCallFound(new CallInfo
{
callee = (MethodReference)inst.Operand,
caller = caller,
location = location,
perfCriticalContext = perfCriticalContext
});
}
foreach (var analyzer in m_Analyzers)
{
if (analyzer.GetOpCodes().Contains(inst.OpCode))
{
var projectIssue = analyzer.Analyze(caller, inst);
if (projectIssue != null)
{
projectIssue.dependencies.perfCriticalContext = perfCriticalContext;
projectIssue.dependencies.AddChild(callerNode);
projectIssue.location = location;
projectIssue.SetCustomProperties(new[] { assemblyInfo.name });
onIssueFound(projectIssue);
}
}
}
}
Profiler.EndSample();
}
public void Audit(Action <ProjectIssue> onIssueFound, Action onComplete, IProgressBar progressBar = null)
{
if (m_ProblemDescriptors == null)
{
throw new Exception("Issue Database not initialized.");
}
if (m_Config.AnalyzeInBackground && m_AssemblyAnalysisThread != null)
{
m_AssemblyAnalysisThread.Join();
}
var compilationPipeline = new AssemblyCompilationPipeline
{
AssemblyCompilationFinished = (assemblyName, compilerMessages) => ProcessCompilerMessages(assemblyName, compilerMessages, onIssueFound)
};
Profiler.BeginSample("ScriptAuditor.Audit.Compilation");
var assemblyInfos = compilationPipeline.Compile(m_Config.AnalyzeEditorCode, progressBar);
Profiler.EndSample();
var callCrawler = new CallCrawler();
var issues = new List <ProjectIssue>();
var localAssemblyInfos = assemblyInfos.Where(info => !info.readOnly).ToArray();
var readOnlyAssemblyInfos = assemblyInfos.Where(info => info.readOnly).ToArray();
var assemblyDirectories = new List <string>();
assemblyDirectories.AddRange(AssemblyInfoProvider.GetPrecompiledAssemblyDirectories(PrecompiledAssemblyTypes.UserAssembly | PrecompiledAssemblyTypes.UnityEngine));
if (m_Config.AnalyzeEditorCode)
{
assemblyDirectories.AddRange(AssemblyInfoProvider.GetPrecompiledAssemblyDirectories(PrecompiledAssemblyTypes.UnityEditor));
}
var onCallFound = new Action <CallInfo>(pair =>
{
callCrawler.Add(pair);
});
var onCompleteInternal = new Action <IProgressBar>(bar =>
{
compilationPipeline.Dispose();
callCrawler.BuildCallHierarchies(issues, bar);
onComplete();
});
var onIssueFoundInternal = new Action <ProjectIssue>(issue =>
{
if (issue.category == IssueCategory.Code)
{
issues.Add(issue);
}
onIssueFound(issue);
});
Profiler.BeginSample("ScriptAuditor.Audit.Analysis");
// first phase: analyze assemblies generated from editable scripts
AnalyzeAssemblies(localAssemblyInfos, assemblyDirectories, onCallFound, onIssueFoundInternal, null, progressBar);
var enableBackgroundAnalysis = m_Config.AnalyzeInBackground;
#if !UNITY_2019_3_OR_NEWER
enableBackgroundAnalysis = false;
#endif
// second phase: analyze all remaining assemblies, in a separate thread if enableBackgroundAnalysis is enabled
if (enableBackgroundAnalysis)
{
m_AssemblyAnalysisThread = new Thread(() =>
AnalyzeAssemblies(readOnlyAssemblyInfos, assemblyDirectories, onCallFound, onIssueFoundInternal, onCompleteInternal));
m_AssemblyAnalysisThread.Name = "Assembly Analysis";
m_AssemblyAnalysisThread.Priority = ThreadPriority.BelowNormal;
m_AssemblyAnalysisThread.Start();
}
else
{
Profiler.BeginSample("ScriptAuditor.Audit.AnalysisReadOnly");
AnalyzeAssemblies(readOnlyAssemblyInfos, assemblyDirectories, onCallFound, onIssueFoundInternal, onCompleteInternal, progressBar);
Profiler.EndSample();
}
Profiler.EndSample();
}
public void RegistryPackageAssemblyIsReadOnly()
{
Assert.IsTrue(AssemblyInfoProvider.IsReadOnlyAssembly("UnityEngine.TestRunner"));
}
protected override bool Save(MSBuildBasedProject project, string configuration, string platform)
{
if (!CheckForValidationErrors())
{
return false;
}
var assemblyInfoFileName = GetAssemblyInfoFileName(project);
if (!string.IsNullOrEmpty(assemblyInfoFileName))
{
if (assemblyInfo != null)
{
var assemblyInfoProvider = new AssemblyInfoProvider();
assemblyInfoProvider.MergeAssemblyInfo(assemblyInfo, assemblyInfoFileName);
}
}
else
{
MessageService.ShowError("${res:Dialog.ProjectOptions.AssemblyInfo.AssemblyInfoNotFound}");
}
return base.Save(project, configuration, platform);
}
private string WriteAssemblyInfoFile(AssemblyInfo assemblyInfo, string sourceFile)
{
using (var inputStream = new MemoryStream(Encoding.UTF8.GetBytes(sourceFile)))
{
var assemblyInfoProvider = new AssemblyInfoProvider();
return assemblyInfoProvider.MergeAssemblyInfo(assemblyInfo, inputStream);
}
}
private AssemblyInfo ReadAssemblyInfo(string assemblyInfoFile)
{
using (var stream = new MemoryStream(Encoding.UTF8.GetBytes(assemblyInfoFile)))
{
var assemblyInfoProvider = new AssemblyInfoProvider();
return assemblyInfoProvider.ReadAssemblyInfo(stream);
}
}
public WepApiLauncher(
Action <ContainerBuilder, IConfiguration>?registerDependencies = null,
Func <IHostBuilder, IHostBuilder>?configureHost = null,
Action <IServiceCollection>?configureServices = null,
Action <HostBuilderContext, ILoggingBuilder>?configureLogging = null,
string?alreadyRunningMessage = null,
int waitAfterOldInstanceKillMilliseconds = 0,
NewInstanceHandling newInstanceHandling = NewInstanceHandling.AllowMultiple,
CultureInfo?startupCulture = null,
Assembly?webApiAssembly = null,
IReadOnlyCollection <Assembly>?additionalXmlCommentsAssemblies = null)
{
IConfiguration?configuration = null;
var cultureManager = new ConsoleCultureManager();
var applicationTerminator = new ConsoleApplicationTerminator();
_assemblyInfoProvider = new AssemblyInfoProvider(new EntryAssemblyProvider(), new SpecialPathsProvider());
webApiAssembly ??= Assembly.GetCallingAssembly();
var baseDirectory = Path.GetDirectoryName(Process.GetCurrentProcess().MainModule?.FileName) ?? throw new InvalidOperationException("Cannot get base directory");
Directory.SetCurrentDirectory(baseDirectory);
_applicationBootstrapper = new ApplicationStartupBootstrapper(
cultureManager,
applicationTerminator,
message => { },
CreateMutex,
containerBuilder => registerDependencies?.Invoke(containerBuilder, configuration ?? throw new InvalidOperationException("Configuration was not initialized")),
_assemblyInfoProvider,
hostBuilder =>
{
configureHost?.Invoke(hostBuilder);
hostBuilder.UseConsoleLifetime();
return(ApiHostingHelper.RegisterWebApiHost(hostBuilder, baseDirectory: baseDirectory, applicationKey: webApiAssembly.GetName().Name));
},
services =>
{
// Build the intermediate service provider
var sp = services.BuildServiceProvider();
configuration = sp.GetRequiredService <IConfiguration>();
var appSettings = configuration.GetSection("AppSettings");
var appName = appSettings[AppSettingsConstants.AppNameKey];
var appVersion = appSettings[AppSettingsConstants.AppVersionKey];
ApiHostingHelper.RegisterServices(
services,
webApiAssembly,
configureMvc: mvcBuilder => mvcBuilder.AddJsonOptions(
options =>
{
options.JsonSerializerOptions.PropertyNamingPolicy = JsonNamingPolicy.CamelCase;
options.JsonSerializerOptions.Converters.Add(new JsonStringEnumConverter(JsonNamingPolicy.CamelCase));
}),
configureSwagger: swaggerGenOptions =>
{
swaggerGenOptions.SwaggerDoc("v1", new OpenApiInfo {
Title = appName, Version = appVersion
});
var xmlDocAssemblies = new List <Assembly>
{
webApiAssembly
};
if (additionalXmlCommentsAssemblies != null)
{
xmlDocAssemblies.AddRange(additionalXmlCommentsAssemblies);
}
foreach (var xmlFilePath in xmlDocAssemblies.Select(assembly => assembly.GetName().Name + ".xml")
.Select(xmlFileName => Path.Combine(baseDirectory, xmlFileName))
.Where(File.Exists))
{
swaggerGenOptions.IncludeXmlComments(xmlFilePath);
}
// If there are two similar routes - this will fix the collision by choosing the first one
swaggerGenOptions.ResolveConflictingActions(apiDescriptions => apiDescriptions.First());
})
.Configure <ConsoleLifetimeOptions>(options => options.SuppressStatusMessages = true)
.AddHttpContextAccessor();
configureServices?.Invoke(services);
},
(hostBuilderContext, loggingBuilder) =>
{
SetupLogging(baseDirectory, hostBuilderContext.HostingEnvironment.EnvironmentName, LogEventLevel.Debug);
loggingBuilder.AddSerilog();
configureLogging?.Invoke(hostBuilderContext, loggingBuilder);
},
alreadyRunningMessage,
waitAfterOldInstanceKillMilliseconds,
newInstanceHandling,
startupCulture,
baseDirectory);
_applicationBootstrapper.BeforeStart();
Configuration = configuration ?? throw new InvalidOperationException("Configuration was not initialized");
}
void UpdateAssemblySelection()
{
if (m_AssemblyNames == null)
{
return;
}
if (m_AssemblySelection == null)
{
m_AssemblySelection = new TreeViewSelection();
}
m_AssemblySelection.selection.Clear();
if (!string.IsNullOrEmpty(m_AssemblySelectionSummary))
{
if (m_AssemblySelectionSummary == "All")
{
m_AssemblySelection.SetAll(m_AssemblyNames);
}
else if (m_AssemblySelectionSummary != "None")
{
var assemblies = m_AssemblySelectionSummary.Split(new[] { ", " }, StringSplitOptions.None)
.Where(assemblyName => m_AssemblyNames.Contains(assemblyName));
if (assemblies.Count() > 0)
{
foreach (var assembly in assemblies)
{
m_AssemblySelection.selection.Add(assembly);
}
}
}
}
if (!m_AssemblySelection.selection.Any())
{
// initial selection setup:
// - assemblies from user scripts or editable packages, or
// - default assembly, or,
// - all generated assemblies
var compiledAssemblies = m_AssemblyNames.Where(a => !AssemblyInfoProvider.IsUnityEngineAssembly(a));
compiledAssemblies = compiledAssemblies.Where(a =>
!AssemblyInfoProvider.IsReadOnlyAssembly(a));
m_AssemblySelection.selection.AddRange(compiledAssemblies);
if (!m_AssemblySelection.selection.Any())
{
if (m_AssemblyNames.Contains(AssemblyInfo.DefaultAssemblyName))
{
m_AssemblySelection.Set(AssemblyInfo.DefaultAssemblyName);
}
else
{
m_AssemblySelection.SetAll(m_AssemblyNames);
}
}
}
// update assembly selection summary
m_AssemblySelectionSummary = GetSelectedAssembliesSummary();
}
