Ejemplo n.º 1
0
        /// <summary>
        ///     Runs multichaind in a background process, connecting to a specified blockchain.
        ///     Optionally callsback on successful launch, determined by multichaind's stdout/err.
        /// </summary>
        /// <param name="chain">Blockchain connection/status data</param>
        /// <param name="clean">Should clean local blockchain directory?</param>
        /// <returns>Blockchain connection/status data</returns>
        private static async Task <MultichainModel> RunDaemon(MultichainModel chain, bool clean)
        {
            if (chain.Process != null)
            {
                try
                {
                    if (!chain.Process.HasExited)
                    {
                        return(chain);
                    }
                }
                // May throw exception if process has become unassociated
                catch (InvalidOperationException)
                {
                }
                Debug.WriteLine($"Restarting Multichaind for chain: {chain.Name}!!");
            }

            // Get working directory and multichaind.exe path
            var evotoDir        = MultiChainTools.GetAppDataFolder(allowSubDir: false);
            var multichainDPath = Path.Combine(evotoDir, "multichaind.exe");

            MultiChainTools.EnsureFileExists(multichainDPath, Resources.multichaind);

            var dataDir = MultiChainTools.GetAppDataFolder();

            // Clean if required (multichain bug)
            if (clean)
            {
                MultiChainTools.CleanBlockchain(dataDir, chain.Name);
            }

            Debug.WriteLine(
                $"Starting MultiChain connection to {chain.Name}@{chain.Hostname}:{chain.Port} ({chain.LocalPort})");
            Debug.WriteLine($"RPC Data: {RpcUser} : {chain.RpcPassword} : {chain.RpcPort}");
            var pArgs =
                $"{chain.Name}@{chain.Hostname}:{chain.Port} -daemon -datadir={dataDir} -server -port={chain.LocalPort}" +
                $" -rpcuser={RpcUser} -rpcpassword={chain.RpcPassword} -rpcport={chain.RpcPort}";

            chain.Process = new Process
            {
                StartInfo =
                {
                    // Stop the process from opening a new window
                    RedirectStandardOutput = true,
                    RedirectStandardError  = true,
                    UseShellExecute        = false,
                    CreateNoWindow         = true,

                    // Setup executable and parameters
                    FileName  = multichainDPath,
                    Arguments = pArgs
                }
            };

            var taskCompletion = new TaskCompletionSource <bool>();

            // Connect to outputs
            chain.Process.ErrorDataReceived += (sender, args) =>
            {
                if (string.IsNullOrWhiteSpace(args.Data))
                {
                    return;
                }
                Debug.WriteLine($"Multichaind Error ({chain.Name}): {args.Data}");
            };
            chain.Process.OutputDataReceived += (sender, e) =>
            {
                if (string.IsNullOrWhiteSpace(e.Data))
                {
                    return;
                }
                Debug.WriteLine($"Multichaind ({chain.Name}): {e.Data}");
                if (e.Data.Contains("Node started"))
                {
                    taskCompletion.SetResult(true);
                }
            };

            // Launch process
            var success = chain.Process.Start();

            if (!success)
            {
                throw new CouldNotStartProcessException();
            }

            // Read outputs
            chain.Process.BeginOutputReadLine();
            chain.Process.BeginErrorReadLine();
            chain.Process.EnableRaisingEvents = true;

            chain.Process.Exited += (sender, args) =>
            {
                // May have been disposed
                taskCompletion.TrySetResult(false);
            };

            await Task.Run(() =>
            {
                if (!taskCompletion.Task.Wait(TimeSpan.FromMinutes(1)))
                {
                    chain.Process.Kill();
                    throw new CouldNotConnectToBlockchainException("Timed Out");
                }
                if (!taskCompletion.Task.Result)
                {
                    throw new CouldNotConnectToBlockchainException();
                }
            });

            return(chain);
        }
        public static async Task CreateBlockchain(string blockchainName)
        {
            var evotoDir           = MultiChainTools.GetAppDataFolder(allowSubDir: false);
            var multichainUtilPath = Path.Combine(evotoDir, "multichain-util.exe");

            MultiChainTools.EnsureFileExists(multichainUtilPath, Resources.multichain_util);

            Debug.WriteLine($"Creating MultiChain: {blockchainName}");

            var dataDir = MultiChainTools.GetAppDataFolder();
            var process = new Process
            {
                StartInfo =
                {
                    // Stop the process from opening a new window
                    RedirectStandardOutput = true,
                    RedirectStandardError  = true,
                    UseShellExecute        = false,
                    CreateNoWindow         = true,

                    // Setup executable and parameters
                    FileName  = multichainUtilPath,
                    Arguments = $"-datadir={dataDir} create {blockchainName}"
                }
            };

            var outputQueue = new Queue <string>();
            var errQueue    = new Queue <string>();

            process.OutputDataReceived += (sender, args) =>
            {
                if (string.IsNullOrWhiteSpace(args.Data))
                {
                    return;
                }
                Debug.WriteLine($"Multichain-util: {args.Data}");
                outputQueue.Enqueue(args.Data);
            };
            process.ErrorDataReceived += (sender, args) =>
            {
                if (string.IsNullOrWhiteSpace(args.Data))
                {
                    return;
                }
                Debug.WriteLine($"Multichain-util Error: {args.Data}");
                errQueue.Enqueue(args.Data);
            };

            // Go
            var success = process.Start();

            if (!success)
            {
                throw new CouldNotCreateBlockchainException("Could not start process");
            }

            process.BeginOutputReadLine();
            process.BeginErrorReadLine();
            // Wait for process to end
            await Task.Run(() =>
            {
                if (process.WaitForExit(10 * 1000))
                {
                    // Allow error events time to be processed
                    Thread.Sleep(100);
                    if (errQueue.Count > 0)
                    {
                        throw new CouldNotCreateBlockchainException(string.Join("\n", errQueue));
                    }
                }
                else
                {
                    // Process hanging
                    process.Kill();
                    throw new CouldNotCreateBlockchainException("Process timed out");
                }
            });
        }