Exemple #1
0
        /// <summary>
        /// 핑체크하기
        /// </summary>
        protected void PingCheck()
        {
            List <string> checkIP = new List <string>();

            try
            {
                if (this.ServerList != null && this.ServerList.Count > 0)
                {
                    //등록된 서버목록을 돌아가면서 체크
                    foreach (ServerInfo srv in this.ServerList)
                    {
                        if (!checkIP.Contains(srv.IP))
                        {
                            if (CheckPing.TestPing(srv.IP))
                            {
                                checkIP.Add(srv.IP);
                            }
                        }
                    }
                }

                if (checkIP.Count > 0)
                {
                    //백업 (매월 1, 11, 21)에 실행한다.
                    //if (DateTime.Now.Day == 1 || DateTime.Now.Day == 11 || DateTime.Now.Day == 21)
                    //    BackUpResult();
                    //프로그램 실행
                    Process.Start(GlobalVar.RIMAGE_MEDICAL_CLIENT + ".exe");
                }
                else
                {
                    showMessage sm = new showMessage();
                    sm.Owner = this;
                    sm.ShowDialog();
                    sm.Dispose();
                }
            }
            catch (Exception ex)
            {
                ErrorLog.LogWrite(this, "프로그램 구동 중 에러가 발생 했습니다.\r\n" + ex.ToString(), Application.StartupPath);
                MessageBox.Show("프로그램 구동 중 에러가 발생 했습니다.\r\n" + ex.ToString(), "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }
Exemple #2
0
        /// <summary>
        ///     Permit to check new remote node host.
        /// </summary>
        /// <param name="ip"></param>
        public static async System.Threading.Tasks.Task <string> CheckNewRemoteNodeHostAsync(string ip)
        {
            InCheckingNewRemoteNode = true;
            var statusPing = CheckPing.CheckPingHost(ip);

            if (statusPing != -1)
            {
#if DEBUG
                Console.WriteLine("From Xiropht-Connector-All: ping status: " + ip + " " + statusPing + " ms.");
#endif
                var statusTcp = await CheckTcp.CheckTcpClientAsync(ip, ClassConnectorSetting.RemoteNodePort);

                if (statusTcp)
                {
                    if (ListRemoteNodeChecked.Count > 0)
                    {
                        var exist = false;
                        for (var i = 0; i < ListRemoteNodeChecked.Count - 1; i++)
                        {
                            if (ListRemoteNodeChecked[i].Item1 == ip)
                            {
                                exist = true;
                            }
                        }
                        if (!exist)
                        {
                            ListRemoteNodeChecked.Add(new Tuple <string, int>(ip, statusPing));
                            return(ClassRemoteNodeStatus.StatusNew);
                        }

                        return(ClassRemoteNodeStatus.StatusAlive);
                    }

                    ListRemoteNodeChecked.Add(new Tuple <string, int>(ip, statusPing));
                    return(ClassRemoteNodeStatus.StatusNew);
                }
            }

            InCheckingNewRemoteNode = false;
            return(ClassRemoteNodeStatus.StatusDead);
        }
Exemple #3
0
        /// <summary>
        /// Check if the wallet address exist on the network.
        /// </summary>
        /// <param name="walletAddress"></param>
        /// <returns></returns>
        public static async Task <bool> CheckWalletAddressExistAsync(string walletAddress)
        {
            if (Program.DictionaryWalletAddressCache.ContainsKey(walletAddress))
            {
                return(true);
            }
            Dictionary <string, int> listOfSeedNodesSpeed = new Dictionary <string, int>();

            foreach (var seedNode in ClassConnectorSetting.SeedNodeIp)
            {
                try
                {
                    int  seedNodeResponseTime = -1;
                    Task taskCheckSeedNode    = Task.Run(() => seedNodeResponseTime = CheckPing.CheckPingHost(seedNode.Key, true));
                    taskCheckSeedNode.Wait(ClassConnectorSetting.MaxPingDelay);
                    if (seedNodeResponseTime == -1)
                    {
                        seedNodeResponseTime = ClassConnectorSetting.MaxSeedNodeTimeoutConnect;
                    }
                    listOfSeedNodesSpeed.Add(seedNode.Key, seedNodeResponseTime);
                }
                catch
                {
                    listOfSeedNodesSpeed.Add(seedNode.Key, ClassConnectorSetting.MaxSeedNodeTimeoutConnect); // Max delay.
                }
            }

            listOfSeedNodesSpeed = listOfSeedNodesSpeed.OrderBy(u => u.Value).ToDictionary(z => z.Key, y => y.Value);

            foreach (var seedNode in listOfSeedNodesSpeed)
            {
                try
                {
                    string randomSeedNode = seedNode.Key;
                    string request        = ClassConnectorSettingEnumeration.WalletTokenType + ClassConnectorSetting.PacketContentSeperator + ClassRpcWalletCommand.TokenCheckWalletAddressExist + ClassConnectorSetting.PacketContentSeperator + walletAddress;
                    string result         = await ProceedHttpRequest("http://" + randomSeedNode + ":" + ClassConnectorSetting.SeedNodeTokenPort + "/", request);

                    if (result != string.Empty && result != PacketNotExist)
                    {
                        JObject resultJson = JObject.Parse(result);
                        if (resultJson.ContainsKey(PacketResult))
                        {
                            string resultCheckWalletAddress = resultJson[PacketResult].ToString();
                            if (resultCheckWalletAddress.Contains(ClassConnectorSetting.PacketContentSeperator))
                            {
                                var splitResultCheckWalletAddress = resultCheckWalletAddress.Split(new[] { ClassConnectorSetting.PacketContentSeperator }, StringSplitOptions.None);

                                if (splitResultCheckWalletAddress[0] == ClassRpcWalletCommand.SendTokenCheckWalletAddressValid)
                                {
                                    Program.SaveWalletAddressCache(walletAddress);
                                    return(true);
                                }
                            }
                        }
                    }
                }
                catch
                {
                }
            }
            return(false);
        }
Exemple #4
0
        /// <summary>
        ///     Start to connect on the seed node.
        /// </summary>
        /// <returns></returns>
        public async Task <bool> StartConnectToSeedAsync(string host, int port = ClassConnectorSetting.SeedNodePort, bool isLinux = false)
        {
            MalformedPacket = string.Empty;

            if (!string.IsNullOrEmpty(host))
            {
#if DEBUG
                Console.WriteLine("Host target: " + host);
#endif
                try
                {
                    _connector = new TcpClient();
                    await _connector.ConnectAsync(host, port);
                }

                catch (Exception error)
                {
#if DEBUG
                    Console.WriteLine("Error to connect on manual host node: " + error.Message);
#endif
                    _isConnected = false;
                    return(false);
                }

                _isConnected         = true;
                _currentSeedNodeHost = host;
                _connector.SetSocketKeepAliveValues(20 * 60 * 1000, 30 * 1000);
                return(true);
            }
            else
            {
                Dictionary <string, int> ListOfSeedNodesSpeed = new Dictionary <string, int>();
                foreach (var seedNode in ClassConnectorSetting.SeedNodeIp)
                {
                    try
                    {
                        int  seedNodeResponseTime = -1;
                        Task taskCheckSeedNode    = Task.Run(() => seedNodeResponseTime = CheckPing.CheckPingHost(seedNode.Key, true));
                        taskCheckSeedNode.Wait(ClassConnectorSetting.MaxPingDelay);
                        if (seedNodeResponseTime == -1)
                        {
                            seedNodeResponseTime = ClassConnectorSetting.MaxSeedNodeTimeoutConnect;
                        }
#if DEBUG
                        Console.WriteLine(seedNode.Key + " response time: " + seedNodeResponseTime + " ms.");
#endif
                        ListOfSeedNodesSpeed.Add(seedNode.Key, seedNodeResponseTime);
                    }
                    catch
                    {
                        ListOfSeedNodesSpeed.Add(seedNode.Key, ClassConnectorSetting.MaxSeedNodeTimeoutConnect); // Max delay.
                    }
                }

                ListOfSeedNodesSpeed = ListOfSeedNodesSpeed.OrderBy(u => u.Value).ToDictionary(z => z.Key, y => y.Value);

                var success        = false;
                var seedNodeTested = false;
                foreach (var seedNode in ListOfSeedNodesSpeed)
                {
#if DEBUG
                    Console.WriteLine("Seed Node Host target: " + seedNode.Key);
#endif
                    try
                    {
                        if (ClassConnectorSetting.SeedNodeDisconnectScore.ContainsKey(seedNode.Key))
                        {
                            int  totalDisconnection = ClassConnectorSetting.SeedNodeDisconnectScore[seedNode.Key].Item1;
                            long lastDisconnection  = ClassConnectorSetting.SeedNodeDisconnectScore[seedNode.Key].Item2;
                            if (lastDisconnection + ClassConnectorSetting.SeedNodeMaxKeepAliveDisconnection < ClassUtils.DateUnixTimeNowSecond())
                            {
                                totalDisconnection = 0;
                                ClassConnectorSetting.SeedNodeDisconnectScore[seedNode.Key] = new Tuple <int, long>(totalDisconnection, lastDisconnection);
                            }
                            if (totalDisconnection < ClassConnectorSetting.SeedNodeMaxDisconnection)
                            {
                                seedNodeTested = true;
                                int maxRetry = 0;
                                while (maxRetry < ClassConnectorSetting.SeedNodeMaxRetry || success)
                                {
                                    _connector = new TcpClient();
                                    var connectTask      = _connector.ConnectAsync(seedNode.Key, port);
                                    var connectTaskDelay = Task.Delay(ClassConnectorSetting.MaxSeedNodeTimeoutConnect);

                                    var completedConnectTask = await Task.WhenAny(connectTask, connectTaskDelay);

                                    if (completedConnectTask == connectTask)
                                    {
#if DEBUG
                                        Console.WriteLine("Successfully connected to Seed Node: " + seedNode.Key);
#endif
                                        success              = true;
                                        _isConnected         = true;
                                        _currentSeedNodeHost = seedNode.Key;
                                        maxRetry             = ClassConnectorSetting.SeedNodeMaxRetry;
                                        _connector.SetSocketKeepAliveValues(20 * 60 * 1000, 30 * 1000);
                                        await Task.Factory.StartNew(() => EnableCheckConnectionAsync(), CancellationToken.None, TaskCreationOptions.LongRunning, TaskScheduler.Current).ConfigureAwait(false);

                                        return(true);
                                    }
                                    else
                                    {
#if DEBUG
                                        Console.WriteLine("Failed to connect to Seed Node: " + seedNode.Key);
#endif
                                        if (maxRetry >= ClassConnectorSetting.SeedNodeMaxRetry)
                                        {
                                            ClassConnectorSetting.SeedNodeDisconnectScore[seedNode.Key] = new Tuple <int, long>(totalDisconnection + 1, ClassUtils.DateUnixTimeNowSecond());
                                        }
                                    }
                                    try
                                    {
                                        _connector?.Close();
                                        _connector?.Dispose();
                                    }
                                    catch
                                    {
                                    }
                                    maxRetry++;
                                }
                            }
                            else
                            {
#if DEBUG
                                Console.WriteLine("Max disconnection is reach for seed node: " + seedNode.Key);
#endif
                            }
                        }
                    }
                    catch (Exception error)
                    {
#if DEBUG
                        Console.WriteLine("Error to connect on seed node: " + error.Message);
#endif
                    }
                }
                if (!seedNodeTested) // Clean up just in case if every seed node return too much disconnection saved in their counter.
                {
                    foreach (var seednode in ClassConnectorSetting.SeedNodeIp)
                    {
                        if (ClassConnectorSetting.SeedNodeDisconnectScore.ContainsKey(seednode.Key))
                        {
                            ClassConnectorSetting.SeedNodeDisconnectScore[seednode.Key] = new Tuple <int, long>(0, 0);
                        }
                    }
                }
            }
            return(false);
        }