private ProcessHelper GetCommandRunner()
{
if (CommandRunner == null)
{
CommandRunner = new ProcessHelper();
}
return CommandRunner;
}
public void Processor_TwoColorValues_ShouldPass(TypeOfProcess typeCode, IColor colorOne, IColor colorTwo)
{
var processor = new Processor();
var processHelper = new ProcessHelper<IProcessor>(processor);
processHelper.Process(colorOne, colorTwo);
Assert.Equal(typeCode, processor.LastProcess);
}
public void Process(IColor colorOne, IColor colorTwo)
{
var helper = new ProcessHelper();
colorOne.Accept(helper);
colorTwo.Accept(helper);
helper.Process(this);
//через конструтор копирования
helper.ProcessByConstructor(this);
}
private void CompileOutProc(Project project, string target = null)
{
string msBuildPath = Environment.ExpandEnvironmentVariables(string.Format(@"%WinDir%\Microsoft.NET\Framework\v4.0.30319\MSBuild.exe"));
Console.WriteLine("Invoke MsBuild from {0}", msBuildPath);
ProcessHelper processHelper = new ProcessHelper();
string targetArg = target == null ? "" : " /target:" + target;
int exitCode = processHelper.RunProcess(msBuildPath, "/nologo /v:m \"{0}\" {1}", project.FullPath, targetArg);
LastCompilationOutput = processHelper.ConsoleOutput;
if (exitCode > 0)
throw new Exception("Build failed");
}
public override void TestSuiteFinished(TestCaseSummary testResultsSummary)
{
base.TestSuiteFinished(testResultsSummary);
if (!runContext.IsDataCollectionEnabled || testResultsSummary.CoverageObject == null)
{
return;
}
var directory = runContext.SolutionDirectory;
var coverageHtmlFile = CoverageOutputGenerator.WriteHtmlFile(directory, testResultsSummary.CoverageObject);
var processHelper = new ProcessHelper();
processHelper.LaunchFileInBrowser(coverageHtmlFile);
}
public void TestProcessNfieldOrPs_ArrayObject_CallsCorrectActions()
{
ArrayList input = new ArrayList();
PSObject arrayInput = new PSObject(input);
PSObject psInput = new PSObject();
input.Add(psInput);
input.Add(psInput);
int count = 0;
var mockedMapper = new Mock<IPSObjectMapper>();
mockedMapper.Setup(x => x.To<Interviewer>(psInput))
.Returns(new Interviewer());
ProcessHelper target = new ProcessHelper(mockedMapper.Object);
target.ProcessNfieldOrPs<Interviewer>(arrayInput,
(item) => { ++count; });
Assert.Equal(2, count);
}
public CurrencyWindowViewModel()
{
if (ChannelSession.Settings.Currency.All(c => !c.Value.IsPrimary))
{
this.IsPrimary = true;
}
this.OnlineRate = CurrencyAcquireRateTypeEnum.Minutes;
this.OfflineRate = CurrencyAcquireRateTypeEnum.Disabled;
this.AutomaticResetRate = CurrencyResetRateEnum.Never;
this.AddRankCommand = this.CreateCommand(async(parameter) =>
{
if (string.IsNullOrEmpty(this.NewRankName))
{
await DialogHelper.ShowMessage("A rank name must be specified");
return;
}
if (this.NewRankAmount < 0)
{
await DialogHelper.ShowMessage("A minimum amount must be specified");
return;
}
if (this.Ranks.Any(r => r.Name.Equals(this.NewRankName) || r.Amount == this.NewRankAmount))
{
await DialogHelper.ShowMessage("Every rank must have a unique name and minimum amount");
return;
}
RankModel newRank = new RankModel(this.NewRankName, this.NewRankAmount);
this.Ranks.Add(newRank);
var tempRanks = this.Ranks.ToList();
this.Ranks.Clear();
foreach (RankModel rank in tempRanks.OrderBy(r => r.Amount))
{
this.Ranks.Add(rank);
}
this.NewRankName = string.Empty;
this.NewRankAmount = 0;
});
this.ManualResetCommand = this.CreateCommand(async(parameter) =>
{
if (await DialogHelper.ShowConfirmation(string.Format("Do you want to reset all {0} points?", this.CurrencyRankIdentifierString)))
{
if (this.Currency != null)
{
await this.Currency.Reset();
}
}
});
this.RetroactivelyGivePointsCommand = this.CreateCommand(async(parameter) =>
{
if (await DialogHelper.ShowConfirmation(string.Format("This option will reset all {0} points for this {0} & assign an amount to each user that directly equals the SAVED online rate, not the currently edited online rate. Before using this option, please save all edits to this {0}, re-edit it, then select this option." +
Environment.NewLine + Environment.NewLine + "EX: If the Online Rate is \"1 Per Hour\" and a user has 16 viewing hours, then that user's {0} points will be set to 16." +
Environment.NewLine + Environment.NewLine + "This process may take some time; are you sure you wish to do this?", this.CurrencyRankIdentifierString)))
{
if (this.Currency != null && this.Currency.AcquireInterval > 0)
{
if (this.Currency.SpecialTracking != CurrencySpecialTrackingEnum.None)
{
await DialogHelper.ShowMessage("The rate type for this currency does not support retroactively giving points.");
return;
}
await this.Currency.Reset();
foreach (MixItUp.Base.Model.User.UserDataModel userData in ChannelSession.Settings.UserData.Values)
{
int intervalsToGive = userData.ViewingMinutes / this.Currency.AcquireInterval;
this.Currency.AddAmount(userData, this.Currency.AcquireAmount * intervalsToGive);
if (userData.TwitchUserRoles.Contains(UserRoleEnum.Mod) || userData.TwitchUserRoles.Contains(UserRoleEnum.ChannelEditor))
{
this.Currency.AddAmount(userData, this.Currency.ModeratorBonus * intervalsToGive);
}
else if (userData.TwitchUserRoles.Contains(UserRoleEnum.Subscriber))
{
this.Currency.AddAmount(userData, this.Currency.SubscriberBonus * intervalsToGive);
}
ChannelSession.Settings.UserData.ManualValueChanged(userData.ID);
}
}
}
});
this.ImportFromFileCommand = this.CreateCommand(async(parameter) =>
{
this.userImportData.Clear();
if (await DialogHelper.ShowConfirmation(string.Format("This will allow you to import the total amounts that each user had, assign them to this {0}, and will overwrite any amounts that each user has." +
Environment.NewLine + Environment.NewLine + "This process may take some time; are you sure you wish to do this?", this.CurrencyRankIdentifierString)))
{
try
{
string filePath = ChannelSession.Services.FileService.ShowOpenFileDialog();
if (!string.IsNullOrEmpty(filePath))
{
string fileContents = await ChannelSession.Services.FileService.ReadFile(filePath);
string[] lines = fileContents.Split(new string[] { Environment.NewLine, "\n" }, StringSplitOptions.RemoveEmptyEntries);
if (lines.Count() > 0)
{
foreach (string line in lines)
{
long id = 0;
string username = null;
int amount = 0;
string[] segments = line.Split(new string[] { " ", "\t", "," }, StringSplitOptions.RemoveEmptyEntries);
if (segments.Count() == 2)
{
if (!int.TryParse(segments[1], out amount))
{
throw new InvalidOperationException("File is not in the correct format");
}
if (!long.TryParse(segments[0], out id))
{
username = segments[0];
}
}
else if (segments.Count() == 3)
{
if (!long.TryParse(segments[0], out id))
{
throw new InvalidOperationException("File is not in the correct format");
}
if (!int.TryParse(segments[2], out amount))
{
throw new InvalidOperationException("File is not in the correct format");
}
}
else
{
throw new InvalidOperationException("File is not in the correct format");
}
UserViewModel user = null;
if (amount > 0)
{
if (id > 0)
{
MixItUp.Base.Model.User.UserDataModel userData = ChannelSession.Settings.GetUserDataByTwitchID(id.ToString());
if (userData != null)
{
user = new UserViewModel(userData);
}
else
{
UserModel twitchUser = await ChannelSession.TwitchUserConnection.GetNewAPIUserByID(id.ToString());
if (twitchUser != null)
{
user = new UserViewModel(twitchUser);
}
}
}
else if (!string.IsNullOrEmpty(username))
{
UserModel twitchUser = await ChannelSession.TwitchUserConnection.GetNewAPIUserByLogin(username);
if (twitchUser != null)
{
user = new UserViewModel(twitchUser);
}
}
}
if (user != null)
{
if (!this.userImportData.ContainsKey(user.ID))
{
this.userImportData[user.ID] = amount;
}
this.userImportData[user.ID] = Math.Max(this.userImportData[user.ID], amount);
this.ImportFromFileText = string.Format("{0} {1}...", this.userImportData.Count(), MixItUp.Base.Resources.Imported);
}
}
foreach (var kvp in this.userImportData)
{
if (ChannelSession.Settings.UserData.ContainsKey(kvp.Key))
{
MixItUp.Base.Model.User.UserDataModel userData = ChannelSession.Settings.UserData[kvp.Key];
this.Currency.SetAmount(userData, kvp.Value);
}
}
this.ImportFromFileText = MixItUp.Base.Resources.ImportFromFile;
return;
}
}
}
catch (Exception ex)
{
Logger.Log(ex);
}
await DialogHelper.ShowMessage("We were unable to import the data. Please ensure your file is in one of the following formats:" +
Environment.NewLine + Environment.NewLine + "<USERNAME> <AMOUNT>" +
Environment.NewLine + Environment.NewLine + "<USER ID> <AMOUNT>" +
Environment.NewLine + Environment.NewLine + "<USER ID> <USERNAME> <AMOUNT>");
this.ImportFromFileText = MixItUp.Base.Resources.ImportFromFile;
}
});
this.ExportToFileCommand = this.CreateCommand(async(parameter) =>
{
string filePath = ChannelSession.Services.FileService.ShowSaveFileDialog(this.Currency.Name + " Data.txt");
if (!string.IsNullOrEmpty(filePath))
{
StringBuilder fileContents = new StringBuilder();
foreach (MixItUp.Base.Model.User.UserDataModel userData in ChannelSession.Settings.UserData.Values.ToList())
{
fileContents.AppendLine(string.Format("{0} {1} {2}", userData.TwitchID, userData.Username, this.Currency.GetAmount(userData)));
}
await ChannelSession.Services.FileService.SaveFile(filePath, fileContents.ToString());
}
});
this.HelpCommand = this.CreateCommand((parameter) =>
{
ProcessHelper.LaunchLink("https://github.com/SaviorXTanren/mixer-mixitup/wiki/Currency,-Rank,-&-Inventory");
return(Task.FromResult(0));
});
}
public static void Gen()
{
ProcessHelper.Run("protogen.bat", null, "../Proto/", false);
AssetDatabase.Refresh();
}
public void Invoke(IDictionary <string, string> argsDictionary)
{
// Setup logging if enabled
string logFile;
if (argsDictionary.TryGetValue(LogFileArgument, out logFile))
{
EqtTrace.InitializeVerboseTrace(logFile);
}
#if NET451
if (EqtTrace.IsInfoEnabled)
{
var appConfigText = System.IO.File.ReadAllText(AppDomain.CurrentDomain.SetupInformation.ConfigurationFile);
EqtTrace.Info("DefaultEngineInvoker: Using Application Configuration: '{0}'", appConfigText);
}
#endif
// vstest.console < 15.5 won't send endpoint and role arguments.
// So derive endpoint from port argument and Make connectionRole as Client.
string endpoint = CommandLineArgumentsHelper.GetStringArgFromDict(argsDictionary, EndpointArgument);
if (string.IsNullOrWhiteSpace(endpoint))
{
var port = CommandLineArgumentsHelper.GetIntArgFromDict(argsDictionary, "--port");
endpoint = IPAddress.Loopback + ":" + port;
}
ConnectionRole connectionRole = ConnectionRole.Client;
string role = CommandLineArgumentsHelper.GetStringArgFromDict(argsDictionary, RoleArgument);
if (string.IsNullOrWhiteSpace(role) && string.Equals(role, "host", StringComparison.OrdinalIgnoreCase))
{
connectionRole = ConnectionRole.Host;
}
// Start Processing of requests
using (var requestHandler = new TestRequestHandler(new TestHostConnectionInfo {
Endpoint = endpoint, Role = connectionRole, Transport = Transport.Sockets
}))
{
// Attach to exit of parent process
var parentProcessId = CommandLineArgumentsHelper.GetIntArgFromDict(argsDictionary, ParentProcessIdArgument);
EqtTrace.Info("DefaultEngineInvoker: Monitoring parent process with id: '{0}'", parentProcessId);
// In remote scenario we cannot monitor parent process, so we expect user to pass parentProcessId as -1
if (parentProcessId != -1)
{
var processHelper = new ProcessHelper();
processHelper.SetExitCallback(
parentProcessId,
() =>
{
EqtTrace.Info("DefaultEngineInvoker: ParentProcess '{0}' Exited.", parentProcessId);
new PlatformEnvironment().Exit(1);
});
}
// Initialize Communication
EqtTrace.Info("DefaultEngineInvoker: Initialize communication on endpoint address: '{0}'", endpoint);
requestHandler.InitializeCommunication();
// Initialize DataCollection Communication if data collection port is provided.
var dcPort = CommandLineArgumentsHelper.GetIntArgFromDict(argsDictionary, DataCollectionPortArgument);
if (dcPort > 0)
{
var dataCollectionTestCaseEventSender = DataCollectionTestCaseEventSender.Create();
dataCollectionTestCaseEventSender.InitializeCommunication(dcPort);
dataCollectionTestCaseEventSender.WaitForRequestSenderConnection(ClientListenTimeOut);
}
// Start processing async in a different task
EqtTrace.Info("DefaultEngineInvoker: Start Request Processing.");
var processingTask = this.StartProcessingAsync(requestHandler, new TestHostManagerFactory());
// Wait for processing to complete.
Task.WaitAny(processingTask);
if (dcPort > 0)
{
// Close socket communication connection.
DataCollectionTestCaseEventSender.Instance.Close();
}
}
}
public async Task kernel_server_honors_log_path()
{
using var logPath = DisposableDirectory.Create();
using var outputReceived = new ManualResetEvent(false);
var outputLock = new object();
var receivedOutput = false;
var errorLines = new List <string>();
// start as external process
var kernelServerProcess = ProcessHelper.Start(
command: "dotnet",
args: $@"interactive stdio --log-path ""{logPath.Directory.FullName}""",
workingDir: new DirectoryInfo(Directory.GetCurrentDirectory()),
output: _line =>
{
lock (outputLock)
{
if (!receivedOutput)
{
receivedOutput = true;
outputReceived.Set();
}
}
},
error: errorLines.Add);
// wait for log file to be created
var logFile = await logPath.Directory.WaitForFile(
timeout : TimeSpan.FromSeconds(2),
predicate : _file => true); // any matching file is the one we want
errorLines.Should().BeEmpty();
logFile.Should().NotBeNull("unable to find created log file");
// submit code
var submissionJson = @"{""token"":""abc"",""commandType"":""SubmitCode"",""command"":{""code"":""1+1"",""submissionType"":0,""targetKernelName"":null}}";
await kernelServerProcess.StandardInput.WriteLineAsync(submissionJson);
await kernelServerProcess.StandardInput.FlushAsync();
// wait for output to proceed
var gotOutput = outputReceived.WaitOne(timeout: TimeSpan.FromSeconds(2));
gotOutput.Should().BeTrue("expected to receive on stdout");
// kill
kernelServerProcess.StandardInput.Close(); // simulate Ctrl+C
await Task.Delay(TimeSpan.FromSeconds(2)); // allow logs to be flushed
kernelServerProcess.Kill();
kernelServerProcess.WaitForExit(2000).Should().BeTrue();
errorLines.Should().BeEmpty();
// check log file for expected contents
(await logFile.WaitForFileCondition(
timeout: TimeSpan.FromSeconds(2),
predicate: file => file.Length > 0))
.Should().BeTrue("expected non-empty log file");
var logFileContents = File.ReadAllText(logFile.FullName);
logFileContents.Should().Contain("ℹ OnAssemblyLoad: ");
}
public void Build_ExecutesPreAndPostBuildScripts_WithinBenvContext()
{
// Arrange
var volume = CreateWebFrontEndVolume();
using (var sw = File.AppendText(Path.Combine(volume.MountedHostDir, "build.env")))
{
sw.NewLine = "\n";
sw.WriteLine("PRE_BUILD_SCRIPT_PATH=scripts/prebuild.sh");
sw.WriteLine("POST_BUILD_SCRIPT_PATH=scripts/postbuild.sh");
}
var scriptsDir = Directory.CreateDirectory(Path.Combine(volume.MountedHostDir, "scripts"));
using (var sw = File.AppendText(Path.Combine(scriptsDir.FullName, "prebuild.sh")))
{
sw.NewLine = "\n";
sw.WriteLine("#!/bin/bash");
sw.WriteLine("echo \"Pre-build script: $node\"");
sw.WriteLine("echo \"Pre-build script: $npm\"");
}
using (var sw = File.AppendText(Path.Combine(scriptsDir.FullName, "postbuild.sh")))
{
sw.NewLine = "\n";
sw.WriteLine("#!/bin/bash");
sw.WriteLine("echo \"Post-build script: $node\"");
sw.WriteLine("echo \"Post-build script: $npm\"");
}
if (RuntimeInformation.IsOSPlatform(Settings.LinuxOS))
{
ProcessHelper.RunProcess(
"chmod",
new[] { "-R", "777", scriptsDir.FullName },
workingDirectory: null,
waitTimeForExit: null);
}
var appDir = volume.ContainerDir;
var script = new ShellScriptBuilder()
.AddBuildCommand($"{appDir} -l nodejs --language-version 6")
.ToString();
// Act
var result = _dockerCli.Run(
Settings.BuildImageName,
volume,
commandToExecuteOnRun: "/bin/bash",
commandArguments:
new[]
{
"-c",
script
});
// Assert
RunAsserts(
() =>
{
Assert.True(result.IsSuccess);
Assert.Matches(@"Pre-build script: /opt/nodejs/6.\d+.\d+/bin/node", result.StdOut);
Assert.Matches(@"Pre-build script: /opt/nodejs/6.\d+.\d+/bin/npm", result.StdOut);
Assert.Matches(@"Post-build script: /opt/nodejs/6.\d+.\d+/bin/node", result.StdOut);
Assert.Matches(@"Post-build script: /opt/nodejs/6.\d+.\d+/bin/npm", result.StdOut);
},
result.GetDebugInfo());
}
public void BuildSample([ValueSource("GetSampleData")] SampleTestData sampleTestData)
{
try {
var data = sampleTestData.SampleTest;
if (!string.IsNullOrEmpty(data.KnownFailure))
{
Assert.Ignore(data.KnownFailure);
}
var environment_variables = new Dictionary <string, string> ();
environment_variables ["MD_APPLE_SDK_ROOT"] = Path.GetDirectoryName(Path.GetDirectoryName(Configuration.XcodeLocation));
switch (data.Project.Platform)
{
case TestPlatform.iOS:
case TestPlatform.tvOS:
case TestPlatform.watchOS:
environment_variables ["MD_MTOUCH_SDK_ROOT"] = Path.Combine(Configuration.IOS_DESTDIR, "Library", "Frameworks", "Xamarin.iOS.framework", "Versions", "Current");
environment_variables ["TargetFrameworkFallbackSearchPaths"] = Path.Combine(Configuration.IOS_DESTDIR, "Library", "Frameworks", "Mono.framework", "External", "xbuild-frameworks");
environment_variables ["MSBuildExtensionsPathFallbackPathsOverride"] = Path.Combine(Configuration.IOS_DESTDIR, "Library", "Frameworks", "Mono.framework", "External", "xbuild");
break;
case TestPlatform.macOS:
environment_variables ["TargetFrameworkFallbackSearchPaths"] = Path.Combine(Configuration.MAC_DESTDIR, "Library", "Frameworks", "Mono.framework", "External", "xbuild-frameworks");
environment_variables ["MSBuildExtensionsPathFallbackPathsOverride"] = Path.Combine(Configuration.MAC_DESTDIR, "Library", "Frameworks", "Mono.framework", "External", "xbuild");
environment_variables ["XamarinMacFrameworkRoot"] = Path.Combine(Configuration.MAC_DESTDIR, "Library", "Frameworks", "Xamarin.Mac.framework", "Versions", "Current");
environment_variables ["XAMMAC_FRAMEWORK_PATH"] = Path.Combine(Configuration.MAC_DESTDIR, "Library", "Frameworks", "Xamarin.Mac.framework", "Versions", "Current");
break;
default:
throw new NotImplementedException(sampleTestData.Platform.ToString());
}
var file_to_build = sampleTestData.SampleTest.Project.RelativePath;
var target = string.Empty;
if (data.BuildSolution)
{
file_to_build = data.Solution;
target = Path.GetFileNameWithoutExtension(data.Project.RelativePath).Replace('.', '_');
}
var repo = CloneRepo();
file_to_build = Path.Combine(repo, file_to_build);
if (data.RemoveProjects != null)
{
if (String.IsNullOrEmpty(data.Solution))
{
Assert.Fail("'RemoveProjects' used without a 'Solution' path!");
}
var sln_path = Path.Combine(repo, data.Solution);
var filtered_sln = new List <string> (File.ReadAllLines(sln_path));
foreach (var p in data.RemoveProjects)
{
for (int i = 0; i < filtered_sln.Count; i++)
{
var line = filtered_sln [i];
if (line.StartsWith("Project(", StringComparison.Ordinal))
{
if (line.Contains($") = \"{p}\", \""))
{
filtered_sln.RemoveAt(i);
filtered_sln.RemoveAt(i); // EndProject (same `i` as things moved up)
break;
}
}
}
}
File.WriteAllLines(sln_path, filtered_sln);
}
ProcessHelper.BuildSolution(file_to_build, sampleTestData.Platform, sampleTestData.Configuration, environment_variables, sampleTestData.Timeout, target, data.CodesignKey);
Console.WriteLine("✅ {0} succeeded.", TestContext.CurrentContext.Test.FullName);
} catch (Exception e) {
Console.WriteLine("❌ {0} failed: {1}", TestContext.CurrentContext.Test.FullName, e.Message);
throw;
}
}
public CommunityCommandsMainControlViewModel(MainWindowViewModel windowViewModel)
: base(windowViewModel)
{
this.BackCommand = this.CreateCommand(async() =>
{
if (this.ShowMyCommands)
{
await this.NavigateToCategories();
}
else if (this.ShowUserCommands)
{
await this.NavigateToCategories();
}
else if (this.ShowSearch)
{
await this.NavigateToCategories();
}
else if (this.ShowCommandDetails)
{
if (this.MyCommands.Count > 0)
{
this.ClearAllShows();
this.ShowMyCommands = true;
}
else if (this.UserCommands.Count > 0)
{
this.ClearAllShows();
this.ShowUserCommands = true;
}
else if (this.SearchResults.Count > 0)
{
this.ClearAllShows();
this.ShowSearch = true;
}
else
{
await this.NavigateToCategories();
}
}
});
this.SearchCommand = this.CreateCommand(async() =>
{
try
{
this.CurrentResultsPage = 0;
await this.PerformSearch();
}
catch (Exception ex)
{
Logger.Log(ex);
}
});
this.GetCommandDetailsCommand = this.CreateCommand(async(id) =>
{
try
{
CommunityCommandDetailsModel commandDetails = await ChannelSession.Services.CommunityCommandsService.GetCommandDetails((Guid)id);
if (commandDetails != null)
{
this.CommandDetails = new CommunityCommandDetailsViewModel(commandDetails);
this.ClearAllShows();
this.ShowCommandDetails = true;
}
}
catch (Exception ex)
{
Logger.Log(ex);
}
});
this.WebsiteLinkCommand = this.CreateCommand(() =>
{
ProcessHelper.LaunchLink(this.CommandDetails?.WebsiteURL);
});
this.GetUserCommandsCommand = this.CreateCommand(async() =>
{
try
{
this.CurrentResultsPage = 0;
await this.PerformUserCommands();
}
catch (Exception ex)
{
Logger.Log(ex);
}
});
this.GetMyCommandsCommand = this.CreateCommand(async() =>
{
try
{
this.CurrentResultsPage = 0;
await this.PerformMyCommands();
}
catch (Exception ex)
{
Logger.Log(ex);
}
});
this.EditMyCommandCommand = this.CreateCommand(async(id) =>
{
try
{
CommunityCommandDetailsModel commandDetails = await ChannelSession.Services.CommunityCommandsService.GetCommandDetails((Guid)id);
if (commandDetails != null)
{
this.CommandDetails = new MyCommunityCommandDetailsViewModel(commandDetails);
this.ClearAllShows();
this.ShowCommandDetails = true;
}
}
catch (Exception ex)
{
Logger.Log(ex);
}
});
this.DeleteMyCommandCommand = this.CreateCommand(async() =>
{
try
{
if (this.CommandDetails.IsMyCommand && await DialogHelper.ShowConfirmation(MixItUp.Base.Resources.CommunityCommandsDeleteMyCommandConfirmation))
{
await ChannelSession.Services.CommunityCommandsService.DeleteCommand(this.CommandDetails.ID);
this.GetMyCommandsCommand.Execute(null);
}
}
catch (Exception ex)
{
Logger.Log(ex);
}
});
this.PreviousResultsCommand = this.CreateCommand(async() =>
{
this.CurrentResultsPage--;
if (this.ShowMyCommands)
{
await this.PerformMyCommands();
}
else if (this.ShowUserCommands)
{
await this.PerformUserCommands();
}
else if (this.ShowSearch)
{
await this.PerformSearch();
}
});
this.NextResultsCommand = this.CreateCommand(async() =>
{
this.CurrentResultsPage++;
if (this.ShowMyCommands)
{
await this.PerformMyCommands();
}
else if (this.ShowUserCommands)
{
await this.PerformUserCommands();
}
else if (this.ShowSearch)
{
await this.PerformSearch();
}
});
}
public static async Task <(int, string)> PsAsync()
{
var(err, stdout, stderr) = await ProcessHelper.RunProcessAsync("docker", $"ps");
return(err, await stdout.ReadToEndAsync());
}
protected override async Task ExecuteAsync(OleMenuCmdEventArgs e)
{
await CommandHelper.SaveFiles();
await ProcessHelper.RunTortoiseGitFileCommand("diff");
}
public void CreatePackage(ServiceDefinition definition, string rootPath, DevEnv type, out string standardOutput, out string standardError)
{
if (definition == null)
{
throw new ArgumentNullException(
"definition",
string.Format(Resources.InvalidOrEmptyArgumentMessage, "Service definition"));
}
if (string.IsNullOrEmpty(rootPath) || File.Exists(rootPath))
{
throw new ArgumentException(Resources.InvalidRootNameMessage, "rootPath");
}
// Track the directories that are created by GetOrCreateCleanPath
// to avoid publishing iisnode log files so we can delete the temp
// copies when we're finished packaging
Dictionary<string, string> tempDirectories = new Dictionary<string, string>();
try
{
string roles =
// Get the names of all web and worker roles
Enumerable.Concat(
definition.WebRole.NonNull().Select(role => role.name),
definition.WorkerRole.NonNull().Select(role => role.name))
// Get the name and safe path for each role (i.e., if the
// role has files that shouldn't be packaged, it'll be
// copied to a temp location without those files)
.Select(name => GetOrCreateCleanPath(rootPath, name, tempDirectories, type))
// Format the role name and path as a role argument
.Select(nameAndPath => string.Format(Resources.RoleArgTemplate, nameAndPath.Key, nameAndPath.Value))
// Join all the role arguments together into one
.DefaultIfEmpty(string.Empty)
.Aggregate(string.Concat);
string sites =
// Get all of the web roles
definition.WebRole.NonNull()
// Get all the sites in each role and format them all as
// site arguments
.SelectMany(role =>
// Format each site as a site argument
role.Sites.Site.Select(site =>
string.Format(
Resources.SitesArgTemplate,
role.name,
site.name,
tempDirectories.GetValueOrDefault(role.name, rootPath))))
// Join all the site arguments together into one
.DefaultIfEmpty(string.Empty)
.Aggregate(string.Concat);
string args = string.Format(
type == DevEnv.Local ? Resources.CsPackLocalArg : Resources.CsPackCloudArg,
rootPath,
roles,
sites);
// Run CsPack to generate the package
ProcessHelper.StartAndWaitForProcess(
new ProcessStartInfo(
Path.Combine(AzureSdkBinDirectory, Resources.CsPackExe),
args),
out standardOutput,
out standardError);
}
finally
{
// Cleanup any temp directories
tempDirectories.Values.ForEach(dir => Directory.Delete(dir, true));
}
}
/// <summary>
/// Creates a copy of a local directory, and returns a DockerVolume instance for mounting that copy in a
/// container.
/// </summary>
/// <param name="hostDir">local directory to be used in a container</param>
/// <returns>DockerVolume instance that can be used to mount the new copy of `originalDir`.</returns>
public static DockerVolume CreateMirror(string hostDir)
{
if (string.IsNullOrEmpty(hostDir))
{
throw new ArgumentException($"'{nameof(hostDir)}' cannot be null or empty.");
}
if (!Directory.Exists(hostDir))
{
throw new ArgumentException($"'{nameof(hostDir)}' must point to an existing directory.");
}
var dirInfo = new DirectoryInfo(hostDir);
// Copy the host directory to a different location and mount that one as it's always possible that a
// single sample app could be tested by different tests and we do not want to modify its original state
// and also it would not be nice to see changes in git repository when running tests.
// Since Docker containers run as 'root' and any content written into the mounted directory is owned by
// the 'root', the CI agent which runs as a non-root account cannot delete that content, so we try to
// create content in a well known location on the CI agent so that these folders are deleted during the
// clean-up task.
var agentName = Environment.GetEnvironmentVariable(VstsAgentNameEnivronmentVariable);
string tempDirRoot = null;
if (string.IsNullOrEmpty(agentName))
{
// On dev machines, create the temporary folders underneath the 'bin' hierarchy itself. This way
// a user can clean those folders when they do 'git clean -xdf' on their source repo.
var fileInfo = new FileInfo(Assembly.GetExecutingAssembly().Location);
tempDirRoot = fileInfo.Directory.FullName;
}
else
{
// Put the folders in a well known location which the CI build definition looks for to clean up.
tempDirRoot = Path.Combine(Path.GetTempPath(), MountedHostDirRootName);
}
var writableHostDir = Path.Combine(
tempDirRoot,
Guid.NewGuid().ToString("N"),
dirInfo.Name);
CopyDirectories(hostDir, writableHostDir, copySubDirs: true);
// Grant permissions to the folder we just copied on the host machine. The permisions here allow the
// user(a non-root user) in the container to read/write/execute files.
var linuxOS = OSPlatform.Create("LINUX");
if (RuntimeInformation.IsOSPlatform(linuxOS))
{
ProcessHelper.RunProcess(
"chmod",
new[] { "-R", "777", writableHostDir },
workingDirectory: null,
waitTimeForExit: null);
}
var containerDirName = dirInfo.Name;
// Note: Path.Combine is the ideal solution here but this would fail when we run the
// tests on a windows machine (which most of us use).
var containerDir = $"{ContainerDirRoot}/{containerDirName}";
return(new DockerVolume(hostDir, writableHostDir, containerDir));
}
public IContainer CreateContainer(ContainerSpec containerSpec)
{
Guard.NotNull(containerSpec, "containerSpec");
UndoStack undoStack = new UndoStack();
IContainer container;
try
{
var handle = containerSpec.Handle;
if (String.IsNullOrEmpty(handle))
{
handle = handleHelper.GenerateHandle();
}
var id = handleHelper.GenerateId(handle);
var user = ContainerUser.Create(userManager, id);
undoStack.Push(() => user.Delete());
var directory = directoryFactory.Create(fileSystem, containerBasePath, id);
directory.CreateSubdirectories(user);
undoStack.Push(directory.Destroy);
directory.CreateBindMounts(containerSpec.BindMounts, user);
var jobObject = new JobObject(id);
undoStack.Push(() => jobObject.Dispose());
var containerHostClient = containerHostService.StartContainerHost(id, directory, jobObject, user.GetCredential());
undoStack.Push(() => containerHostClient.Shutdown());
var constrainedProcessRunner = new ConstrainedProcessRunner(containerHostClient);
undoStack.Push(() => constrainedProcessRunner.Dispose());
var processHelper = new ProcessHelper();
var dependencyHelper = new ContainerHostDependencyHelper();
var diskQuotaControl = diskQuotaManager.CreateDiskQuotaControl(directory);
container = new Container(
id,
handle,
user,
directory,
containerPropertiesService,
tcpPortManager,
jobObject,
diskQuotaControl,
processRunner,
constrainedProcessRunner,
processHelper,
containerSpec.Environment,
dependencyHelper);
containerPropertiesService.SetProperties(container, containerSpec.Properties);
lock (containers)
{
containers.Add(container);
}
}
catch (Exception e)
{
try
{
undoStack.UndoAll();
throw;
}
catch (AggregateException undoException)
{
throw new AggregateException(new[] { e, undoException });
}
}
return(container);
}
public override void TestSuiteFinished(TestCaseSummary testResultsSummary)
{
base.TestSuiteFinished(testResultsSummary);
if(!runContext.IsDataCollectionEnabled || testResultsSummary.CoverageObject == null)
{
return;
}
try
{
// If we do not have a solutiondirectory, we assume that we are running in tfs build
// In that case we only write to the testrundirectory and do not open a browser
if(string.IsNullOrEmpty(runContext.SolutionDirectory))
{
ChutzpahTracer.TraceInformation("Chutzpah runs in TFSBuild, writing coverage file to {0}", runContext.TestRunDirectory);
var directory = runContext.TestRunDirectory;
CoverageOutputGenerator.WriteHtmlFile(Path.Combine(directory, Constants.CoverageHtmlFileName), testResultsSummary.CoverageObject);
}
else
{
ChutzpahTracer.TraceInformation("Chutzpah runs not in TFSBuild opening coverage file in browser");
var directory = runContext.SolutionDirectory;
var coverageHtmlFile = CoverageOutputGenerator.WriteHtmlFile(Path.Combine(directory, Constants.CoverageHtmlFileName), testResultsSummary.CoverageObject);
var processHelper = new ProcessHelper();
processHelper.LaunchFileInBrowser(coverageHtmlFile);
}
}
catch(Exception e)
{
frameworkHandle.SendMessage(TestMessageLevel.Error, string.Format("Error while writing coverage output: {0}", e));
}
}
public void TestProcessNfieldOrPs_ObjectCanBeMapped_CallsNfieldAction()
{
int count = 0;
var mockedMapper = new Mock<IPSObjectMapper>();
var input = new PSObject();
mockedMapper.Setup(x => x.To<Interviewer>(input))
.Returns(new Interviewer());
ProcessHelper target = new ProcessHelper(mockedMapper.Object);
target.ProcessNfieldOrPs<Interviewer>(input,
(item) => { ++count; });
Assert.Equal(1, count);
}
public Task <bool> ExecuteAsync()
{
return(Task.Run(() =>
{
Console.WriteLine("Build Electron Application...");
SimpleCommandLineParser parser = new SimpleCommandLineParser();
parser.Parse(_args);
if (!parser.Arguments.ContainsKey(_paramTarget))
{
Console.WriteLine($"Error: missing '{_paramTarget}' argument.");
Console.WriteLine(COMMAND_ARGUMENTS);
return false;
}
var desiredPlatform = parser.Arguments[_paramTarget][0];
string specifiedFromCustom = string.Empty;
if (desiredPlatform == "custom" && parser.Arguments[_paramTarget].Length > 1)
{
specifiedFromCustom = parser.Arguments[_paramTarget][1];
}
string configuration = "Release";
if (parser.Arguments.ContainsKey(_paramDotNetConfig))
{
configuration = parser.Arguments[_paramDotNetConfig][0];
}
var platformInfo = GetTargetPlatformInformation.Do(desiredPlatform, specifiedFromCustom);
Console.WriteLine($"Build ASP.NET Core App for {platformInfo.NetCorePublishRid}...");
string tempPath = Path.Combine(Directory.GetCurrentDirectory(), "obj", "desktop", desiredPlatform);
if (Directory.Exists(tempPath) == false)
{
Directory.CreateDirectory(tempPath);
}
else
{
Directory.Delete(tempPath, true);
Directory.CreateDirectory(tempPath);
}
Console.WriteLine("Executing dotnet publish in this directory: " + tempPath);
string tempBinPath = Path.Combine(tempPath, "bin");
Console.WriteLine($"Build ASP.NET Core App for {platformInfo.NetCorePublishRid} under {configuration}-Configuration...");
string publishReadyToRun = "/p:PublishReadyToRun=";
if (parser.Arguments.ContainsKey(_paramPublishReadyToRun))
{
publishReadyToRun += parser.Arguments[_paramPublishReadyToRun][0];
}
else
{
publishReadyToRun += "true";
}
var resultCode = ProcessHelper.CmdExecute($"dotnet publish -r {platformInfo.NetCorePublishRid} -c \"{configuration}\" --output \"{tempBinPath}\" {publishReadyToRun} --self-contained", Directory.GetCurrentDirectory());
if (resultCode != 0)
{
Console.WriteLine("Error occurred during dotnet publish: " + resultCode);
return false;
}
DeployEmbeddedElectronFiles.Do(tempPath);
var nodeModulesDirPath = Path.Combine(tempPath, "node_modules");
if (parser.Arguments.ContainsKey(_paramPackageJson))
{
Console.WriteLine("Copying custom package.json.");
File.Copy(parser.Arguments[_paramPackageJson][0], Path.Combine(tempPath, "package.json"), true);
}
var checkForNodeModulesDirPath = Path.Combine(tempPath, "node_modules");
if (Directory.Exists(checkForNodeModulesDirPath) == false || parser.Contains(_paramForceNodeInstall) || parser.Contains(_paramPackageJson))
{
Console.WriteLine("Start npm install...");
}
ProcessHelper.CmdExecute("npm install --production", tempPath);
Console.WriteLine("ElectronHostHook handling started...");
string electronhosthookDir = Path.Combine(Directory.GetCurrentDirectory(), "ElectronHostHook");
if (Directory.Exists(electronhosthookDir))
{
string hosthookDir = Path.Combine(tempPath, "ElectronHostHook");
DirectoryCopy.Do(electronhosthookDir, hosthookDir, true, new List <string>()
{
"node_modules"
});
Console.WriteLine("Start npm install for hosthooks...");
ProcessHelper.CmdExecute("npm install", hosthookDir);
// ToDo: Not sure if this runs under linux/macos
ProcessHelper.CmdExecute(@"npx tsc -p . --sourceMap false", hosthookDir);
}
Console.WriteLine("Build Electron Desktop Application...");
// Specifying an absolute path supercedes a relative path
string buildPath = Path.Combine(Directory.GetCurrentDirectory(), "bin", "desktop");
if (parser.Arguments.ContainsKey(_paramAbsoluteOutput))
{
buildPath = parser.Arguments[_paramAbsoluteOutput][0];
}
else if (parser.Arguments.ContainsKey(_paramOutputDirectory))
{
buildPath = Path.Combine(Directory.GetCurrentDirectory(), parser.Arguments[_paramOutputDirectory][0]);
}
Console.WriteLine("Executing electron magic in this directory: " + buildPath);
string electronArch = "x64";
if (parser.Arguments.ContainsKey(_paramElectronArch))
{
electronArch = parser.Arguments[_paramElectronArch][0];
}
string electronParams = "";
if (parser.Arguments.ContainsKey(_paramElectronParams))
{
electronParams = parser.Arguments[_paramElectronParams][0];
}
// ToDo: Make the same thing easer with native c# - we can save a tmp file in production code :)
Console.WriteLine("Create electron-builder configuration file...");
string manifestFileName = "electron.manifest.json";
if (parser.Arguments.ContainsKey(_manifest))
{
manifestFileName = parser.Arguments[_manifest].First();
}
ProcessHelper.CmdExecute($"node build-helper.js " + manifestFileName, tempPath);
Console.WriteLine($"Package Electron App for Platform {platformInfo.ElectronPackerPlatform}...");
ProcessHelper.CmdExecute($"npx electron-builder . --config=./bin/electron-builder.json --{platformInfo.ElectronPackerPlatform} --{electronArch} -c.electronVersion=9.0.0 {electronParams}", tempPath);
Console.WriteLine("... done");
return true;
}));
}
protected override void Execute(GVFSEnlistment enlistment)
{
string diagnosticsRoot = Path.Combine(enlistment.DotGVFSRoot, "diagnostics");
if (!Directory.Exists(diagnosticsRoot))
{
Directory.CreateDirectory(diagnosticsRoot);
}
string archiveFolderPath = Path.Combine(diagnosticsRoot, "gvfs_" + DateTime.Now.ToString("yyyyMMdd_HHmmss"));
Directory.CreateDirectory(archiveFolderPath);
using (FileStream diagnosticLogFile = new FileStream(Path.Combine(archiveFolderPath, "diagnostics.log"), FileMode.CreateNew))
using (this.diagnosticLogFileWriter = new StreamWriter(diagnosticLogFile))
{
this.WriteMessage("Collecting diagnostic info into temp folder " + archiveFolderPath);
this.WriteMessage(string.Empty);
this.WriteMessage("gvfs version " + ProcessHelper.GetCurrentProcessVersion());
GitVersion gitVersion = null;
string error = null;
if (!string.IsNullOrEmpty(enlistment.GitBinPath) && GitProcess.TryGetVersion(enlistment.GitBinPath, out gitVersion, out error))
{
this.WriteMessage("git version " + gitVersion.ToString());
}
else
{
this.WriteMessage("Could not determine git version. " + error);
}
this.WriteMessage(enlistment.GitBinPath);
this.WriteMessage(string.Empty);
this.WriteMessage("Enlistment root: " + enlistment.EnlistmentRoot);
this.WriteMessage("Cache Server: " + CacheServerResolver.GetCacheServerFromConfig(enlistment));
string localCacheRoot;
string gitObjectsRoot;
this.GetLocalCachePaths(enlistment, out localCacheRoot, out gitObjectsRoot);
string actualLocalCacheRoot = !string.IsNullOrWhiteSpace(localCacheRoot) ? localCacheRoot : gitObjectsRoot;
this.WriteMessage("Local Cache: " + actualLocalCacheRoot);
this.WriteMessage(string.Empty);
this.PrintDiskSpaceInfo(actualLocalCacheRoot, this.EnlistmentRootPathParameter);
this.RecordVersionInformation();
this.ShowStatusWhileRunning(
() =>
this.RunAndRecordGVFSVerb <StatusVerb>(archiveFolderPath, "gvfs_status.txt") != ReturnCode.Success ||
this.RunAndRecordGVFSVerb <UnmountVerb>(archiveFolderPath, "gvfs_unmount.txt", verb => verb.SkipLock = true) == ReturnCode.Success,
"Unmounting",
suppressGvfsLogMessage: true);
this.ShowStatusWhileRunning(
() =>
{
// .gvfs
this.CopyAllFiles(enlistment.EnlistmentRoot, archiveFolderPath, GVFSConstants.DotGVFS.Root, copySubFolders: false);
if (!GVFSPlatform.Instance.IsUnderConstruction)
{
// driver
this.FlushKernelDriverLogs();
string kernelLogsFolderPath = GVFSPlatform.Instance.KernelDriver.LogsFolderPath;
// This copy sometimes fails because the OS has an exclusive lock on the etl files. The error is not actionable
// for the user so we don't write the error message to stdout, just to our own log file.
this.CopyAllFiles(Path.GetDirectoryName(kernelLogsFolderPath), archiveFolderPath, Path.GetFileName(kernelLogsFolderPath), copySubFolders: false, hideErrorsFromStdout: true);
}
// .git
this.CopyAllFiles(enlistment.WorkingDirectoryRoot, archiveFolderPath, GVFSConstants.DotGit.Root, copySubFolders: false);
this.CopyAllFiles(enlistment.WorkingDirectoryRoot, archiveFolderPath, GVFSConstants.DotGit.Hooks.Root, copySubFolders: false);
this.CopyAllFiles(enlistment.WorkingDirectoryRoot, archiveFolderPath, GVFSConstants.DotGit.Info.Root, copySubFolders: false);
this.CopyAllFiles(enlistment.WorkingDirectoryRoot, archiveFolderPath, GVFSConstants.DotGit.Logs.Root, copySubFolders: true);
this.CopyAllFiles(enlistment.WorkingDirectoryRoot, archiveFolderPath, GVFSConstants.DotGit.Refs.Root, copySubFolders: true);
this.CopyAllFiles(enlistment.WorkingDirectoryRoot, archiveFolderPath, GVFSConstants.DotGit.Objects.Info.Root, copySubFolders: false);
this.LogDirectoryEnumeration(enlistment.WorkingDirectoryRoot, Path.Combine(archiveFolderPath, GVFSConstants.DotGit.Objects.Root), GVFSConstants.DotGit.Objects.Pack.Root, "packs-local.txt");
this.LogLooseObjectCount(enlistment.WorkingDirectoryRoot, Path.Combine(archiveFolderPath, GVFSConstants.DotGit.Objects.Root), GVFSConstants.DotGit.Objects.Root, "objects-local.txt");
// databases
this.CopyAllFiles(enlistment.DotGVFSRoot, Path.Combine(archiveFolderPath, GVFSConstants.DotGVFS.Root), GVFSConstants.DotGVFS.Databases.Name, copySubFolders: false);
// local cache
this.CopyLocalCacheData(archiveFolderPath, localCacheRoot, gitObjectsRoot);
// corrupt objects
this.CopyAllFiles(enlistment.DotGVFSRoot, Path.Combine(archiveFolderPath, GVFSConstants.DotGVFS.Root), GVFSConstants.DotGVFS.CorruptObjectsName, copySubFolders: false);
if (GVFSPlatform.Instance.SupportsGVFSService)
{
// service
this.CopyAllFiles(
Paths.GetServiceDataRoot(string.Empty),
archiveFolderPath,
this.ServiceName,
copySubFolders: true);
}
if (GVFSPlatform.Instance.SupportsGVFSUpgrade)
{
// upgrader
this.CopyAllFiles(
ProductUpgrader.GetUpgradesDirectoryPath(),
archiveFolderPath,
ProductUpgrader.LogDirectory,
copySubFolders: true,
targetFolderName: ProductUpgrader.UpgradeDirectoryName);
this.LogDirectoryEnumeration(
ProductUpgrader.GetUpgradesDirectoryPath(),
Path.Combine(archiveFolderPath, ProductUpgrader.UpgradeDirectoryName),
ProductUpgrader.DownloadDirectory,
"downloaded-assets.txt");
}
return(true);
},
"Copying logs");
this.ShowStatusWhileRunning(
() => this.RunAndRecordGVFSVerb <MountVerb>(archiveFolderPath, "gvfs_mount.txt") == ReturnCode.Success,
"Mounting",
suppressGvfsLogMessage: true);
this.CopyAllFiles(enlistment.DotGVFSRoot, Path.Combine(archiveFolderPath, GVFSConstants.DotGVFS.Root), "logs", copySubFolders: false);
}
string zipFilePath = archiveFolderPath + ".zip";
this.ShowStatusWhileRunning(
() =>
{
ZipFile.CreateFromDirectory(archiveFolderPath, zipFilePath);
PhysicalFileSystem.RecursiveDelete(archiveFolderPath);
return(true);
},
"Creating zip file",
suppressGvfsLogMessage: true);
this.Output.WriteLine();
this.Output.WriteLine("Diagnostics complete. All of the gathered info, as well as all of the output above, is captured in");
this.Output.WriteLine(zipFilePath);
}
private void RecycleGuard()
{
// 创建自己的日志
IDLog log = new TinyLog();
log.Init(_config.ID + "_" + _config.AppName, _config.ID + "_" + _config.AppName + "/log");
int count1 = 0;
_appErrExecutor.Log = log;
//监控间隔提醒
if (_config.GuardInternal < 1500)
{
log.Fatal("注意: 配置的监控间隔小于1.5秒，监控非常容易出问题，监控停止！GuardInternal:" + _config.GuardInternal);
return;
}
else if (_config.GuardInternal < 5000)
{
log.Warn("注意: 配置的监控间隔小于5秒，可能存在问题！GuardInternal:" + _config.GuardInternal);
}
while (Common.IsRun)
{
Thread.Sleep(_config.GuardInternal);
log.Info("开始一次守护主流程+++++++++++++++++++++++++++++++++++++++++++++++");
//进行进程守护 // 不管是哪种守护类型，都需要进行守护
try
{
if (_config.AppType == (int)Enums.EnumAppType.务)
{
ServiceManger sm = new ServiceManger();
if (sm.GetServiceValue(_config.AppName, "State").ToString().Equals(ServiceState.Stopped))
{
log.Error("服务状态已停止，开始处理错误");
_appErrExecutor.HandleError(Enums.EnumHandleCondition.务进程停止, _config, LastProcessTime);
continue;
}
else
{
log.Info("服务状态正在运行！");
LastProcessTime = DateTime.Now;
}
}
else
{
if (ProcessHelper.ExistProcess(_config.AppName) == false)
{
log.Error("进程已停止，开始处理错误");
_appErrExecutor.HandleError(Enums.EnumHandleCondition.务进程停止, _config, LastProcessTime);
continue;
}
else
{
log.Info("进程运行正常!");
LastProcessTime = DateTime.Now;
}
}
}
catch (Exception ex)
{
log.Error(string.Format("进程守护 ID[{0}] 名称[{1}] 出错: ", _config.ID, _config.AppName) + ex.ToString());
continue;
}
if (_config.GuardType == (int)Enums.EnumGuardType.心跳守护)
{
log.Info("开始心跳检测");
try
{
log.Info("开始检测状态中心健康情况");
IStateCenterConnector connector = StateCenterConnectorFactory.GetAvailableConnector();
if (connector == null || !connector.IsCenterAlived())
{
log.Error("状态中心无法连接，开始处理错误：");
_appErrExecutor.HandleError(Enums.EnumHandleCondition.务不可见, _config, LastStateCenterTime);
continue;
}
else
{
log.Info("状态中心连接正常");
LastStateCenterTime = DateTime.Now;
}
string beatName = ComputerInfo.GetMacAddress() + "." + _config.AppName;
log.Info(string.Format("开始获取心跳时间：[{0}]", beatName));
// 心跳检测
DateTime?lastBeatTime = connector.GetLastBeatTime(beatName);
if (lastBeatTime.HasValue == false)
{
log.Error("连接的服务未向中心发出心跳，首次连接不正常，不进行处理");
count1++;
if (count1 > 100)
{
log.Error("超过100次，无法抓取到首次心跳反应，监控终止");
return;
}
}
else
{
//首次心跳
if (LastBeatTime == null)
{
LastBeatTime = lastBeatTime;
log.Info("首次心跳时间:" + LastBeatTime.Value.ToString("yyyy-MM-dd HH:mm:ss"));
}
else
{
log.Info("远程心跳时间： " + lastBeatTime.Value.ToString("yyyy-MM-dd HH:mm:ss"));
//先判断是链路是否通着，只有通着的时候，才判断是否心跳
if (connector.IsClientAlived(beatName))
{
if (lastBeatTime.Value == LastBeatTime.Value)
{
log.Error(string.Format("心跳未进行:处理问题 lastBeatTime:" + lastBeatTime.Value.ToString("yyyy-MM-dd HH:mm:ss")));
_appErrExecutor.HandleError(Enums.EnumHandleCondition.务可见心脏停止跳动, _config, LastBeatTime);
}
else
{
LastBeatTime = lastBeatTime;
log.Info("正常心跳");
//重置状态
_appErrExecutor.ResetState();
}
}
else
{
log.Error("客户端服务未能正常连接到状态中心，心跳监控失效");
continue;
}
}
}
}
catch (Exception ex)
{
log.Error(string.Format("心跳 ID[{0}] 名称[{1}] 出错: ", _config.ID, _config.AppName) + ex.ToString());
continue;
}
}
}
}
private void CreateEngine(ProcessHelper p)
{
try
{
Engine engine = new Engine(p.Process);
Engine.Current = engine;
p.Owner.CallUI <TextBlock>("Tag", "Account").SetUI <TextBlock>("Text", "Waiting for D3 to start...");
p.Owner.CallUI <TextBlock>("Tag", "BattleTag").SetUI <TextBlock>("Text", "Gathering information...");
while (engine == null)
{
Thread.Sleep(1000);
engine = new Engine(p.Process);
Engine.Current = engine;
}
while (engine.ApplicationLoopCount == 0)
{
Thread.Sleep(1000);
}
Engine.Current = engine;
p.Engine = engine;
p.Owner.CallUI <TextBlock>("Tag", "Account").SetUI <TextBlock>("Text", "Trying to resolve BattleTag");
p.Owner.CallUI <TextBlock>("Tag", "BattleTag").SetUI <TextBlock>("Text", "Waiting for login into Diablo III");
while (engine.Memory.Reader.ReadChain <int>(OffsetConversion.ScreenManager, OffsetConversion.BattleNetClient, OffsetConversion.SelectedHeroes) == 0) // Haven't loaded a hero or logged-in
{
Thread.Sleep(1000);
}
if (Config.Get <FKAccounts>().GetAccount(HeroReader.GetBattleTag.ToString()) == null)
{
p.Owner.CallUI <TextBlock>("Tag", "Account").SetUI <TextBlock>("Text", "This account has not been setup");
p.Owner.CallUI <TextBlock>("Tag", "Account").SetUI <TextBlock>("Foreground", Extensions.HexToBrush("#ff4444"));
p.Owner.CallUI <TextBlock>("Tag", "BattleTag").SetUI <TextBlock>("Text", "You need to configure it in Settings > Multibox Accounts");
return;
}
p.Owner.CallUI <TextBlock>("Tag", "Account").SetUI <TextBlock>("Text", Config.Get <FKAccounts>().GetAccount(HeroReader.GetBattleTag.ToString()).Nickname);
p.AccountSettings = Config.Get <FKAccounts>().GetAccount(HeroReader.GetBattleTag.ToString());
p.Loaded = true;
p.Enabled = true;
//Extensions.Execute.UIThread(()=> p.Owner.CallUI<Image>("Tag", "EnableAcc").CheckBox(p.Enabled));
p.Owner.CallUI <Image>("Tag", "EnableAcc").SetUI <Image>("Tag", p);
p.Owner.CallUI <TextBlock>("Tag", "BattleTag").SetUI <TextBlock>("Text", HeroReader.GetBattleTag.ToString());
if (Config.Get <FKAccounts>().GetAccount(HeroReader.GetBattleTag.ToString()).MainAccount)
{
Extensions.Execute.UIThread(() =>
{
p.Owner.CallUI <Image>("Tag", "MainAccountSel").Source = Extensions.FKImage("./app");
p.Owner.CallUI <Image>("Tag", "MainAccountSel").FindParent <StackPanel>().ToolTip = new TextBlock {
Text = "This is set as your main account"
};
});
}
HeroData(p);
}
catch (Exception e)
{
Extensions.Execute.UIThread(() => MessageBox.Show(e.ToString()));
}
}
public XUnitHelper(Tracer tracer, FileSystemHelper fileSystem, ProcessHelper process)
{
_fileSystem = fileSystem;
_process = process;
_tracer = tracer;
}
private void RemoveHandler(ProcessHelper Helper)
{
Helper.Process.Exited -= Helper.ExitHandler;
Helper.Dispose();
PHelper.Remove(Helper.Key);
}
public static async Task ShowUserDialog(UserViewModel user)
{
if (user != null && !user.IsAnonymous)
{
object result = await DialogHelper.ShowCustom(new UserDialogControl(user));
if (result != null)
{
UserDialogResult dialogResult = EnumHelper.GetEnumValueFromString <UserDialogResult>(result.ToString());
switch (dialogResult)
{
case UserDialogResult.Purge:
await ChannelSession.Services.Chat.PurgeUser(user);
break;
case UserDialogResult.Timeout1:
await ChannelSession.Services.Chat.TimeoutUser(user, 60);
break;
case UserDialogResult.Timeout5:
await ChannelSession.Services.Chat.TimeoutUser(user, 300);
break;
case UserDialogResult.Ban:
if (await DialogHelper.ShowConfirmation(string.Format("This will ban the user {0} from this channel. Are you sure?", user.DisplayName)))
{
await ChannelSession.Services.Chat.BanUser(user);
}
break;
case UserDialogResult.Unban:
await ChannelSession.Services.Chat.UnbanUser(user);
break;
case UserDialogResult.Follow:
await ChannelSession.TwitchUserConnection.FollowUser(ChannelSession.TwitchUserNewAPI, user.GetTwitchNewAPIUserModel());
break;
case UserDialogResult.Unfollow:
await ChannelSession.TwitchUserConnection.UnfollowUser(ChannelSession.TwitchUserNewAPI, user.GetTwitchNewAPIUserModel());
break;
case UserDialogResult.PromoteToMod:
if (await DialogHelper.ShowConfirmation(string.Format("This will promote the user {0} to a moderator of this channel. Are you sure?", user.DisplayName)))
{
await ChannelSession.Services.Chat.ModUser(user);
}
break;
case UserDialogResult.DemoteFromMod:
if (await DialogHelper.ShowConfirmation(string.Format("This will demote the user {0} from a moderator of this channel. Are you sure?", user.DisplayName)))
{
await ChannelSession.Services.Chat.UnmodUser(user);
}
break;
case UserDialogResult.ChannelPage:
ProcessHelper.LaunchLink(user.ChannelLink);
break;
case UserDialogResult.EditUser:
UserDataModel userData = ChannelSession.Settings.GetUserData(user.ID);
if (userData != null)
{
UserDataEditorWindow window = new UserDataEditorWindow(userData);
await Task.Delay(100);
window.Show();
await Task.Delay(100);
window.Focus();
}
break;
case UserDialogResult.Close:
default:
// Just close
break;
}
}
}
}
public Task <bool> ExecuteAsync()
{
return(Task.Run(() =>
{
Console.WriteLine("Start Electron Desktop Application...");
string aspCoreProjectPath = "";
if (_args.Length > 0)
{
if (Directory.Exists(_args[0]))
{
aspCoreProjectPath = _args[0];
}
}
else
{
aspCoreProjectPath = Directory.GetCurrentDirectory();
}
string tempPath = Path.Combine(aspCoreProjectPath, "obj", "Host");
if (Directory.Exists(tempPath) == false)
{
Directory.CreateDirectory(tempPath);
}
var platformInfo = GetTargetPlatformInformation.Do(String.Empty, String.Empty);
string tempBinPath = Path.Combine(tempPath, "bin");
var resultCode = ProcessHelper.CmdExecute($"dotnet publish -r {platformInfo.NetCorePublishRid} --output \"{tempBinPath}\"", aspCoreProjectPath);
if (resultCode != 0)
{
Console.WriteLine("Error occurred during dotnet publish: " + resultCode);
return false;
}
DeployEmbeddedElectronFiles.Do(tempPath);
var checkForNodeModulesDirPath = Path.Combine(tempPath, "node_modules");
if (Directory.Exists(checkForNodeModulesDirPath) == false)
{
Console.WriteLine("node_modules missing in: " + checkForNodeModulesDirPath);
Console.WriteLine("Start npm install...");
ProcessHelper.CmdExecute("npm install", tempPath);
}
else
{
Console.WriteLine("Skip npm install, because node_modules directory exists in: " + checkForNodeModulesDirPath);
}
string path = Path.Combine(tempPath, "node_modules", ".bin");
bool isWindows = RuntimeInformation.IsOSPlatform(OSPlatform.Windows);
if (isWindows)
{
Console.WriteLine("Invoke electron.cmd - in dir: " + path);
ProcessHelper.CmdExecute(@"electron.cmd ""..\..\main.js""", path);
}
else
{
Console.WriteLine("Invoke electron - in dir: " + path);
ProcessHelper.CmdExecute(@"./electron ""../../main.js""", path);
}
return true;
}));
}
public static void Main(string [] args)
{
ProcessHelper.Exit(Main2(args)); // Work around #499702
}
internal override async Task <bool> OnAfterUpdate(SafeDictionary <string, object> keys)
{
if (Debugger.IsAttached)
{
if (MessageBox.Show("Install updates?", "Caution", MessageBoxButton.YesNo) == MessageBoxResult.No)
{
return(true);
}
}
ReportProgress("Installing Updates");
await Task.Delay(1000);
var dir = new DirectoryInfo(Common.Path() + "Updates");
if (!dir.Exists)
{
dir.Create();
}
var name = Environment.MachineName;
try
{
var resp =
await
ServerRequestHelper.GetObjectFromServerAsync <TerminalInfoResponse>(keys["hospitalserver"].ToString(),
"get_terminal_info/");
name = resp.Result.TerminalName;
}
catch
{
//maybe get_terminal_info not implemented - compatibility
}
var nameRequiresChange = name != Environment.MachineName;
////throw new Exception("Sfgfg");
var response =
await
ServerRequestHelper.GetObjectFromServerAsync <List <UpdatePackage> >(keys["hospitalserver"].ToString(), "get_terminal_updates/");
var updates = new List <Update>();
var freeze = FreezeHelper.IsFreezeEnabled();
if (!response.Success)
{
return(true);
}
if (nameRequiresChange)
{
if (await LockdownManager.IsFrozen() == true)
{
ReportProgress("Rebooting to unfreeze");
await Task.Delay(1500);
LockdownManager.Unfreeze();
App.ShutdownSafe(false);
return(true);
}
}
response.Result.ForEach(p => p.Updates.ForEach(u => u.PackageId = p.Id));
if (nameRequiresChange)
{
if (Debugger.IsAttached)
{
if (MessageBox.Show("Change hostname?", "Question", MessageBoxButton.YesNo) == MessageBoxResult.Yes)
{
Common.SetMachineName(name);
}
}
else
{
Common.SetMachineName(name);
ReportProgress("Rebooting to change hostname");
await Task.Delay(3000);
ProcessHelper.Reboot();
return(true);
}
}
foreach (var package in response.Result)
{
ReportProgress(package.Name);
foreach (var update in package.Updates)
{
try
{
if (SkipUpdate(update.Id))
{
continue;
}
if (await LockdownManager.IsFrozen() == true)
{
ReportProgress("Rebooting to unfreeze");
await Task.Delay(1500);
LockdownManager.Unfreeze();
App.ShutdownSafe(false);
return(true);
}
updates.Add(update);
var tempPath = System.IO.Path.GetTempPath(); //C:\\Users\\<UserName>\\AppData\\Local\\Temp
var updateDir = new DirectoryInfo(tempPath + "PanaceaUpdates\\" + update.Id);
if (!updateDir.Exists)
{
updateDir.Create();
}
await _webClient.DownloadFileTaskAsync(
new Uri(keys["hospitalserver"] + "/" + update.PatchScript),
updateDir + "\\" + Path.GetFileName(update.PatchScript));
foreach (var file in update.RequiredFiles)
{
await _webClient.DownloadFileTaskAsync(
new Uri(keys["hospitalserver"] + "/" + file),
updateDir + "\\" + Path.GetFileName(file));
}
ReportProgress("Installing...");
var code = await Task.Run(() =>
{
var info = new ProcessStartInfo()
{
WorkingDirectory = updateDir.ToString(),
FileName = updateDir + "\\" + Path.GetFileName(update.PatchScript),
CreateNoWindow = true,
UseShellExecute = false,
Verb = "runas"
};
var p = new Process {
StartInfo = info
};
try
{
p.Start();
p.WaitForExit();
return(p.ExitCode);
}
catch
{
return(9001);
}
});
//OnProgressFiles(code == 0 ? "Installation successful!" : "Installation failed");
await Task.Delay(1000);
update.Installed = code == 0;
update.ExitCode = code;
if (code != 0)
{
continue;
}
AddRegistryUpdate(update);
await ReportToServer(keys["hospitalserver"].ToString(), update.Id, package.Id, code);
try
{
File.Delete(updateDir + "\\" + Path.GetFileName(update.PatchScript));
foreach (var file in update.RequiredFiles)
{
File.Delete(updateDir + "\\" + Path.GetFileName(file));
}
}
catch { }
if (update.RequiresReboot != "yes")
{
continue;
}
ProcessHelper.Reboot();
return(false);
}
catch
{
update.ExitCode = 9999;
AddRegistryUpdate(update);
await ReportToServer(keys["hospitalserver"].ToString(), update.Id, package.Id, 9999);
}
}
}
if (updates.All(u => u.ExitCode != 0))
{
foreach (var update in updates)
{
AddRegistryUpdate(update);
await ReportToServer(keys["hospitalserver"].ToString(), update.Id, update.PackageId, update.ExitCode);
}
}
if (updates.Any(u => u.RequiresReboot == "batch" && u.ExitCode == 0))
{
ReportProgress("Restarting...");
await Task.Delay(1500);
ProcessHelper.Reboot();
return(false);
}
if (updates.Any(u => u.ExitCode != 0) && updates.Any(u => u.ExitCode == 0))
{
ReportProgress("Rebooting to retry updates that failed...");
await Task.Delay(1500);
ProcessHelper.Reboot();
return(false);
}
if (await LockdownManager.IsFrozen() == false && freeze)
{
if (updates.All(u => u.ExitCode == 0) || updates.All(u => u.ExitCode != 0))
{
ReportProgress("Rebooting to freeze");
await Task.Delay(1500);
LockdownManager.Freeze();
}
App.ShutdownSafe(false);
return(false);
}
return(true);
}
public ShaderCompilerResult Compile(ShaderCode shaderCode, ShaderCompilerArguments arguments)
{
var version = Version.Parse(arguments.GetString(CommonParameters.VersionParameterName));
var isVersion21OrLater = version >= new Version(2, 1);
var isVersion22OrLater = version >= new Version(2, 2);
var asic = arguments.GetString("Asic");
var directXMode = arguments.GetString("DirectXMode");
var entryPoint = arguments.GetString("EntryPoint");
var targetProfile = arguments.GetString("TargetProfile");
var shaderStage = arguments.GetString(CommonParameters.GlslShaderStage.Name);
using (var tempFile = TempFile.FromShaderCode(shaderCode))
{
var outputAnalysisPath = $"{tempFile.FilePath}.analysis";
var ilPath = $"{tempFile.FilePath}.il";
var isaPath = $"{tempFile.FilePath}.isa";
var liveRegPath = $"{tempFile.FilePath}.livereg";
var cfgPath = $"{tempFile.FilePath}.cfg";
var args = $"--asic \"{asic}\" --il \"{ilPath}\" --line-numbers --isa \"{isaPath}\" --parse-isa --livereg \"{liveRegPath}\" --cfg \"{cfgPath}\"";
switch (shaderCode.Language)
{
case LanguageNames.Hlsl:
switch (directXMode)
{
case "dx11":
args += isVersion22OrLater ? $" -s dx11" : " -s hlsl";
args += $" --profile {targetProfile} --function {entryPoint}";
args += $" \"{tempFile.FilePath}\"";
break;
case "dx12":
if (!isVersion22OrLater)
{
throw new InvalidOperationException("DX12 mode is only supported on RGA 2.2 and above");
}
args += " -s dx12";
var stage = targetProfile.Substring(0, 2);
args += $" --{stage}-model {targetProfile} --{stage}-entry {entryPoint}";
args += $" --all-hlsl \"{tempFile.FilePath}\"";
break;
}
break;
case LanguageNames.Glsl:
switch (arguments.GetString("GlslTarget"))
{
case TargetOpenGL:
args += $" -s opengl --{shaderStage}";
break;
case TargetVulkan:
args += $" -s {(isVersion21OrLater ? "vk-offline" : "vulkan")} --{shaderStage}";
break;
}
args += $" \"{tempFile.FilePath}\"";
break;
case LanguageNames.SpirvAssembly:
args += $" -s {(isVersion21OrLater ? "vk-spv-txt-offline" : "vulkan-spv-text")} --{shaderStage}";
args += $" \"{tempFile.FilePath}\"";
break;
}
var rgaPath = CommonParameters.GetBinaryPath("rga", arguments, "rga.exe");
var result = ProcessHelper.Run(
rgaPath,
args,
out var stdOutput,
out var stdError);
var actualOutputPathPrefix = Path.GetDirectoryName(tempFile.FilePath);
string GetActualOutputPath(string extension)
{
if (extension == "analysis" && shaderCode.Language == LanguageNames.Hlsl)
{
return(Path.Combine(
Path.GetDirectoryName(tempFile.FilePath),
$"{entryPoint}_{Path.GetFileName(tempFile.FilePath)}.analysis"));
}
switch (shaderCode.Language)
{
case LanguageNames.Hlsl:
if (directXMode == "dx12")
{
switch (targetProfile.Substring(0, 2))
{
case "cs":
switch (extension)
{
case "isa":
shaderStage = "comp";
break;
default:
shaderStage = "compute";
break;
}
break;
}
goto default;
}
return(Path.Combine(
actualOutputPathPrefix,
$"{asic}_{entryPoint}_{Path.GetFileName(tempFile.FilePath)}.{extension}"));
default:
if (isVersion21OrLater)
{
return(Path.Combine(
actualOutputPathPrefix,
$"{asic}_{Path.GetFileName(tempFile.FilePath)}_{shaderStage}.{extension}"));
}
else
{
return(Path.Combine(
actualOutputPathPrefix,
$"{asic}_{shaderStage}_{Path.GetFileName(tempFile.FilePath)}.{extension}"));
}
}
}
outputAnalysisPath = GetActualOutputPath("analysis");
ilPath = GetActualOutputPath("il");
isaPath = GetActualOutputPath("isa");
var isaCsvPath = GetActualOutputPath("csv");
liveRegPath = GetActualOutputPath("livereg");
cfgPath = GetActualOutputPath("cfg");
var outputAnalysis = FileHelper.ReadAllTextIfExists(outputAnalysisPath);
var il = FileHelper.ReadAllTextIfExists(ilPath);
var isa = FileHelper.ReadAllTextIfExists(isaPath);
var isaCsv = FileHelper.ReadAllTextIfExists(isaCsvPath);
var liveReg = FileHelper.ReadAllTextIfExists(liveRegPath);
var cfg = FileHelper.ReadAllTextIfExists(cfgPath);
FileHelper.DeleteIfExists(outputAnalysisPath);
FileHelper.DeleteIfExists(ilPath);
FileHelper.DeleteIfExists(isaPath);
FileHelper.DeleteIfExists(isaCsvPath);
FileHelper.DeleteIfExists(liveRegPath);
FileHelper.DeleteIfExists(cfgPath);
var selectedOutputIndex = !result || stdOutput.Contains("\nError: ") || stdOutput.Contains("... failed.")
? 5
: (int?)null;
var isaBreakdownJson = GetIsaBreakdownJson(isaCsv);
return(new ShaderCompilerResult(
selectedOutputIndex == null,
null,
selectedOutputIndex,
new ShaderCompilerOutput("ISA Disassembly", null, isa),
new ShaderCompilerOutput("ISA Breakdown", "jsontable", isaBreakdownJson),
new ShaderCompilerOutput("IL Disassembly", null, il),
//new ShaderCompilerOutput("Analysis", null, outputAnalysis),
new ShaderCompilerOutput("Live register analysis", null, liveReg),
new ShaderCompilerOutput("Control flow graph", "graphviz", cfg),
new ShaderCompilerOutput("Build output", null, stdOutput)));
}
}
protected override void Execute(GVFSEnlistment enlistment)
{
string diagnosticsRoot = Path.Combine(enlistment.DotGVFSRoot, "diagnostics");
if (!Directory.Exists(diagnosticsRoot))
{
Directory.CreateDirectory(diagnosticsRoot);
}
string archiveFolderPath = Path.Combine(diagnosticsRoot, "gvfs_" + DateTime.Now.ToString("yyyyMMdd_HHmmss"));
Directory.CreateDirectory(archiveFolderPath);
using (FileStream diagnosticLogFile = new FileStream(Path.Combine(archiveFolderPath, "diagnostics.log"), FileMode.CreateNew))
using (this.diagnosticLogFileWriter = new StreamWriter(diagnosticLogFile))
{
this.WriteMessage("Collecting diagnostic info into temp folder " + archiveFolderPath);
this.WriteMessage(string.Empty);
this.WriteMessage("gvfs version " + ProcessHelper.GetCurrentProcessVersion());
this.WriteMessage(GitProcess.Version(enlistment).Output);
this.WriteMessage(GitProcess.GetInstalledGitBinPath());
this.WriteMessage(string.Empty);
this.WriteMessage("Enlistment root: " + enlistment.EnlistmentRoot);
this.WriteMessage("Repo URL: " + enlistment.RepoUrl);
this.WriteMessage("Objects URL: " + enlistment.ObjectsEndpointUrl);
this.WriteMessage(string.Empty);
this.WriteMessage("Copying .gvfs folder...");
this.CopyAllFiles(enlistment.EnlistmentRoot, archiveFolderPath, GVFSConstants.DotGVFSPath, copySubFolders: false);
this.WriteMessage("Copying GVFlt logs...");
this.FlushGvFltLogBuffers();
string system32LogFilesPath = Environment.ExpandEnvironmentVariables(System32LogFilesRoot);
this.CopyAllFiles(system32LogFilesPath, archiveFolderPath, GVFltLogFolderName, copySubFolders: false);
this.WriteMessage("Checking on GVFS...");
this.RunAndRecordGVFSVerb <LogVerb>(archiveFolderPath, "gvfs_log.txt");
ReturnCode statusResult = this.RunAndRecordGVFSVerb <StatusVerb>(archiveFolderPath, "gvfs_status.txt");
if (statusResult == ReturnCode.Success)
{
this.WriteMessage("GVFS is mounted. Unmounting so we can read files that GVFS has locked...");
this.RunAndRecordGVFSVerb <UnmountVerb>(archiveFolderPath, "gvfs_unmount.txt");
}
else
{
this.WriteMessage("GVFS was not mounted.");
}
this.WriteMessage("Checking Defender exclusion...");
this.WriteAntivirusExclusions(enlistment.EnlistmentRoot, archiveFolderPath, "DefenderExclusionInfo.txt");
this.WriteMessage("Copying .git folder...");
this.CopyAllFiles(enlistment.WorkingDirectoryRoot, archiveFolderPath, GVFSConstants.DotGit.Root, copySubFolders: false);
this.CopyAllFiles(enlistment.WorkingDirectoryRoot, archiveFolderPath, GVFSConstants.DotGit.Hooks.Root, copySubFolders: false);
this.CopyAllFiles(enlistment.WorkingDirectoryRoot, archiveFolderPath, GVFSConstants.DotGit.Info.Root, copySubFolders: false);
this.CopyAllFiles(enlistment.WorkingDirectoryRoot, archiveFolderPath, GVFSConstants.DotGit.Logs.Root, copySubFolders: true);
this.CopyEsentDatabase <Guid, GVFltCallbacks.BackgroundGitUpdate>(
enlistment.DotGVFSRoot,
Path.Combine(archiveFolderPath, GVFSConstants.DotGVFSPath),
GVFSConstants.DatabaseNames.BackgroundGitUpdates);
this.CopyEsentDatabase <string, bool>(
enlistment.DotGVFSRoot,
Path.Combine(archiveFolderPath, GVFSConstants.DotGVFSPath),
GVFSConstants.DatabaseNames.DoNotProject);
this.CopyEsentDatabase <string, long>(
enlistment.DotGVFSRoot,
Path.Combine(archiveFolderPath, GVFSConstants.DotGVFSPath),
GVFSConstants.DatabaseNames.BlobSizes);
this.CopyEsentDatabase <string, string>(
enlistment.DotGVFSRoot,
Path.Combine(archiveFolderPath, GVFSConstants.DotGVFSPath),
GVFSConstants.DatabaseNames.RepoMetadata);
this.WriteMessage(string.Empty);
this.WriteMessage("Remounting GVFS...");
ReturnCode mountResult = this.RunAndRecordGVFSVerb <MountVerb>(archiveFolderPath, "gvfs_mount.txt");
if (mountResult == ReturnCode.Success)
{
this.WriteMessage("Mount succeeded");
}
else
{
this.WriteMessage("Failed to remount. The reason for failure was captured.");
}
this.CopyAllFiles(enlistment.DotGVFSRoot, Path.Combine(archiveFolderPath, GVFSConstants.DotGVFSPath), "logs", copySubFolders: false);
}
string zipFilePath = archiveFolderPath + ".zip";
ZipFile.CreateFromDirectory(archiveFolderPath, zipFilePath);
PhysicalFileSystem.RecursiveDelete(archiveFolderPath);
this.Output.WriteLine();
this.Output.WriteLine("Diagnostics complete. All of the gathered info, as well as all of the output above, is captured in");
this.Output.WriteLine(zipFilePath);
this.Output.WriteLine();
this.Output.WriteLine("If you are experiencing an issue, please email the GVFS team with your repro steps and include this zip file.");
}
private void OnGUI()
{
// 内容
GUILayout.BeginVertical("box", GUILayout.Width(400), GUILayout.Height(250));
{
GUILayout.Space(5);
GUILayout.BeginHorizontal();
{
GUILayout.FlexibleSpace();
GUILayout.Label("SCP同步工具");
GUILayout.FlexibleSpace();
}
GUILayout.EndHorizontal();
GUILayout.Space(5);
// IP地址输入框
GUILayout.BeginHorizontal();
{
GUILayout.Label("服务器ip:");
string currentIP = GUILayout.TextField(scpWindowData.serverIP, GUILayout.Width(250));
if (currentIP != scpWindowData.serverIP)
{
scpWindowData.serverIP = currentIP;
Save();
}
}
GUILayout.EndHorizontal();
// 用户名输入框
GUILayout.BeginHorizontal();
{
GUILayout.Label("用户名:");
string currentUsername = GUILayout.TextField(scpWindowData.username, GUILayout.Width(250));
if (scpWindowData.username != currentUsername)
{
scpWindowData.username = currentUsername;
Save();
}
}
GUILayout.EndHorizontal();
GUILayout.Space(20);
// 同步热更程序
GUILayout.BeginVertical("box", GUILayout.Width(400), GUILayout.Height(50));
{
// 服务器程序地址
GUILayout.BeginHorizontal();
{
GUILayout.Label("服务器程序地址:");
string currentProgramPath = GUILayout.TextField(scpWindowData.serverProgramPath, GUILayout.Width(250));
if (scpWindowData.serverProgramPath != currentProgramPath)
{
scpWindowData.serverProgramPath = currentProgramPath;
Save();
}
}
GUILayout.EndHorizontal();
GUILayout.Space(20);
if (GUILayout.Button("同步程序"))
{
Debug.Log("同步程序");
string localProgramPath = Application.dataPath.Replace("Unity/Assets", $"Bin/publish");
if (Directory.Exists(localProgramPath) == false)
{
Debug.LogError($"不存在路径: {localProgramPath}, 请检查是否 dotnet push ?");
return;
}
string arguments = $"-r {localProgramPath} {scpWindowData.username}@{scpWindowData.serverIP}:{scpWindowData.serverProgramPath}";
Debug.Log($"同步服务器程序, 命令: scp {arguments}");
ProcessHelper.Run("scp", arguments);
}
}
GUILayout.EndVertical();
GUILayout.Space(20);
// 同步热更资源
GUILayout.BeginVertical("box", GUILayout.Width(400), GUILayout.Height(50));
{
// 服务器资源地址
GUILayout.BeginHorizontal();
{
GUILayout.Label("服务器资源地址:");
string currentBundlePath = GUILayout.TextField(scpWindowData.serverBundlePath, GUILayout.Width(250));
if (scpWindowData.serverBundlePath != currentBundlePath)
{
scpWindowData.serverBundlePath = currentBundlePath;
Save();
}
}
GUILayout.EndHorizontal();
GUILayout.Space(10);
// 平台类型
PlatformType currentPlatform = (PlatformType)EditorGUILayout.EnumPopup(scpWindowData.platformType);
if (scpWindowData.platformType != currentPlatform)
{
scpWindowData.platformType = currentPlatform;
Save();
}
GUILayout.Space(10);
if (GUILayout.Button("同步资源"))
{
if (scpWindowData.platformType == PlatformType.None)
{
Debug.LogError("请选择平台, 当前为: None");
}
else
{
// Release下的热更目录
string platformName = Enum.GetName(typeof(PlatformType), scpWindowData.platformType);
string localBundlePath = Application.dataPath.Replace("Unity/Assets", $"Release/{platformName}");
if (Directory.Exists(localBundlePath) == false)
{
Debug.LogError($"不存在路径: {localBundlePath}, 请检查是否打包此平台的AssetBundle");
return;
}
string arguments = $"-r {localBundlePath} {scpWindowData.username}@{scpWindowData.serverIP}:{scpWindowData.serverBundlePath}";
Debug.Log($"同步服务器资源, 命令: scp {arguments}");
ProcessHelper.Run("scp", arguments);
}
}
}
GUILayout.EndVertical();
}
GUILayout.EndVertical();
}
/// <summary>
/// Launch the WinMerge
/// </summary>
/// <param name="filePath">The differences file</param>
public void LaunchApplication(string filePath)
{
ProcessHelper.Shell(filePath, string.Empty, ProcessWindowStyle.Normal, false);
}
public void Stop()
{
var ph = new ProcessHelper();
ph.TerminateProcess(process);
}
public HttpRequestor(ITracer tracer, RetryConfig retryConfig, GitAuthentication authentication)
{
this.client = new HttpClient(new HttpClientHandler()
{
UseDefaultCredentials = true
});
this.client.Timeout = retryConfig.Timeout;
this.RetryConfig = retryConfig;
this.authentication = authentication;
this.Tracer = tracer;
this.userAgentHeader = new ProductInfoHeaderValue(ProcessHelper.GetEntryClassName(), ProcessHelper.GetCurrentProcessVersion());
}
private static ProcessResult CallPowershellCommand(string command)
{
return(ProcessHelper.Run("powershell.exe", "-NonInteractive -NoProfile -Command \"& { " + command + " }\""));
}
public async Task <ExitCode> ExecuteAsync(
ILogger logger,
IReadOnlyCollection <IVariable> buildVariables,
CancellationToken cancellationToken)
{
var sourceRoot =
new DirectoryInfo(buildVariables.Require(WellKnownVariables.SourceRoot).ThrowIfEmptyValue().Value);
logger.Write($"Looking for paket.exe in source root {sourceRoot.FullName}");
PathLookupSpecification pathLookupSpecification = DefaultPaths.DefaultPathLookupSpecification.WithIgnoredFileNameParts(new List <string>());
FileInfo paketExe = null;
List <string> packageSpecifications =
sourceRoot.GetFilesRecursive(new List <string> {
".exe"
}, pathLookupSpecification)
.Where(file => file.Name.Equals("paket.exe", StringComparison.Ordinal))
.Select(f => f.FullName)
.ToList();
if (!packageSpecifications.Any())
{
FileInfo normalSearch = sourceRoot.GetFiles("paket.exe", SearchOption.AllDirectories)
.OrderBy(file => file.FullName.Length).FirstOrDefault();
if (normalSearch != null)
{
paketExe = normalSearch;
}
else
{
logger.Write("Could not find paket.exe, skipping paket restore");
return(ExitCode.Success);
}
}
if (paketExe == null)
{
IReadOnlyCollection <FileInfo> filtered =
packageSpecifications.Where(
packagePath =>
!pathLookupSpecification.IsFileBlackListed(
packagePath,
sourceRoot.FullName,
logger: logger).Item1)
.Select(file => new FileInfo(file))
.ToReadOnlyCollection();
if (!filtered.Any())
{
logger.Write(
$"Could not find paket.exe, filtered out: {string.Join(", ", packageSpecifications)}, skipping paket restore");
return(ExitCode.Success);
}
paketExe = filtered.First();
}
logger.Write($"Found paket.exe at '{paketExe.FullName}'");
string copyFromPath = buildVariables.GetVariableValueOrDefault("Arbor.X.Build.Tools.Paket.CopyExeFromPath", string.Empty);
if (!string.IsNullOrWhiteSpace(copyFromPath))
{
if (File.Exists(copyFromPath))
{
File.Copy(copyFromPath, paketExe.FullName, overwrite: true);
logger.Write($"Copied paket.exe to {paketExe.FullName}");
}
else
{
logger.Write($"The specified paket.exe path '{copyFromPath}' does not exist");
}
}
else
{
logger.Write($"Found no paket.exe to copy");
}
Directory.SetCurrentDirectory(sourceRoot.FullName);
ExitCode exitCode = await ProcessHelper.ExecuteAsync(
paketExe.FullName,
new List <string> {
"restore"
},
logger,
cancellationToken : cancellationToken);
return(exitCode);
}
public void Accept(ProcessHelper helper)
{
helper.SetColor(this);
}
public void TestProcessNfieldOrPs_ObjectCannotBeMapped_NotCallsNfieldAction()
{
int count = 0;
var mockedMapper = new Mock<IPSObjectMapper>();
var input = new PSObject();
ProcessHelper target = new ProcessHelper(mockedMapper.Object);
target.ProcessNfieldOrPs<Interviewer>(input,
(item) => { ++count; });
Assert.Equal(0, count);
}
