コード例 #1
0
 public static void ExecuteMethod_ObtainLockRemoveFromContainerAndDeleteProcess(string processID, Process process, ProcessContainer ownerProcessContainer)
 {
     if (process == null)
     {
         if (ownerProcessContainer != null && ownerProcessContainer.ProcessIDs != null)
         {
             ownerProcessContainer.ProcessIDs.Remove(processID);
             ownerProcessContainer.StoreInformation();
         }
     }
     else
     {
         string lockEtag = process.ObtainLockOnObject();
         if (lockEtag == null)
             return;
         try
         {
             if (ownerProcessContainer != null)
             {
                 ownerProcessContainer.ProcessIDs.Remove(process.ID);
                 ownerProcessContainer.StoreInformation();
             }
             process.DeleteInformationObject();
         }
         finally
         {
             process.ReleaseLockOnObject(lockEtag);
         }
     }
 }
        private void HandleTick(object sender, EventArgs e)
        {
            DispatcherTimer  timer   = sender as DispatcherTimer;
            ProcessContainer process = timer.Tag as ProcessContainer;

            if (timer != null && process != null)
            {
                timer.Stop();
                processList.Remove(process);
                scheduledList.Remove(process);
                Process.GetProcessById(process.Id).Kill();
            }
        }
コード例 #3
0
        public void EncodeTest()
        {
            //Arrange
            var cloudStorageConfiguration = new CloudStorageConfiguration(CloudStorageAccount.DevelopmentStorageAccount, new Version());

            var queueVideoRepository = new QueueVideoRepository(cloudStorageConfiguration.StorageAccount.CreateCloudQueueClient());
            var videoRepository      = new FakeVideoRepository(_blobSource, _blobDestination);
            var screenshotRepository = new FakeScreenshotRepository(_blobDestination);
            var mediaInfoReader      = new MediaInfoReader();
            var encoder           = new Encoder();
            var fileSystemWrapper = new FileSystemWrapper();

            var queueProcess    = new QueueProcess(1000, queueVideoRepository);
            var downloadProcess = new DownloadProcess(5, videoRepository, fileSystemWrapper);
            var encoderProcess  = new EncodeProcess(5, encoder, videoRepository, mediaInfoReader, queueVideoRepository, fileSystemWrapper);
            var uploadProcess   = new UploadProcess(5, videoRepository, screenshotRepository, fileSystemWrapper);
            var finishProcess   = new FinishProcess(queueVideoRepository, videoRepository, fileSystemWrapper);

            var queueContainer    = new ProcessContainer <object, QueueInformation, DownloadInformation>(queueProcess, downloadProcess);
            var downloadContainer = new ProcessContainer <QueueInformation, DownloadInformation, EncodeInformation>(downloadProcess, encoderProcess);
            var encoderContainer  = new ProcessContainer <DownloadInformation, EncodeInformation, UploadInformation>(encoderProcess, uploadProcess);
            var uploadContainer   = new ProcessContainer <EncodeInformation, UploadInformation, object>(uploadProcess, finishProcess);

            var processManager = new EncodeProcessManager(queueVideoRepository.DeleteMessageLocal);

            processManager.Add(queueContainer);
            processManager.Add(downloadContainer);
            processManager.Add(encoderContainer);
            processManager.Add(uploadContainer);

            var timer = new Timer(UpdateMessages, queueVideoRepository, (int)queueVideoRepository.InvisibleTime.TotalMilliseconds / 2, (int)queueVideoRepository.InvisibleTime.TotalMilliseconds / 2);

            //Act & Assert
            Task task = processManager.Start();

            StartQueueWork();

            Thread.Sleep(30000);


            while (queueVideoRepository.ApproximateMessageCount > 0)
            {
                Thread.Sleep(60000);
            }

            //Thread.Sleep(50*60*1000);

            processManager.Stop();

            task.Wait();
        }
