public ActionResult CommandLineProcess(string cmd)
{
Server.ScriptTimeout = 3600;
object result;
if (string.IsNullOrEmpty(cmd))
{
result = new { Success = false, Message = "Missing command" }
}
;
else
{
var scriptResult = CommandLineUtility.Execute(cmd);
result = new { scriptResult.Success, scriptResult.Message, scriptResult.Data };
}
return(Json(result));
}
internal string GetSpatialPath()
{
string path;
// The command line overrides everything.
if (!CommandLineUtility.TryGetCommandLineValue(GetCommandLine(), SpatialPathArgument, out path))
{
// Then try the user-specific preferences
path = GetUserString(SpatialRunner.CommandLocationKey, string.Empty);
}
// If nothing has been configured, assume it's on the system PATH, and use a sensible default of "spatial"
if (string.IsNullOrEmpty(path))
{
path = DiscoverSpatialLocation(null);
}
return(path);
}
public override Task ExecuteCommandAsync()
{
// On mono, parallel builds are broken for some reason. See https://gist.github.com/4201936 for the errors
// That are thrown.
DisableParallelProcessing |= RuntimeEnvironmentHelper.IsMono;
if (DisableParallelProcessing)
{
HttpSourceResourceProvider.Throttle = SemaphoreSlimThrottle.CreateBinarySemaphore();
}
_CalculateEffectivePackageSaveModeInfo.Invoke(this, null);
_CalculateEffectiveSettingsInfo.Invoke(this, null);
var installPath = (string)_ResolveInstallPathInfo.Invoke(this, null);
var configFilePath = Path.GetFullPath(Arguments.Count == 0 ? Constants.PackageReferenceFile : Arguments[0]);
var configFileName = Path.GetFileName(configFilePath);
// If the first argument is a packages.xxx.config file, install everything it lists
// Otherwise, treat the first argument as a package Id
if (CommandLineUtility.IsValidConfigFileName(configFileName))
{
Prerelease = true;
// display opt-out message if needed
if (Console != null && RequireConsent &&
new NuGet.PackageManagement.PackageRestoreConsent(Settings).IsGranted)
{
var message = string.Format(
CultureInfo.CurrentCulture,
Local.RestoreCommandPackageRestoreOptOutMessage,
NuGetResources.PackageRestoreConsentCheckBoxText.Replace("&", ""));
Console.WriteLine(message);
}
return(PerformV2RestoreAsync(configFilePath, installPath));
}
else
{
throw new NotImplementedException();
}
}
private void InstallPackagesFromConfigFile(IFileSystem fileSystem, PackageReferenceFile configFile)
{
// display opt-out message if needed
if (Console != null && RequireConsent && new PackageRestoreConsent(Settings).IsGranted)
{
string message = String.Format(
CultureInfo.CurrentCulture,
LocalizedResourceManager.GetString("RestoreCommandPackageRestoreOptOutMessage"),
NuGet.Resources.NuGetResources.PackageRestoreConsentCheckBoxText.Replace("&", ""));
Console.WriteLine(message);
}
var packageReferences = CommandLineUtility.GetPackageReferences(configFile, requireVersion: true);
bool installedAny = ExecuteInParallel(fileSystem, packageReferences);
if (!installedAny && packageReferences.Any())
{
Console.WriteLine(LocalizedResourceManager.GetString("InstallCommandNothingToInstall"), Constants.PackageReferenceFile);
}
}
private void PushPackageCore(string source, string apiKey, PackageServer packageServer, string packageToPush, TimeSpan timeout)
{
// Push the package to the server
var package = new ZipPackage(packageToPush);
string sourceName = CommandLineUtility.GetSourceDisplayName(source);
Console.WriteLine(NuGetResources.PushCommandPushingPackage, package.GetFullName(), sourceName);
using (Stream stream = package.GetStream())
{
packageServer.PushPackage(apiKey, stream, Convert.ToInt32(timeout.TotalMilliseconds));
}
if (CreateOnly)
{
Console.WriteWarning(NuGetResources.Warning_PublishPackageDeprecated);
}
Console.WriteLine(NuGetResources.PushCommandPackagePushed);
}
private static ICollection <PackageReference> GetPackageReferencesInDirectory(string directory)
{
var packageReferences = new HashSet <PackageReference>();
var configFiles = Directory.GetFiles(directory, "packages*.config", SearchOption.AllDirectories)
.Where(f => Path.GetFileName(f).StartsWith("packages.", StringComparison.OrdinalIgnoreCase));
foreach (var configFile in configFiles)
{
PackageReferenceFile file = new PackageReferenceFile(configFile);
try
{
packageReferences.AddRange(CommandLineUtility.GetPackageReferences(file, requireVersion: true));
}
catch (InvalidOperationException)
{
// Skip the file if it is not a valid xml file.
}
}
return(packageReferences);
}
public override void ExecuteCommand()
{
//Frist argument should be the ApiKey
string apiKey = Arguments[0];
bool setSymbolServerKey = false;
//If the user passed a source use it for the gallery location
string galleryServerUrl;
if (String.IsNullOrEmpty(Source))
{
galleryServerUrl = GalleryServer.DefaultGalleryServerUrl;
// If no source was specified, set the default symbol server key to be the same
setSymbolServerKey = true;
}
else
{
CommandLineUtility.ValidateSource(Source);
galleryServerUrl = Source;
}
var settings = Settings.UserSettings;
settings.SetEncryptedValue(CommandLineUtility.ApiKeysSectionName, galleryServerUrl, apiKey);
// Setup the symbol server key
if (setSymbolServerKey)
{
settings.SetEncryptedValue(CommandLineUtility.ApiKeysSectionName, GalleryServer.DefaultSymbolServerUrl, apiKey);
Console.WriteLine(NuGetResources.SetApiKeyCommandDefaultApiKeysSaved,
apiKey,
CommandLineUtility.GetSourceDisplayName(galleryServerUrl),
CommandLineUtility.GetSourceDisplayName(GalleryServer.DefaultSymbolServerUrl));
}
else
{
Console.WriteLine(NuGetResources.SetApiKeyCommandApiKeySaved, apiKey, CommandLineUtility.GetSourceDisplayName(galleryServerUrl));
}
}
private string GetApiKey(string source)
{
if (!String.IsNullOrEmpty(ApiKey))
{
return(ApiKey);
}
string apiKey = null;
// Second argument, if present, should be the API Key
if (Arguments.Count > 1)
{
apiKey = Arguments[1];
}
// If the user did not pass an API Key look in the config file
if (String.IsNullOrEmpty(apiKey))
{
apiKey = CommandLineUtility.GetApiKey(Settings, source);
}
return(apiKey);
}
public override void ExecuteCommand()
{
if (NoPrompt)
{
Console.WriteWarning(NuGetResources.Warning_NoPromptDeprecated);
NonInteractive = true;
}
//First argument should be the package ID
string packageId = Arguments[0];
//Second argument should be the package Version
string packageVersion = Arguments[1];
//If the user passed a source use it for the gallery location
string source = SourceProvider.ResolveAndValidateSource(Source) ?? NuGetConstants.DefaultGalleryServerUrl;
var gallery = new PackageServer(source, CommandLineConstants.UserAgent);
//If the user did not pass an API Key look in the config file
string apiKey = GetApiKey(source);
string sourceDisplayName = CommandLineUtility.GetSourceDisplayName(source);
if (String.IsNullOrEmpty(apiKey))
{
Console.WriteWarning(NuGetResources.NoApiKeyFound, sourceDisplayName);
}
if (NonInteractive || Console.Confirm(String.Format(CultureInfo.CurrentCulture, NuGetResources.DeleteCommandConfirm, packageId, packageVersion, sourceDisplayName)))
{
Console.WriteLine(NuGetResources.DeleteCommandDeletingPackage, packageId, packageVersion, sourceDisplayName);
gallery.DeletePackage(apiKey, packageId, packageVersion);
Console.WriteLine(NuGetResources.DeleteCommandDeletedPackage, packageId, packageVersion);
}
else
{
Console.WriteLine(NuGetResources.DeleteCommandCanceled);
}
}
public void ParseArguments(string[] args)
{
MbUnit.Core.Monitoring.ConsoleMonitor consoleMonitor = new MbUnit.Core.Monitoring.ConsoleMonitor();
consoleMonitor.Start();
try
{
this.arguments = new MbUnitFormArguments();
if (args.Length == 0)
{
this.noArgs = true;
}
CommandLineUtility.ParseCommandLineArguments(args, arguments);
}
catch (Exception)
{
consoleMonitor.Stop();
MessageBox.Show(consoleMonitor.Out + consoleMonitor.Error);
return;
}
finally
{
consoleMonitor.Stop();
}
}
public void GetLocalizedString_ThrowsArgumentExceptionForEmptyName()
{
// Act & Assert
ExceptionAssert.ThrowsArgNullOrEmpty(() => CommandLineUtility.GetLocalizedString(typeof(string), ""), "resourceName");
}
public void ExecuteArguments()
{
if (this.arguments == null)
{
return;
}
System.Threading.Thread.Sleep(500);
try
{
if (this.arguments.Help)
{
MessageBox.Show(
CommandLineUtility.CommandLineArgumentsUsage(typeof(MbUnitFormArguments))
);
}
// load files or project if possible
if (this.arguments.Files != null)
{
foreach (string fileName in arguments.Files)
{
if (fileName.ToLower().EndsWith(".mbunit"))
{
this.Invoke(new LoadProjectDelegate(this.LoadProjectInvoker),
new object[] { fileName, false });
break;
}
this.treeView.AddAssembly(fileName);
}
}
// load last settings
if (ConfigurationSettings.AppSettings["restorePreviousState"] == "true" && this.noArgs)
{
this.Invoke(new LoadProjectDelegate(this.LoadProjectInvoker),
new object[] { previousSettings, true });
return;
}
// populate tree
this.treeView.ThreadedPopulateTree(false);
while (treeView.WorkerThreadAlive)
{
System.Threading.Thread.Sleep(100);
}
// run
if (this.arguments.Run)
{
this.treeView.ThreadedRunTests();
while (treeView.WorkerThreadAlive)
{
System.Threading.Thread.Sleep(100);
}
}
// generate report
foreach (ReportType reportType in this.arguments.ReportTypes)
{
switch (reportType)
{
case ReportType.Html:
this.treeView.GenerateHtmlReport(); break;
case ReportType.Text:
this.treeView.GenerateTextReport(); break;
case ReportType.Dox:
this.treeView.GenerateDoxReport(); break;
case ReportType.Xml:
this.treeView.GenerateXmlReport(); break;
}
}
// exit
if (this.arguments.Close)
{
System.Threading.Thread.Sleep(1000);
while (treeView.WorkerThreadAlive)
{
System.Threading.Thread.Sleep(100);
}
this.Close();
}
}
catch (Exception ex)
{
Console.WriteLine("Failure while executing arguments");
Console.WriteLine(ex.ToString());
throw new ApplicationException("Failure while executing arguments", ex);
}
}
public override void ExecuteCommand()
{
var manifest = new Manifest();
string projectFile = null;
string fileName = null;
if (!String.IsNullOrEmpty(AssemblyPath))
{
// Extract metadata from the assembly
string path = Path.Combine(Directory.GetCurrentDirectory(), AssemblyPath);
AssemblyMetadata metadata = AssemblyMetadataExtractor.GetMetadata(path);
manifest.Metadata.Id = metadata.Name;
manifest.Metadata.Version = metadata.Version.ToString();
manifest.Metadata.Authors = metadata.Company;
manifest.Metadata.Description = metadata.Description;
}
else
{
if (!CommandLineUtility.TryGetProjectFile(out projectFile))
{
manifest.Metadata.Id = Arguments.Any() ? Arguments[0] : "Package";
manifest.Metadata.Version = "1.0";
}
else
{
fileName = Path.GetFileNameWithoutExtension(projectFile);
manifest.Metadata.Id = "$id$";
manifest.Metadata.Version = "$version$";
manifest.Metadata.Description = "$description$";
manifest.Metadata.Authors = "$author$";
}
}
// Get the file name from the id or the project file
fileName = fileName ?? manifest.Metadata.Id;
// If we're using a project file then we want the a minimal nuspec
if (String.IsNullOrEmpty(projectFile))
{
manifest.Metadata.Description = manifest.Metadata.Description ?? "Package description";
if (String.IsNullOrEmpty(manifest.Metadata.Authors))
{
manifest.Metadata.Authors = Environment.UserName;
}
manifest.Metadata.Dependencies = new List <ManifestDependency>();
manifest.Metadata.Dependencies.Add(new ManifestDependency {
Id = "SampleDependency", Version = "1.0"
});
}
manifest.Metadata.ProjectUrl = "http://PROJECT_URL_HERE_OR_DELETE_THIS_LINE";
manifest.Metadata.LicenseUrl = "http://LICENSE_URL_HERE_OR_DELETE_THIS_LINE";
manifest.Metadata.IconUrl = "http://ICON_URL_HERE_OR_DELETE_THIS_LINE";
manifest.Metadata.Tags = "Tag1 Tag2";
string nuspecFile = fileName + Constants.ManifestExtension;
// Skip the creation if the file exists and force wasn't specified
if (File.Exists(nuspecFile) && !Force)
{
Console.WriteLine(NuGetResources.SpecCommandFileExists, nuspecFile);
}
else
{
try {
using (Stream stream = File.Create(nuspecFile)) {
manifest.Save(stream, validate: false);
}
Console.WriteLine(NuGetResources.SpecCommandCreatedNuSpec, nuspecFile);
}
catch {
// Cleanup the file if it fails to save for some reason
File.Delete(nuspecFile);
throw;
}
}
}
public void ChangeType_ThrowsIfTypeIsNull()
{
// Act & Assert
ExceptionAssert.ThrowsArgNull(() => CommandLineUtility.ChangeType(new object(), null), "type");
}
public void GetLocalizedString_ThrowsArgumentExceptionForNullType()
{
// Act & Assert
ExceptionAssert.ThrowsArgNull(() => CommandLineUtility.GetLocalizedString(null, "foo"), "resourceType");
}
public void Awake()
{
InitializeWorkerTypes();
// Taken from DefaultWorldInitalization.cs
SetupInjectionHooks(); // Register hybrid injection hooks
PlayerLoopManager.RegisterDomainUnload(DomainUnloadShutdown, 10000); // Clean up worlds and player loop
Application.targetFrameRate = TargetFrameRate;
if (Application.isEditor)
{
#if UNITY_EDITOR
var workerConfigurations =
AssetDatabase.LoadAssetAtPath <ScriptableWorkerConfiguration>(ScriptableWorkerConfiguration
.AssetPath);
foreach (var workerConfig in workerConfigurations.WorkerConfigurations)
{
if (!workerConfig.IsEnabled)
{
continue;
}
var worker = WorkerRegistry.CreateWorker(workerConfig.Type, $"{workerConfig.Type}-{Guid.NewGuid()}",
workerConfig.Origin);
Workers.Add(worker);
}
connectionConfig = new ReceptionistConfig();
connectionConfig.UseExternalIp = workerConfigurations.UseExternalIp;
#endif
}
else
{
var commandLineArguments = System.Environment.GetCommandLineArgs();
Debug.LogFormat("Command line {0}", string.Join(" ", commandLineArguments.ToArray()));
var commandLineArgs = CommandLineUtility.ParseCommandLineArgs(commandLineArguments);
var workerType =
CommandLineUtility.GetCommandLineValue(commandLineArgs, RuntimeConfigNames.WorkerType,
string.Empty);
var workerId =
CommandLineUtility.GetCommandLineValue(commandLineArgs, RuntimeConfigNames.WorkerId,
string.Empty);
// because the launcher does not pass in the worker type as an argument
var worker = workerType.Equals(string.Empty)
? WorkerRegistry.CreateWorker <UnityClient>(
workerId: null, // The worker id for the UnityClient will be auto-generated.
origin: new Vector3(0, 0, 0))
: WorkerRegistry.CreateWorker(workerType, workerId, new Vector3(0, 0, 0));
Workers.Add(worker);
connectionConfig = ConnectionUtility.CreateConnectionConfigFromCommandLine(commandLineArgs);
}
if (World.AllWorlds.Count <= 0)
{
throw new InvalidConfigurationException(
"No worlds have been created, due to invalid worker types being specified. Check the config in" +
"Improbable -> Configure editor workers.");
}
var worlds = World.AllWorlds.ToArray();
ScriptBehaviourUpdateOrder.UpdatePlayerLoop(worlds);
// Systems don't tick if World.Active isn't set
World.Active = worlds[0];
}
/// <summary>
/// Build method that is invoked by commandline
/// </summary>
// ReSharper disable once UnusedMember.Global
public static void Build()
{
try
{
var commandLine = Environment.GetCommandLineArgs();
var buildTargetArg = CommandLineUtility.GetCommandLineValue(commandLine, "buildTarget", "local");
BuildEnvironment buildEnvironment;
switch (buildTargetArg.ToLower())
{
case "cloud":
buildEnvironment = BuildEnvironment.Cloud;
break;
case "local":
buildEnvironment = BuildEnvironment.Local;
break;
default:
throw new BuildFailedException("Unknown build target value: " + buildTargetArg);
}
var workerTypesArg =
CommandLineUtility.GetCommandLineValue(commandLine, BuildWorkerTypes,
"UnityClient,UnityGameLogic");
var wantedWorkerTypes = workerTypesArg.Split(',');
foreach (var wantedWorkerType in wantedWorkerTypes)
{
var buildTargetsForWorker = GetBuildTargetsForWorkerForEnvironment(wantedWorkerType, buildEnvironment);
var buildTargetsMissingBuildSupport = BuildSupportChecker.GetBuildTargetsMissingBuildSupport(buildTargetsForWorker);
if (buildTargetsMissingBuildSupport.Length > 0)
{
throw new BuildFailedException(BuildSupportChecker.ConstructMissingSupportMessage(wantedWorkerType, buildEnvironment, buildTargetsMissingBuildSupport));
}
}
ScriptingImplementation scriptingBackend;
var wantedScriptingBackend = CommandLineUtility.GetCommandLineValue(commandLine, "scriptingBackend", "mono");
switch (wantedScriptingBackend)
{
case "mono":
scriptingBackend = ScriptingImplementation.Mono2x;
break;
case "il2cpp":
scriptingBackend = ScriptingImplementation.IL2CPP;
break;
default:
throw new BuildFailedException("Unknown scripting backend value: " + wantedScriptingBackend);
}
LocalLaunch.BuildConfig();
foreach (var wantedWorkerType in wantedWorkerTypes)
{
BuildWorkerForEnvironment(wantedWorkerType, buildEnvironment, scriptingBackend);
}
}
catch (Exception e)
{
Debug.LogException(e);
if (e is BuildFailedException)
{
throw;
}
throw new BuildFailedException(e);
}
}
private void PushPackage(string packagePath, string source, string apiKey = null)
{
var gallery = new GalleryServer(source);
// Use the specified api key or fall back to default behavior
apiKey = apiKey ?? GetApiKey(source);
// Push the package to the server
var package = new ZipPackage(packagePath);
Console.WriteLine(NuGetResources.PushCommandPushingPackage, package.GetFullName(), CommandLineUtility.GetSourceDisplayName(source));
using (Stream stream = package.GetStream()) {
gallery.CreatePackage(apiKey, stream);
}
// Publish the package on the server
if (!CreateOnly)
{
var cmd = new PublishCommand();
cmd.Console = Console;
cmd.Source = source;
cmd.Arguments = new List <string> {
package.Id, package.Version.ToString(), apiKey
};
cmd.Execute();
}
else
{
Console.WriteLine(NuGetResources.PushCommandPackageCreated, source);
}
}
public override void ExecuteCommand()
{
//Frist argument should be the package ID
string packageId = Arguments[0];
//Second argument should be the package Version
string packageVersion = Arguments[1];
//Third argument if present should be the API Key
string userSetApiKey = null;
if (Arguments.Count > 2)
{
userSetApiKey = Arguments[2];
}
//If the user passed a source use it for the gallery location
string galleryServerUrl = String.IsNullOrEmpty(Source) ? GalleryServer.DefaultGalleryServerUrl : Source;
var gallery = new GalleryServer(galleryServerUrl);
//If the user did not pass an API Key look in the config file
string apiKey = String.IsNullOrEmpty(userSetApiKey) ? CommandLineUtility.GetApiKey(Settings.UserSettings, galleryServerUrl) : userSetApiKey;
Console.WriteLine(NuGetResources.PublishCommandPublishingPackage, packageId, packageVersion, CommandLineUtility.GetSourceDisplayName(Source));
gallery.PublishPackage(apiKey, packageId, packageVersion);
Console.WriteLine(NuGetResources.PublishCommandPackagePublished);
}
/// <summary>
/// Build method that is invoked by commandline
/// </summary>
// ReSharper disable once UnusedMember.Global
public static void Build()
{
try
{
var commandLine = Environment.GetCommandLineArgs();
var buildTargetArg = CommandLineUtility.GetCommandLineValue(commandLine, "buildTarget", "local");
BuildEnvironment buildEnvironment;
switch (buildTargetArg.ToLower())
{
case "cloud":
buildEnvironment = BuildEnvironment.Cloud;
break;
case "local":
buildEnvironment = BuildEnvironment.Local;
break;
default:
throw new BuildFailedException("Unknown build target value: " + buildTargetArg);
}
var workerTypesArg =
CommandLineUtility.GetCommandLineValue(commandLine, BuildWorkerTypes,
"UnityClient,UnityGameLogic");
var wantedWorkerTypes = workerTypesArg.Split(',');
ScriptingImplementation scriptingBackend;
var wantedScriptingBackend =
CommandLineUtility.GetCommandLineValue(commandLine, "scriptingBackend", "mono");
switch (wantedScriptingBackend)
{
case "mono":
scriptingBackend = ScriptingImplementation.Mono2x;
break;
case "il2cpp":
scriptingBackend = ScriptingImplementation.IL2CPP;
break;
default:
throw new BuildFailedException("Unknown scripting backend value: " + wantedScriptingBackend);
}
var buildsSucceeded = BuildWorkers(wantedWorkerTypes, buildEnvironment, scriptingBackend);
if (!buildsSucceeded)
{
throw new BuildFailedException("Not all builds were completed successfully. See the log for more information.");
}
}
catch (Exception e)
{
Debug.LogException(e);
if (e is BuildFailedException)
{
throw;
}
throw new BuildFailedException(e);
}
}
private static void Update()
{
if (SUGARManager.client != null && SUGARManager.account != null && !_accountSet)
{
var sugarAccount = SUGARManager.account;
foreach (var autoLoginOption in AutoLoginOptions)
{
if (autoLoginOption.GetType() == typeof(BoolValue))
{
var boolValue = (BoolValue)autoLoginOption;
boolValue.Value = !EditorPrefs.HasKey($"{Application.productName}_{boolValue.Key}") || EditorPrefs.GetBool($"{Application.productName}_{boolValue.Key}");
var prop = sugarAccount.GetType().GetField(boolValue.SugarRefName, BindingFlags.Instance | BindingFlags.NonPublic);
prop?.SetValue(sugarAccount, boolValue.Value);
}
if (autoLoginOption.GetType() == typeof(StringValue))
{
var stringValue = (StringValue)autoLoginOption;
stringValue.Value = EditorPrefs.HasKey($"{Application.productName}_{stringValue.Key}") ? EditorPrefs.GetString($"{Application.productName}_{stringValue.Key}") : string.Empty;
var prop = sugarAccount.GetType().GetField(stringValue.SugarRefName, BindingFlags.Instance | BindingFlags.NonPublic);
prop?.SetValue(sugarAccount, stringValue.Value);
if (autoLoginOption.Required)
{
if (stringValue.Value == string.Empty)
{
Debug.LogError($"Auto Log-in Tool Error: {stringValue.Label} not provided");
}
}
}
}
var args = new List <string>();
foreach (var autoLoginOption in AutoLoginOptions)
{
if (autoLoginOption.GetType() == typeof(BoolValue))
{
var boolValue = (BoolValue)autoLoginOption;
if (!string.IsNullOrEmpty(boolValue.AutoLoginPrefix) && boolValue.Value)
{
args.Add(boolValue.AutoLoginPrefix);
}
}
if (autoLoginOption.GetType() == typeof(StringValue))
{
var stringValue = (StringValue)autoLoginOption;
if (!string.IsNullOrEmpty(stringValue.DependsOnValue))
{
// this value is only used if the value it depends on is true
if (DependentValue(stringValue.DependsOnValue) && !string.IsNullOrEmpty(stringValue.AutoLoginPrefix) && !string.IsNullOrEmpty(stringValue.Value))
{
args.Add(stringValue.AutoLoginPrefix + stringValue.Value);
}
}
else if (!string.IsNullOrEmpty(stringValue.AutoLoginPrefix) && !string.IsNullOrEmpty(stringValue.Value))
{
args.Add(stringValue.AutoLoginPrefix + stringValue.Value);
}
}
}
SUGARManager.account.options = CommandLineUtility.ParseArgs(args.ToArray());
_accountSet = true;
}
else if (SUGARManager.client == null && _accountSet)
{
_accountSet = false;
}
}
public void ChangeType_ThrowsIfTypeDoesNotAllowNulls()
{
// Act & Assert
ExceptionAssert.Throws <InvalidCastException>(() => CommandLineUtility.ChangeType(null, typeof(int)));
}
public static void Run()
{
var doValidateProjectAssets = false;
var doValidateCrossScenes = false;
var sceneValidationMode = SceneValidationMode.None;
var outputMode = OutputFormat.None;
var fileName = "";
var argsDict = CommandLineUtility.GetNamedCommandlineArguments(':');
// Parse whether or not to validate assets in the project
if (argsDict.ContainsKey(VALIDATE_PROJECT_ASSETS))
{
if (!bool.TryParse(argsDict[VALIDATE_PROJECT_ASSETS], out doValidateProjectAssets))
{
LogArgumentError(VALIDATE_PROJECT_ASSETS, argsDict[VALIDATE_PROJECT_ASSETS]);
}
}
// Parse whether or not to validate across scenes in the project
if (argsDict.ContainsKey(VALIDATE_CROSS_SCENES))
{
if (!bool.TryParse(argsDict[VALIDATE_CROSS_SCENES], out doValidateCrossScenes))
{
LogArgumentError(VALIDATE_CROSS_SCENES, argsDict[VALIDATE_CROSS_SCENES]);
}
}
// Parse Scene Validation Mode
if (argsDict.ContainsKey(SCENE_VALIDATE_MODE_KEY))
{
try
{
sceneValidationMode = (SceneValidationMode)Enum.Parse(typeof(SceneValidationMode), argsDict[SCENE_VALIDATE_MODE_KEY], true);
}
catch (Exception)
{
LogArgumentError(argsDict[SCENE_VALIDATE_MODE_KEY], SCENE_VALIDATE_MODE_KEY);
return;
}
}
// Parse Output Format
if (argsDict.ContainsKey(OUTPUT_FORMAT_KEY))
{
try
{
outputMode = (OutputFormat)Enum.Parse(typeof(OutputFormat), argsDict[OUTPUT_FORMAT_KEY], true);
}
catch (Exception)
{
LogArgumentError(argsDict[SCENE_VALIDATE_MODE_KEY], SCENE_VALIDATE_MODE_KEY);
return;
}
}
else
{
Debug.LogWarning("No OutputFormat has been specified and so none will be written/displayed.");
}
// Parse OutputFilename
if (argsDict.ContainsKey(FILENAME_MODE_KEY))
{
fileName = argsDict[FILENAME_MODE_KEY];
// TODO Fix This
//if (!FileUtility.IsValidFilename(fileName))
//{
// Debug.LogFormat("{0} is not a valid filename, please check for any illegal characters for this operating system", fileName);
// return;
//}
}
Debug.LogFormat("SceneValidationMode: [{0}], OutputMode: [{1}], DoValidateProjectAssets: [{2}], DoValidateCrossScenes: [{3}], Filename: [{4}]",
sceneValidationMode, outputMode, doValidateProjectAssets, doValidateCrossScenes, fileName);
RunValidation(sceneValidationMode,
outputMode,
doValidateProjectAssets,
doValidateCrossScenes,
fileName);
}
public List <CommandLineUtility.ParamCommand> GetFixedCommandList()
{
return(CommandLineUtility.GetParamCommandList(UserConnection));
}
public override void ExecuteCommand()
{
// First argument should be the package
string packagePath = Arguments[0];
// Don't push symbols by default
string source = ResolveSource(packagePath, ConfigurationDefaults.Instance.DefaultPushSource);
var apiKey = GetApiKey(source);
if (String.IsNullOrEmpty(apiKey) && !IsFileSource(source))
{
Console.WriteWarning(LocalizedResourceManager.GetString("NoApiKeyFound"), CommandLineUtility.GetSourceDisplayName(source));
}
var timeout = TimeSpan.FromSeconds(Math.Abs(Timeout));
if (timeout.Seconds <= 0)
{
timeout = TimeSpan.FromMinutes(5); // Default to 5 minutes
}
PushPackage(packagePath, source, apiKey, timeout);
if (source.Equals(NuGetConstants.DefaultGalleryServerUrl, StringComparison.OrdinalIgnoreCase))
{
PushSymbols(packagePath, timeout);
}
}
public void CreateParamCommands()
{
CommandLineUtility.CheckRegisteredSections(UserConnection);
}
public void Parse(String[] args)
{
CommandLineUtility.ParseCommandLineArguments(args, arguments);
}
/// <summary>
/// Build method that is invoked by commandline
/// </summary>
// ReSharper disable once UnusedMember.Global
public static void Build()
{
try
{
var commandLine = Environment.GetCommandLineArgs();
var buildTargetArg = CommandLineUtility.GetCommandLineValue(commandLine, "buildTarget", "local");
BuildEnvironment buildEnvironment;
switch (buildTargetArg.ToLower())
{
case "cloud":
buildEnvironment = BuildEnvironment.Cloud;
break;
case "local":
buildEnvironment = BuildEnvironment.Local;
break;
default:
throw new BuildFailedException("Unknown build target value: " + buildTargetArg);
}
var workerTypesArg =
CommandLineUtility.GetCommandLineValue(commandLine, BuildWorkerTypes,
"UnityClient,UnityGameLogic");
var desiredWorkerTypes = workerTypesArg.Split(',');
var filteredWorkerTypes = BuildSupportChecker.FilterWorkerTypes(buildEnvironment, desiredWorkerTypes);
if (desiredWorkerTypes.Length != filteredWorkerTypes.Length)
{
throw new BuildFailedException(
"Unable to complete build. Missing build support. Check logs for specific errors.");
}
ScriptingImplementation scriptingBackend;
var wantedScriptingBackend =
CommandLineUtility.GetCommandLineValue(commandLine, "scriptingBackend", "mono");
switch (wantedScriptingBackend)
{
case "mono":
scriptingBackend = ScriptingImplementation.Mono2x;
break;
case "il2cpp":
scriptingBackend = ScriptingImplementation.IL2CPP;
break;
default:
throw new BuildFailedException("Unknown scripting backend value: " + wantedScriptingBackend);
}
LocalLaunch.BuildConfig();
foreach (var wantedWorkerType in filteredWorkerTypes)
{
BuildWorkerForEnvironment(wantedWorkerType, buildEnvironment, scriptingBackend);
}
}
catch (Exception e)
{
Debug.LogException(e);
if (e is BuildFailedException)
{
throw;
}
throw new BuildFailedException(e);
}
}
private string GetApiKey(string source)
{
return(String.IsNullOrEmpty(ApiKey) ? CommandLineUtility.GetApiKey(Settings, source) : ApiKey);
}
public void AddPackage(IPackage package)
{
_logger.Log(MessageLevel.Info, NuGetResources.MirrorCommandPushingPackage, package.GetFullName(), CommandLineUtility.GetSourceDisplayName(_destination.Source));
_destination.PushPackage(_apiKey, package, (int)_timeout.TotalMilliseconds);
_logger.Log(MessageLevel.Info, NuGetResources.MirrorCommandPackagePushed);
}
