Пример #1
0
        private static void Main(string[] args)
        {
            ConfigurationOptions configR = new ConfigurationOptions();

            configR.ResolveDns = true;

            string host = config.IniReadValue("redis-server");
            int    port = 6379;

            if (host.Split(':').Length == 2)
            {
                port = int.Parse(host.Split(':')[1]);
            }

            host = host.Split(':')[0];

            configR.EndPoints.Add(Dns.GetHostAddresses(host)[0], port);

            Logger.AppLogLevel = Logger.LogLevel.Debug;
            Logger.Log(Logger.LogLevel.General, "Starting up!");

            Statics.HashRate = new PoolHashRateCalculation();

            Logger.Log(Logger.LogLevel.Debug, "Initialized PoolHashRateCalculation");
            try
            {
                Statics.RedisDb =
                    new RedisPoolDatabase(
                        ConnectionMultiplexer.Connect(configR)
                        .GetDatabase(int.Parse(config.IniReadValue("redis-database"))));
                Logger.Log(Logger.LogLevel.Debug, "Initialized RedisDb");
            }
            catch (StackExchange.Redis.RedisConnectionException)
            {
                if (NativeFunctions.IsLinux)
                {
                    Logger.Log(Logger.LogLevel.Error, "Redis connection failed.Retrying after 3 seconds");
                    Thread.Sleep(3 * 1000);
                    while (true)
                    {
                        try
                        {
                            Statics.RedisDb =
                                new RedisPoolDatabase(
                                    ConnectionMultiplexer.Connect(configR)
                                    .GetDatabase(int.Parse(config.IniReadValue("redis-database"))));
                            break;
                        }
                        catch
                        {
                        }
                        Logger.Log(Logger.LogLevel.Error, "Redis connection failed.Retrying after 3 seconds");
                        Thread.Sleep(3 * 1000);
                    }
                }
                else
                {
                    Logger.Log(Logger.LogLevel.Error, "Redis connection failed. Shutting down");
                    Environment.Exit(-1);
                }
            }
            Statics.BlocksPendingPayment = new List <PoolBlock>();
            Logger.Log(Logger.LogLevel.Debug, "Initialized BlocksPendingPayment");

            Statics.BlocksPendingSubmition = new List <PoolBlock>();
            Logger.Log(Logger.LogLevel.Debug, "Initialized BlocksPendingSubmition");

            Statics.Config = new IniFile("config.txt");
            Logger.Log(Logger.LogLevel.Debug, "Initialized Config");

            Statics.ConnectedClients = new Dictionary <string, ConnectedWorker>();
            Logger.Log(Logger.LogLevel.Debug, "Initialized ConnectedClients");

            Statics.DaemonJson = new JsonRPC(config.IniReadValue("daemon-json-rpc"));
            Logger.Log(Logger.LogLevel.Debug, "Initialized DaemonJson");

            Statics.WalletJson = new JsonRPC(config.IniReadValue("wallet-json-rpc"));
            Logger.Log(Logger.LogLevel.Debug, "Initialized WalletJson");

            Logger.Log(Logger.LogLevel.General, "Initialized Statics, initializing classes");



            BackgroundStaticUpdater backgroundSaticUpdater = new BackgroundStaticUpdater();

            backgroundSaticUpdater.Start();
            Logger.Log(Logger.LogLevel.Debug, "Initialized backgroundSaticUpdater");

            BlockPayment blockPayment = new BlockPayment();

            blockPayment.Start();
            Logger.Log(Logger.LogLevel.Debug, "Initialized BlockPayment");

            BlockSubmitter blockSubmitter = new BlockSubmitter();

            blockSubmitter.Start();
            Logger.Log(Logger.LogLevel.Debug, "Initialized BlockSubmitter");

            DifficultyRetargeter difficultyRetargeter = new DifficultyRetargeter();

            difficultyRetargeter.Start();
            Logger.Log(Logger.LogLevel.Debug, "Initialized DifficultyRetargeter");


            CryptoNightPool cryptoNightPool = new CryptoNightPool();

            cryptoNightPool.Start();
            Logger.Log(Logger.LogLevel.Debug, "Initialized CryptoNightPool");

            Logger.Log(Logger.LogLevel.General, "Initialized Classes");

            while (true)
            {
                Logger.Log(Logger.LogLevel.Debug, "Put the main thread into sleep...");
                Thread.Sleep(Timeout.Infinite);
            }
        }