コード例 #4
0
        public void EncodeTest()
        {
            //Arrange
            var cloudStorageConfiguration = new CloudStorageConfiguration(CloudStorageAccount.DevelopmentStorageAccount, new Version());

            var queueVideoRepository = new QueueVideoRepository(cloudStorageConfiguration.StorageAccount.CreateCloudQueueClient());
            var videoRepository = new FakeVideoRepository(_blobSource, _blobDestination);
            var screenshotRepository = new FakeScreenshotRepository(_blobDestination);
            var mediaInfoReader = new MediaInfoReader();
            var encoder = new Encoder();
            var fileSystemWrapper = new FileSystemWrapper();

            var queueProcess = new QueueProcess(1000, queueVideoRepository);
            var downloadProcess = new DownloadProcess(5, videoRepository, fileSystemWrapper);
            var encoderProcess = new EncodeProcess(5, encoder, videoRepository, mediaInfoReader, queueVideoRepository, fileSystemWrapper);
            var uploadProcess = new UploadProcess(5, videoRepository, screenshotRepository, fileSystemWrapper);
            var finishProcess = new FinishProcess(queueVideoRepository, videoRepository, fileSystemWrapper);

            var queueContainer = new ProcessContainer<object, QueueInformation, DownloadInformation>(queueProcess, downloadProcess);
            var downloadContainer = new ProcessContainer<QueueInformation, DownloadInformation, EncodeInformation>(downloadProcess, encoderProcess);
            var encoderContainer = new ProcessContainer<DownloadInformation, EncodeInformation, UploadInformation>(encoderProcess, uploadProcess);
            var uploadContainer = new ProcessContainer<EncodeInformation, UploadInformation, object>(uploadProcess, finishProcess);

            var processManager = new EncodeProcessManager(queueVideoRepository.DeleteMessageLocal);
            processManager.Add(queueContainer);
            processManager.Add(downloadContainer);
            processManager.Add(encoderContainer);
            processManager.Add(uploadContainer);

            var timer = new Timer(UpdateMessages, queueVideoRepository, (int) queueVideoRepository.InvisibleTime.TotalMilliseconds/2, (int) queueVideoRepository.InvisibleTime.TotalMilliseconds/2);

            //Act & Assert
            Task task = processManager.Start();
            StartQueueWork();

            Thread.Sleep(30000);


            while (queueVideoRepository.ApproximateMessageCount > 0)
            {
                Thread.Sleep(60000);
            }

            //Thread.Sleep(50*60*1000);

            processManager.Stop();

            task.Wait();
        }
コード例 #5
0
        /// <summary>
        /// Initializes a new instance of the <see cref="ProcessContainerVM"/> class.
        /// </summary>
        /// <param name="process"> The process to be contained. </param>
        public ProcessContainerVM(ProcessContainer process)
        {
            this.processContainer = process;

            this.Modules = new ObservableCollection <ProcessModuleContainerVm>();

            if (this.processContainer.Modules != null)
            {
                foreach (var item in this.processContainer.Modules)
                {
                    this.Modules.Add(new ProcessModuleContainerVm(item));
                }
            }

            this.isChecked = false;
        }
コード例 #6
0
ファイル: Program.cs プロジェクト: Rhetos/AspNetFormsAuth
        internal static void Run(string[] args)
        {
            var commands = new List <Action <TransactionScopeContainer> >
            {
                container => CreateAdminUserAndPermissions(container),
                container =>
                {
                    string password = null;
                    for (int i = 0; i < args.Length; i++)
                    {
                        if (args[i] == "-pass" && i < args.Length - 1)
                        {
                            password = args[i + 1];
                            break;
                        }
                    }
                    SetUpAdminAccount(password);
                }
            };

            var processContainer = new ProcessContainer(
                addCustomConfiguration: configurationBuilder => configurationBuilder.AddConfigurationManagerConfiguration());

            // If the first command fails ("CreateAdminUserAndPermissions"), this program will still try to execute "SetUpAdminAccount" then report the exception later.
            var exceptions = new List <Exception>();

            foreach (var command in commands)
            {
                try
                {
                    using (var container = processContainer.CreateTransactionScopeContainer())
                    {
                        command(container);
                        container.CommitChanges();
                    }
                }
                catch (Exception ex)
                {
                    exceptions.Add(ex);
                }
            }

            if (exceptions.Any())
            {
                ExceptionsUtility.Rethrow(exceptions.First());
            }
        }
コード例 #7
0
        /// <summary>
        /// 根据游戏核心id来启动游戏
        /// </summary>
        /// <param name="id"></param>
        public virtual void Launch(string id)
        {
            if (this.ProcessContainer?.ProcessState == Model.ProcessState.Running)
            {
                throw new GameHasRanException()
                      {
                          ProcessContainer = this.ProcessContainer
                      }
            }
            ;
            else
            {
                this.ProcessContainer?.Dispose();
            }

            var core = this.CoreLocator.GetGameCoreFromId(id);

            if (core == null)
            {
                throw new GameCoreNotFoundException()
                      {
                          Id = id
                      }
            }
            ;

            this.ArgumentsBuilder = new ArgumentsBuilder(core, this.LaunchConfig);

            if (string.IsNullOrEmpty(this.LaunchConfig.NativesFolder))
            {
                this.LaunchConfig.NativesFolder = $"{PathHelper.GetVersionFolder(core.Root, id)}{PathHelper.X}natives";
            }

            var nativesDecompressor = new NativesDecompressor(core.Root, id);

            nativesDecompressor.Decompress(core.Natives, this.LaunchConfig.NativesFolder);

            this.ProcessContainer = new ProcessContainer(
                new ProcessStartInfo
            {
                WorkingDirectory = Directory.Exists(LaunchConfig.WorkingFolder) ? LaunchConfig.WorkingFolder : core.Root,
                Arguments        = ArgumentsBuilder.BulidArguments(),
                FileName         = this.LaunchConfig.JavaPath,
            });

            ProcessContainer.Start();
        }
コード例 #8
0
        /// <summary>
        /// 恢复根进程
        /// </summary>
        public static void Resume(this ProcessContainer processContainer)
        {
            if (processContainer.Process.Equals(null))
            {
                throw new NullReferenceException();
            }

            foreach (Process process in Process.GetProcesses())
            {
                if (process.Id.Equals(processContainer.Process.Id))
                {
                    NativeWin32MethodExtend.ResumeProcess(processContainer.Process.Id);
                    processContainer.ProcessState = Model.ProcessState.Running;
                }
            }

            throw new InvalidOperationException("The process has not been started or has exited. 该进程尚未启动或已退出。");
        }
コード例 #9
0
        public string GetData(int value)
        {
            string applicationFolder = @"";

            ConsoleLogger.MinLevel = EventType.Info; // Use EventType.Trace for more detailed log.

            using (var container = ProcessContainer.CreateTransactionScopeContainer(applicationFolder))
            {
                var context    = container.Resolve <Common.ExecutionContext>();
                var repository = context.Repository;

                // <<<< Copy-paste the example code here >>>>
            }



            return(string.Format("You entered: {0}", value));
        }
コード例 #10
0
ファイル: MainForm.cs プロジェクト: scottd564/ProcessWatcher
        private void ClearCreation(bool removeProcess = false)
        {
            string name = input_name.Text;

            input_name.Text      = "";
            input_process.Text   = "";
            input_startfrom.Text = "";
            input_target.Text    = "";

            toggle_web.Checked       = false;
            toggle_autostart.Checked = false;

            editingContainer = null;

            if (removeProcess)
            {
                ServerFactory.RemoveByName(name);
            }
        }
コード例 #11
0
        public async Task StartTest()
        {
            var receivedException = (Exception?)null;

            using var cancellationTokenSource = new CancellationTokenSource(TimeSpan.FromSeconds(5));
            await using var container         = new ProcessContainer(nameof(ProcessContainerTests));
            container.ExceptionOccurred      += (sender, exception) =>
            {
                Console.WriteLine($"ExceptionOccurred: {exception}");
                receivedException = exception;

                // ReSharper disable once AccessToDisposedClosure
                cancellationTokenSource.Cancel();
            };

            await container.InitializeAsync(cancellationTokenSource.Token);

            await container.StartAsync(cancellationTokenSource.Token);

            //await container.LoadAssemblyAsync("test", cancellationTokenSource.Token);

            var instance = await container.CreateObjectAsync <ISimpleEventClass>(typeof(SimpleEventClass), cancellationTokenSource.Token);

            instance.Event1 += (sender, args) => Console.WriteLine($"Hello, I'm the event. My value is {args}");

            instance.RaiseEvent1();
            Assert.AreEqual(321 + 123, instance.Method1(123));
            Assert.AreEqual("Hello, input = 123", instance.Method2("123"));

            try
            {
                await Task.Delay(TimeSpan.FromSeconds(1), cancellationTokenSource.Token);
            }
            catch (OperationCanceledException)
            {
            }

            if (receivedException != null)
            {
                Assert.Fail(receivedException.ToString());
            }
        }
コード例 #12
0
        private void InitializeRhetosTransactionScopeContainer()
        {
            if (_rhetosTransactionScope == null)
            {
                if (_processContainer == null)
                {
                    lock (_containerInitializationLock)
                        if (_processContainer == null)
                        {
                            _processContainer = new ProcessContainer(SearchForRhetosServerRootFolder(), new ConsoleLogProvider(),
                                                                     configurationBuilder => configurationBuilder.AddConfigurationManagerConfiguration());
                        }
                }

                _rhetosTransactionScope = _processContainer.CreateTransactionScopeContainer(InitializeSession);
                if (_commitChanges)
                {
                    _rhetosTransactionScope.CommitChanges();
                }
            }
        }
コード例 #13
0
ファイル: MainForm.cs プロジェクト: scottd564/ProcessWatcher
        private void Datagrid_view_CellContentClick(object sender, DataGridViewCellEventArgs e)
        {
            if (e.RowIndex < 0)
            {
                return;
            }

            if (lastInteraction.CompareTo(DateTime.Now) > 0)
            {
                return;
            }

            lastInteraction = DateTime.Now.AddSeconds(5);

            DataGridViewRow  gridRow       = datagrid_view.Rows[e.RowIndex];
            ProcessContainer procContainer = gridRow.DataBoundItem as ProcessContainer;

            if (e.ColumnIndex == 4)
            {
                if (procContainer.IsRunning)
                {
                    procContainer.CloseProcess();
                    gridRow.Cells["StartStatus"].Value = "Start";
                }
                else
                {
                    procContainer.CreateProcess();
                    gridRow.Cells["StartStatus"].Value = "Stop";
                }

                datagrid_view.RefreshEdit();
            }
            else if (e.ColumnIndex == 5)
            {
                EditContainer(procContainer);
            }
        }