Пример #2
0
        public async void Start()
        {
            Logger.Log(Logger.LogLevel.General, "Beginning Background Updater thread!");

            await Task.Yield();

            Statics.CurrentBlockHeight =
                (int)(await Statics.DaemonJson.InvokeMethodAsync("getblockcount"))["result"]["count"];
            Statics.CurrentBlockTemplate = (JObject)
                                           (await
                                            Statics.DaemonJson.InvokeMethodAsync("getblocktemplate",
                                                                                 new JObject(
                                                                                     new JProperty(
                                                                                         "reserve_size", 4),
                                                                                     new JProperty(
                                                                                         "wallet_address",
                                                                                         Statics.Config
                                                                                         .IniReadValue(
                                                                                             "wallet-address")))))
                                           ["result"];
            if (Statics.CurrentBlockTemplate == null || Statics.CurrentBlockHeight == 0)
            {
                Logger.Log(Logger.LogLevel.Error, "Failed to get block template and height. Shutting down!");
                Environment.Exit(-1);
            }
            Statics.HashRate.Begin      = DateTime.Now;
            Statics.HashRate.Difficulty = 0;
            Logger.Log(Logger.LogLevel.General, "Acquired block template and height, miners can connet now!");
            while (true)
            {
                try
                {
                    int newBlockHeight =
                        (int)(await Statics.DaemonJson.InvokeMethodAsync("getblockcount"))["result"]["count"];
                    Logger.Log(Logger.LogLevel.General, "Current pool hashrate : {0} Hashes/Second",
                               Helpers.GetHashRate(Statics.HashRate.Difficulty, Statics.HashRate.Time));

                    Statics.RedisDb.Information.CurrentBlock     = newBlockHeight;
                    Statics.RedisDb.Information.NewtworkHashRate =
                        (double)((int)Statics.CurrentBlockTemplate["difficulty"]) / 60;
                    Statics.RedisDb.Information.PoolHashRate = Helpers.GetHashRate(Statics.HashRate.Difficulty,
                                                                                   Statics.HashRate.Time);
                    Statics.RedisDb.Information.SharesPerSecond = (double)Statics.TotalShares / 5;
                    Statics.RedisDb.Information.RoundShares    += Statics.TotalShares;
                    Statics.RedisDb.Information.BaseDificulty   = int.Parse(Statics.Config.IniReadValue("base-difficulty"));
                    Statics.TotalShares = 0;
                    Statics.RedisDb.SaveChanges(Statics.RedisDb.Information);

                    Logger.Log(Logger.LogLevel.Verbose, "Updated database!");
                    if (newBlockHeight != Statics.CurrentBlockHeight)
                    {
                        Statics.CurrentBlockTemplate = (JObject)
                                                       (await
                                                        Statics.DaemonJson.InvokeMethodAsync("getblocktemplate",
                                                                                             new JObject(
                                                                                                 new JProperty(
                                                                                                     "reserve_size", 4),
                                                                                                 new JProperty(
                                                                                                     "wallet_address",
                                                                                                     Statics.Config
                                                                                                     .IniReadValue
                                                                                                     (
                                                                                                         "wallet-address")))))
                                                       ["result"];

                        Statics.HashRate.Difficulty             = 0;
                        Statics.HashRate.Time                   = 0;
                        Statics.HashRate.Begin                  = DateTime.Now;
                        Statics.RedisDb.Information.RoundShares = 0;
                        Statics.RedisDb.SaveChanges(Statics.RedisDb.Information);
                        Statics.CurrentBlockHeight = newBlockHeight;
                        Logger.Log(Logger.LogLevel.General, "New block with height {0}, updating Tcp Miners", newBlockHeight);

                        var localCopy = Statics.ConnectedClients.ToDictionary(x => x.Key, x => x.Value);

                        foreach (var connectedClient in localCopy)
                        {
                            if (connectedClient.Value.TcpClient != null)
                            {
                                JObject response = new JObject();

                                response["jsonrpc"] = "2.0";

                                response["method"] = "job";

                                JObject bluffResponse = new JObject();
                                CryptoNightPool.GenerateGetJobResponse(ref bluffResponse, connectedClient.Key);

                                response["params"] = bluffResponse["result"];
                                string s = JsonConvert.SerializeObject(response);
                                s += "\n";
                                byte[] byteArray = Encoding.UTF8.GetBytes(s);
                                connectedClient.Value.TcpClient.GetStream().Write(byteArray, 0, byteArray.Length);
                            }
                        }
                    }
                    var list = Statics.ConnectedClients.ToList();

                    Logger.Log(Logger.LogLevel.Debug, "Beginning client validation", newBlockHeight);

                    Parallel.For(0, list.Count, (i) =>
                    {
                        try
                        {
                            Miner miner = Statics.RedisDb.Miners.First(x => x.Address == list[i].Value.Address);
                            if (miner.TimeHashRate == null)
                            {
                                miner.TimeHashRate = new Dictionary <DateTime, double>();
                                miner.TimeHashRate.Add(DateTime.Now, Helpers.GetMinerHashRate(miner));
                            }

                            if ((DateTime.Now - list[i].Value.LastSeen).TotalSeconds >
                                int.Parse(Statics.Config.IniReadValue("client-timeout-seconds")))
                            {
                                Logger.Log(Logger.LogLevel.General, "Removing time out client {0}", list[i].Key);
                                Statics.ConnectedClients.Remove(list[i].Key);

                                miner.MinersWorker.Remove(list[i].Key);
                                miner.TimeHashRate.Add(DateTime.Now, Helpers.GetMinerHashRate(miner));

                                Statics.RedisDb.Remove(
                                    Statics.RedisDb.MinerWorkers.First(x => x.Identifier == list[i].Key));
                            }
                            else if ((DateTime.Now - miner.TimeHashRate.Last().Key).Minutes > 5)
                            {
                                miner.TimeHashRate.Add(DateTime.Now, Helpers.GetMinerHashRate(miner));
                            }

                            foreach (
                                var cur in miner.TimeHashRate.Where(x => (DateTime.Now - x.Key).Days >= 1).ToList())
                            {
                                miner.TimeHashRate.Remove(cur.Key);
                            }
                            Statics.RedisDb.SaveChanges(miner);
                        }
                        catch
                        {
                        }
                    });
                    System.Threading.Thread.Sleep(5000);
                }
                catch (Exception e)
                {
                    Logger.Log(Logger.LogLevel.Error, e.ToString());
                }
            }
        }