コード例 #14
0
        public ProcessContainer AddProcess(ProcessBase process)
        {
            if (process.Debug == true)
            {
                //uruchamiamy proces w trybie debug
                var kontenerProcesu = new DebugProcesContainer()
                {
                    Id = process.Id
                };
                kontenerProcesu.Process     = process;
                kontenerProcesu.Thread      = new Thread(debugThread);
                kontenerProcesu.Thread.Name = "proces " + process.Id;
                process.Status = EnumProcessStatus.WaitingForExecution;
                debugProcesess.Add(kontenerProcesu);

                kontenerProcesu.Thread.Start(kontenerProcesu);
                return(kontenerProcesu);
            }
            else
            {
                process.Status = EnumProcessStatus.WaitingForExecution;
                var wm = new VirtualMachine.VirtualMachine();
                //dodaje tylko do kolejki uruchomienia - nie uruchamiam w tym wątku
                wm.Start(process, doExecuting: false);
                var xml = wm.Serialize();

                var serializedProcess = new ProcessContainer();
                serializedProcess.Id                = process.Id;
                serializedProcess.Status            = process.Status;
                serializedProcess.ExecutionDate     = process.ExecutionDate;
                serializedProcess.VirtualMachineXml = xml;

                dal.AddProcess(serializedProcess);
                return(serializedProcess);
            }
        }
コード例 #15
0
        /// <summary>
        /// 安装(异步)
        /// </summary>
        /// <returns></returns
        public async Task <ForgeInstallerResultModel> InstallAsync()
        {
            using var archive = ZipFile.OpenRead(this.ForgeInstallerPackagePath);
            var processOutputs      = new List <string>();
            var processErrorOutputs = new List <string>();

            #region Get version.json

            OnProgressChanged(0.1, $"Installing Forge Loader - Initializing");

            var versionJson = await ZipFileHelper.GetStringFromJsonEntryAsync
                                  (archive.Entries.First(x => x.Name.Equals("version.json", StringComparison.OrdinalIgnoreCase)));

            var versionModel = JsonConvert.DeserializeObject <CoreModel>(versionJson);

            var versionJsonFile = new FileInfo
                                      ($"{PathHelper.GetVersionFolder(this.CoreLocator.Root, versionModel.Id)}{PathHelper.X}{versionModel.Id}.json");
            if (!versionJsonFile.Directory.Exists)
            {
                versionJsonFile.Directory.Create();
            }

            File.WriteAllText(versionJsonFile.FullName, versionJson);

            OnProgressChanged(0.15, $"Installing Forge Loader - Initializing");

            #endregion

            #region Get install_profile.json

            var forgeInstallProfile = await ZipFileHelper.GetObjectFromJsonEntryAsync <ForgeInstallProfileModel>
                                          (archive.Entries.First(x => x.Name.Equals("install_profile.json", StringComparison.OrdinalIgnoreCase)));

            var forgeVersion = forgeInstallProfile.Version.Replace("-forge-", "-");

            forgeInstallProfile.Data["BINPATCH"].Client = $"[net.minecraftforge:forge:{forgeVersion}:clientdata@lzma]";
            forgeInstallProfile.Data["BINPATCH"].Server = $"[net.minecraftforge:forge:{forgeVersion}:serverdata@lzma]";

            OnProgressChanged(0.2, $"Installing Forge Loader - Initialized");

            #endregion

            #region Get Lzma

            OnProgressChanged(0.3, $"Installing Forge Loader - Extracting Files");

            var clientLzma = archive.Entries.FirstOrDefault(e => e.FullName.Equals("data/client.lzma", StringComparison.OrdinalIgnoreCase));
            var serverLzma = archive.Entries.FirstOrDefault(e => e.FullName.Equals("data/server.lzma", StringComparison.OrdinalIgnoreCase));

            var clientLzmaFile = new FileInfo(GetMavenFilePath(forgeInstallProfile.Data["BINPATCH"].Client));
            var serverLzmaFile = new FileInfo(GetMavenFilePath(forgeInstallProfile.Data["BINPATCH"].Server));

            await ZipFileHelper.WriteAsync(clientLzma, clientLzmaFile.Directory.FullName, clientLzmaFile.Name);

            await ZipFileHelper.WriteAsync(serverLzma, serverLzmaFile.Directory.FullName, serverLzmaFile.Name);

            #endregion

            #region Extract Forge Jar

            var forgeJar = archive.Entries.FirstOrDefault
                               (e => e.FullName.Equals($"maven/net/minecraftforge/forge/{forgeVersion}/forge-{forgeVersion}.jar", StringComparison.OrdinalIgnoreCase));
            var forgeUniversalJar = archive.Entries.FirstOrDefault
                                        (e => e.FullName.Equals($"maven/net/minecraftforge/forge/{forgeVersion}/forge-{forgeVersion}-universal.jar", StringComparison.OrdinalIgnoreCase));

            if (forgeJar != default)
            {
                if (forgeUniversalJar != default)
                {
                    var fileUniversalJar = new FileInfo($"{PathHelper.GetLibrariesFolder(this.CoreLocator.Root)}{PathHelper.X}{forgeUniversalJar.FullName.Replace("maven/", "").Replace("/", PathHelper.X)}");
                    if (!fileUniversalJar.Directory.Exists)
                    {
                        fileUniversalJar.Directory.Create();
                    }

                    await ZipFileHelper.WriteAsync(forgeUniversalJar, fileUniversalJar.Directory.FullName);
                }

                var file = new FileInfo($"{PathHelper.GetLibrariesFolder(this.CoreLocator.Root)}{PathHelper.X}{forgeJar.FullName.Replace("maven/", "").Replace("/", PathHelper.X)}");
                if (!file.Directory.Exists)
                {
                    file.Directory.Create();
                }

                await ZipFileHelper.WriteAsync(forgeJar, file.Directory.FullName);
            }

            OnProgressChanged(0.4, $"Installing Forge Loader - Extracted");

            #endregion

            #region Parser Processor

            OnProgressChanged(0.4, $"Installing Forge Loader - Parsering Processor");

            var replaceValues = new Dictionary <string, string>
            {
                { "{SIDE}", "client" },
                { "{MINECRAFT_JAR}", $"{PathHelper.GetVersionFolder(this.CoreLocator.Root,this.McVersionId)}{PathHelper.X}{this.McVersionId}.jar" },
                { "{MINECRAFT_VERSION}", this.McVersion },
                { "{ROOT}", this.CoreLocator.Root },
                { "{INSTALLER}", this.ForgeInstallerPackagePath },
                { "{LIBRARY_DIR}", PathHelper.GetLibrariesFolder(this.CoreLocator.Root) },
                { "/", PathHelper.X }
            };
            var replaceArgs = forgeInstallProfile.Data.Select(x => ($"{{{x.Key}}}", x.Value.Client)).ToDictionary(k => k.Item1, v =>
            {
                if (v.Client.Contains("[") && v.Client.Contains("]"))
                {
                    return(GetMavenFilePath(v.Client));
                }

                return(v.Client);
            });

            for (int i = 0; i < forgeInstallProfile.Processors.Count; i++)
            {
                var processModel = forgeInstallProfile.Processors[i];

                if (processModel.Sides != null && !processModel.Sides.Any(s => s.Equals("client", StringComparison.OrdinalIgnoreCase)))
                {
                    forgeInstallProfile.Processors.RemoveAt(i);
                    continue;
                }
            }

            for (int i = 0; i < forgeInstallProfile.Processors.Count; i++)
            {
                var processModel = forgeInstallProfile.Processors[i];

                processModel.Args = StringHelper.Replace(processModel.Args, replaceValues).ToList();
                processModel.Args = StringHelper.Replace(processModel.Args, replaceArgs).ToList();

                processModel.Args = processModel.Args.Select(x =>
                {
                    if (x.Contains("[") && x.Contains("]"))
                    {
                        return($"{Path.Combine(PathHelper.GetLibrariesFolder(this.CoreLocator.Root), new Library { Name = x.TrimStart('[').TrimEnd(']') }.GetRelativePath())}");
                    }

                    return(x);
                }).ToList();

                if (processModel.Outputs != default)
                {
                    processModel.Outputs = processModel.Outputs.Select
                                               (x => (StringHelper.Replace(x.Key, replaceArgs), StringHelper.Replace(x.Value, replaceArgs))).ToDictionary(k => k.Item1, v => v.Item2);
                }

                forgeInstallProfile.Processors[i] = processModel;
            }

            OnProgressChanged(0.5, $"Installing Forge Loader - Parsered Processor");

            #endregion

            #region Download Libraries

            OnProgressChanged(0.5, $"Installing Forge Loader - Downloading Libraries");

            for (int i = 0; i < versionModel.Libraries.Count; i++)
            {
                if (versionModel.Libraries[i].Name == forgeInstallProfile.Path)
                {
                    versionModel.Libraries.Remove(versionModel.Libraries[i]);
                }
            }

            for (int i = 0; i < forgeInstallProfile.Libraries.Count; i++)
            {
                if (forgeInstallProfile.Libraries[i].Name == $"{forgeInstallProfile.Path}:universal")
                {
                    forgeInstallProfile.Libraries.Remove(forgeInstallProfile.Libraries[i]);
                }
            }

            async Task Download(IEnumerable <HttpDownloadRequest> requests)
            {
                var manyBlock    = new TransformManyBlock <IEnumerable <HttpDownloadRequest>, HttpDownloadRequest>(x => x);
                var blockOptions = new ExecutionDataflowBlockOptions
                {
                    BoundedCapacity        = DependencesCompleter.MaxThread,
                    MaxDegreeOfParallelism = DependencesCompleter.MaxThread
                };

                var actionBlock = new ActionBlock <HttpDownloadRequest>(async x =>
                {
                    try
                    {
                        if (!x.Directory.Exists)
                        {
                            x.Directory.Create();
                        }

                        var res = await HttpHelper.HttpDownloadAsync(x, x.FileName);
                        if (res.HttpStatusCode != HttpStatusCode.OK)
                        {
                            this.ErrorDownload.Add(x);
                        }
                    }
                    catch
                    {
                        throw;
                    }
                }, blockOptions);

                var linkOptions = new DataflowLinkOptions {
                    PropagateCompletion = true
                };

                _ = manyBlock.LinkTo(actionBlock, linkOptions);

                _ = manyBlock.Post(requests);
                manyBlock.Complete();

                await actionBlock.Completion;

                GC.Collect();
            }

            var downloadList = versionModel.Libraries.Union(forgeInstallProfile.Libraries).Select(x =>
            {
                var result = x.GetDownloadRequest(this.CoreLocator.Root, true);

                if (SystemConfiguration.Api.Url != new Mojang().Url)
                {
                    result.Url = result.Url.Replace("https://maven.minecraftforge.net", $"{SystemConfiguration.Api.Url}/maven");
                }

                return(result);
            });

            await Download(downloadList);

            //Try Again
            if (ErrorDownload.Count > 0)
            {
                await Download(ErrorDownload.Select(x =>
                {
                    x.Url = x.Url.Replace($"{SystemConfiguration.Api.Url}/maven", "https://maven.minecraftforge.net");
                    return(x);
                }));
            }

            OnProgressChanged(0.8, $"Installing Forge Loader - Downloaded Libraries");

            #endregion

            #region Run Process

            OnProgressChanged(0.8, $"Installing Forge Loader - Processing");

            foreach (var process in forgeInstallProfile.Processors)
            {
                string JarFile = $"{Path.Combine(PathHelper.GetLibrariesFolder(this.CoreLocator.Root), new Library { Name = process.Jar }.GetRelativePath())}";

                using var JarFileArchive = ZipFile.OpenRead(JarFile);

                var      libEntry  = JarFileArchive.Entries.FirstOrDefault(e => e.FullName.Equals("META-INF/MANIFEST.MF", StringComparison.OrdinalIgnoreCase));
                string[] lines     = (await ZipFileHelper.GetStringFromJsonEntryAsync(libEntry)).Split("\r\n");
                var      mainClass = lines.ToList().FirstOrDefault(x => x.Contains("Main-Class: ")).Replace("Main-Class: ", "");

                var libs = new List <string>()
                {
                    process.Jar
                }.Concat(process.Classpath);
                var classpath = libs.Select(x => $"{Path.Combine(PathHelper.GetLibrariesFolder(this.CoreLocator.Root), new Library { Name = x }.GetRelativePath())}");
                var parameter = new List <string>
                {
                    "-cp",
                    $"\"{string.Join(ArgumentsBuilder.Separator,classpath)}\"",
                    mainClass
                };

                parameter.AddRange(process.Args);

                var processContainer = new ProcessContainer(new ProcessStartInfo(JavaPath)
                {
                    Arguments        = string.Join(" ", parameter),
                    WorkingDirectory = this.CoreLocator.Root
                });

                processContainer.Start();
                await processContainer.Process.WaitForExitAsync();

                processOutputs.AddRange(processContainer.OutputData);
                processErrorOutputs.AddRange(processContainer.ErrorData);

                processContainer.Dispose();
            }

            OnProgressChanged(0.9, $"Installing Forge Loader - Processed");

            #endregion

            OnProgressChanged(1.0, $"Installing Forge Loader - Finished");

            if (processErrorOutputs.Count > 0)
            {
                return new ForgeInstallerResultModel
                       {
                           IsSuccessful       = false,
                           Message            = $"Failed Install Forge-{forgeVersion}!",
                           ProcessOutput      = processOutputs,
                           ProcessErrorOutput = processErrorOutputs
                       }
            }
            ;

            return(new ForgeInstallerResultModel
            {
                IsSuccessful = true,
                Message = $"Successfully Install Forge-{forgeVersion}!",
                ProcessOutput = processOutputs,
                ProcessErrorOutput = processErrorOutputs
            });
        }
コード例 #16
0
ファイル: Objects.cs プロジェクト: DylanReeder/Class_A_Model
 public void Transfer(ProcessContainer to, int numAtoms)
 {
     to.Fill(Drain(numAtoms));
 }
コード例 #17
0
 /// <summary>
 /// Creates a thread-safe lifetime scope DI container to isolate unit of work in a separate database transaction.
 /// To commit changes to database, call <see cref="TransactionScopeContainer.CommitChanges"/> at the end of the 'using' block.
 /// </summary>
 public static TransactionScopeContainer CreateTransactionScopeContainer(Action <ContainerBuilder> registerCustomComponents = null)
 {
     return(ProcessContainer.CreateTransactionScopeContainer(registerCustomComponents));
 }
コード例 #18
0
        public async Task RealTest()
        {
            var receivedException = (Exception?)null;

            using var cancellationTokenSource = new CancellationTokenSource(TimeSpan.FromSeconds(15));
            await using var container         = new ProcessContainer(nameof(ProcessContainerTests))
                        {
                            MethodsCancellationToken = cancellationTokenSource.Token,
                        };
            container.ExceptionOccurred += (_, exception) =>
            {
                Console.WriteLine($"ExceptionOccurred: {exception}");
                receivedException = exception;

                // ReSharper disable once AccessToDisposedClosure
                cancellationTokenSource.Cancel();
            };

            await container.InitializeAsync(cancellationTokenSource.Token);

            await container.StartAsync(cancellationTokenSource.Token);

            var directory = Path.Combine(Path.GetTempPath(), "H.Containers.Tests_WitAiConverter");

            Directory.CreateDirectory(directory);
            var path  = Path.Combine(directory, "WitAiConverter.zip");
            var bytes = ResourcesUtilities.ReadFileAsBytes("WitAiConverter.zip");

            File.WriteAllBytes(path, bytes);

            ZipFile.ExtractToDirectory(path, directory, true);

            await container.LoadAssemblyAsync(Path.Combine(directory, "WitAiConverter.dll"), cancellationTokenSource.Token);

            var instance = await container.CreateObjectAsync <IConverter>("H.NET.Converters.WitAiConverter", cancellationTokenSource.Token);

            Assert.IsNotNull(instance);

            Assert.AreEqual("WitAiConverter", instance.ShortName);

            var availableSettings = instance.GetAvailableSettings().ToArray();

            Console.WriteLine("AvailableSettings:");
            foreach (var setting in availableSettings)
            {
                Console.WriteLine($" - {setting}");
            }
            CollectionAssert.AreEqual(
                new[] { "Token" },
                availableSettings);

            instance.SetSetting("Token", "XZS4M3BUYV5LBMEWJKAGJ6HCPWZ5IDGY");

            await BaseConvertersTests.ConvertTest(instance, "проверка_проверка_8000.wav", "проверка", cancellationTokenSource.Token);

            try
            {
                await Task.Delay(TimeSpan.FromSeconds(1), cancellationTokenSource.Token);
            }
            catch (OperationCanceledException)
            {
            }

            if (receivedException != null)
            {
                Assert.Fail(receivedException.ToString());
            }
        }
コード例 #19
0
 public static ProcessContainer GetTarget_OwnerProcessContainer()
 {
     return(ProcessContainer.RetrieveFromOwnerContent(InformationContext.CurrentOwner, "default"));
 }
コード例 #20
0
 public static void ExecuteMethod_ObtainLockRemoveFromContainerAndDeleteProcess(string processID, Process process, ProcessContainer ownerProcessContainer)
 {
     if (process == null)
     {
         if (ownerProcessContainer != null && ownerProcessContainer.ProcessIDs != null)
         {
             ownerProcessContainer.ProcessIDs.Remove(processID);
             ownerProcessContainer.StoreInformation();
         }
     }
     else
     {
         string lockEtag = process.ObtainLockOnObject();
         if (lockEtag == null)
         {
             return;
         }
         try
         {
             if (ownerProcessContainer != null)
             {
                 ownerProcessContainer.ProcessIDs.Remove(process.ID);
                 ownerProcessContainer.StoreInformation();
             }
             process.DeleteInformationObject();
         }
         finally
         {
             process.ReleaseLockOnObject(lockEtag);
         }
     }
 }
コード例 #21
0
 private static void ServerFactory_OnServerAdded(ProcessContainer pc)
 {
     util.Log($"Server '{pc.ProcName}': {pc.Path} was added.");
     ServerFactory.Save();
 }
コード例 #22
0
 /// <summary>
 /// Creates a thread-safe lifetime scope DI container to isolate unit of work in a separate database transaction.
 /// To commit changes to database, call <see cref="UnitOfWorkScope.CommitAndClose"/> at the end of the 'using' block.
 /// </summary>
 public static UnitOfWorkScope CreateScope(Action <ContainerBuilder> registerCustomComponents = null)
 {
     return(ProcessContainer.CreateScope(registerCustomComponents));
 }
コード例 #23
0
        public async Task BaseModuleTest <T>(
            string name,
            string typeName,
            string shortName,
            Func <T, CancellationToken, Task> testFunc)
            where T : class, IModule
        {
            var receivedException = (Exception?)null;

            using var tempDirectory           = new TempDirectory();
            using var cancellationTokenSource = new CancellationTokenSource(TimeSpan.FromSeconds(15));
            await using var container         = new ProcessContainer(nameof(ProcessContainerTests))
                        {
                            MethodsCancellationToken = cancellationTokenSource.Token,
                        };
            container.ExceptionOccurred += (_, exception) =>
            {
                Console.WriteLine($"ExceptionOccurred: {exception}");
                receivedException = exception;

                // ReSharper disable once AccessToDisposedClosure
                cancellationTokenSource.Cancel();
            };

            await container.InitializeAsync(cancellationTokenSource.Token);

            await container.StartAsync(cancellationTokenSource.Token);

            var path = tempDirectory.Extract(name);

            await container.LoadAssemblyAsync(path, cancellationTokenSource.Token);

            var types = await container.GetTypesAsync(cancellationTokenSource.Token);

            ShowList(types, "Available types");

            using var instance = await container.CreateObjectAsync <T>(typeName, cancellationTokenSource.Token);

            Assert.IsNotNull(instance);

            instance.NewCommand += (_, command) =>
            {
                Console.WriteLine($"{nameof(instance.NewCommand)}: {command}");
            };
            instance.ExceptionOccurred += (_, exception) =>
            {
                Console.WriteLine($"{nameof(instance.ExceptionOccurred)}: {exception}");
            };
            instance.LogReceived += (_, log) =>
            {
                Console.WriteLine($"{nameof(instance.LogReceived)}: {log}");
            };

            Assert.AreEqual(shortName, instance.ShortName);

            var availableSettings = instance.GetAvailableSettings().ToArray();

            ShowList(availableSettings, "Available settings");

            await testFunc(instance, cancellationTokenSource.Token);

            try
            {
                await Task.Delay(TimeSpan.FromSeconds(1), cancellationTokenSource.Token);
            }
            catch (OperationCanceledException)
            {
            }

            if (receivedException != null)
            {
                Assert.Fail(receivedException.ToString());
            }
        }
コード例 #24
0
        static void Main(string[] args)
        {
            string applicationFolder = @"..\..\..\..\Bookstore.Service\obj\Rhetos";
            var    directory         = System.IO.Directory.GetFiles(applicationFolder);

            ConsoleLogger.MinLevel = EventType.Info; // Use EventType.Trace for more detailed log.

            using (var container = ProcessContainer.CreateTransactionScopeContainer(applicationFolder))
            {
                var context    = container.Resolve <Common.ExecutionContext>();
                var repository = context.Repository;



                /*                            //DAY2
                 *
                 * //1
                 * foreach (var book in  repository.Bookstore.Book.Load())
                 * {
                 *  List<Guid> ids = new List<Guid>();
                 *
                 *  string authorName = string.Empty;
                 *  if (book.AuthorID.HasValue)
                 *  {
                 *      ids.Add(book.AuthorID.Value);
                 *
                 *      var author = repository.Bookstore.Person.Load(ids);//Obsolete?
                 *      authorName = author.FirstOrDefault()?.Name;
                 *  }
                 *
                 *  Console.WriteLine(book.Title + "\t\t\t\t" +  authorName);
                 * }
                 *
                 * Console.WriteLine();
                 * Console.WriteLine("------------------------");
                 * Console.WriteLine();
                 *
                 * //2
                 * var q = repository.Bookstore.Book.Query().Select(x => new { x.Title, x.NumberOfPages, x.Author.Name });
                 * ConsoleDump.Extensions.Dump(q);
                 *
                 * Console.WriteLine();
                 * Console.WriteLine("------------------------");
                 * Console.WriteLine();
                 *
                 * //3
                 * Console.WriteLine(q.ToString());
                 *
                 *
                 * //4
                 * repository.Bookstore.GenerateBooks.Execute(new GenerateBooks() { NumberOfBooks = 2, Title = "Novele" });
                 *
                 * //repository.Bookstore.Insert5Books.Execute(null);
                 * //repository.Bookstore.CreatePrincipal.Execute(new CreatePrincipal() {  Name = "Ivan Glas" });//ID ne radi jer u .rhe skripti tip podataka je Guid, pa ne radi konverzija u Guid?
                 *
                 *
                 * //DAY 2  */

                //DAY3
                var filterParametar = new Bookstore.LongBooks();
                var q = repository.Bookstore.Book.Query(filterParametar, typeof(Bookstore.LongBooks));


                var newForeignBook = new ForeignBook()
                {
                    ID = Guid.Parse("fb7237c7-aa8f-4c8c-8bee-589e32c8bee3"), OriginalLanguage = "HR"
                };
                repository.Bookstore.ForeignBook.Save(new List <ForeignBook> {
                    newForeignBook
                }, null, null);
                //repository.Bookstore.Book.Insert(newBook);

                ConsoleDump.Extensions.Dump(q);

                Console.WriteLine(q.ToString());

                container.CommitChanges();
                Console.ReadLine();
                // <<<< Copy-paste the example code here >>>>
            }
        }