public override void Execute(IList <object> line)
{
if (line == null || line.Count < 3)
{
RigEx.WriteLineColors("Bot Id parametr error ".AddTimeStamp(), ConsoleColor.DarkRed);
return;
}
if (line[1].ToString().ToLower() != TeleSettings.MyName)
{
return;
}
int curVersion;
if (GetVersionString(line, out curVersion))
{
if (!gSheet.Data.VersionIsLiquid(curVersion, gSheet.NewVersion))
{
return;
}
else
{
RigEx.WriteLineColors($"Google Sheet you use last version: {curVersion}", ConsoleColor.Green);
}
}
else
{
RigEx.WriteLineColors("Google Sheet cannot read cur version from C", ConsoleColor.Red);
}
}
public MainClass()
{
_handler += new MainClass.EventHandler(Handler);
AppDomain.CurrentDomain.ProcessExit += (s, e) => { OnProcessExit(s, new EventType {
msg = "Quit"
}); };
SetConsoleCtrlHandler(_handler, true);
settings = new SettingsData();
controller = new Controller(settings);
Sheet = new GSheet(controller);
RigEx.WriteLineColors($"servise:\tGoogle Sheet\t- {Sheet != null}".AddTimeStamp(), Sheet != null ? ConsoleColor.DarkGreen : ConsoleColor.Red);
bool initBiosDone = controller.TelegramUser.Any() && controller.ServerList.Any();
RigEx.WriteLineColors($"servise:\tGoogle Reader\t- {initBiosDone}".AddTimeStamp(), initBiosDone ? ConsoleColor.DarkGreen : ConsoleColor.Red);
sensors = new SensorService(controller);
RigEx.WriteLineColors($"servise:\tSensors\t\t- {sensors != null}".AddTimeStamp(), sensors != null ? ConsoleColor.DarkGreen : ConsoleColor.Red);
alarmSensors = new AlarmData(controller);
RigEx.WriteLineColors($"servise:\tAlarmSensors\t- {alarmSensors != null}".AddTimeStamp(), alarmSensors != null ? ConsoleColor.DarkGreen : ConsoleColor.Red);
tbot = new TelegramBot(controller);
RigEx.WriteLineColors($"servise:\tTelegramBot\t- {tbot != null}".AddTimeStamp(), tbot != null ? ConsoleColor.DarkGreen : ConsoleColor.Red);
difficulty = new MineDifficulty(controller);
RigEx.WriteLineColors($"servise:\tWhat To Mine\t- {difficulty != null}".AddTimeStamp(), difficulty != null ? ConsoleColor.DarkGreen : ConsoleColor.Red);
miner = new Miner(controller);
RigEx.WriteLineColors($"servise:\tMiner \t- {miner != null}".AddTimeStamp(), miner != null ? ConsoleColor.DarkGreen : ConsoleColor.Red);
}
public void Execute(JsonData jd)
{
RigEx.WriteLineColors($"Command change miner {srv.Ctrl.CurMiner} to {jd.Value} ".AddTimeStamp(), ConsoleColor.Yellow);
var serv = srv.Ctrl.Miners.FirstOrDefault(i => i.Name == jd.Value);
if (serv != null)
{
if (srv.Ctrl.CurMiner.Name != serv.Name)
{
srv.Ctrl.MinerCommand(CurrentMinerCommand.ChangeAndRunMiner, jd);
}
else if (!srv.Ctrl.MinerStatus)
{
srv.Ctrl.MinerCommand(CurrentMinerCommand.LounchMiner);
}
else
{
RigEx.WriteLineColors($"Warning Change miner - Already Running {serv.Name}".AddTimeStamp(), ConsoleColor.DarkYellow);
srv.SendMsg($"{serv.Name} : already running");
}
}
else
{
RigEx.WriteLineColors($"Warning Change miner - canot fount miner {jd.Value}".AddTimeStamp(), ConsoleColor.DarkRed);
}
}
public override void Execute(IList <object> line)
{
if (line == null || line.Count < 2)
{
RigEx.WriteLineColors("CoinName parametr error ".AddTimeStamp(), ConsoleColor.DarkRed);
return;
}
int id;
if (!int.TryParse(line[2].ToString(), out id))
{
Console.WriteLine($"line {line[0]} senver name {line[1]} do not have id as int {line[2]} ");
}
string serverName = line[1].ToString().ToLower();
var newSheed = new ServerInfo(id, serverName, true);
if (serverName.Contains(GShSettings.PCname))
{
gSheet.MyPage.MyServerSheetId = newSheed;
}
else if (!gSheet.Data.ServersSheetId.Any(o => o.Name.Contains(serverName)))
{
gSheet.Data.ServersSheetId.Add(newSheed);
}
}
private void Start()
{
try
{
minerProcess = Process.Start(startInfo);
// minerProcess.WaitForExit();
// if (ctrl.MinerStatus)
// {
// RigEx.WriteLineColors("WaitForExit ".AddTimeStamp(), ConsoleColor.DarkCyan);
// }
}
catch (Exception e)
{
Console.WriteLine($"Error lounch {startInfo.FileName}: {e.Message} ");
}
while (true)
{
Thread.Sleep(1000);
if (ctrl.MinerStatus && minerProcess.HasExited)
{
RigEx.WriteLineColors($"relaunching miner: {ctrl.CurMiner.Name}".AddTimeStamp(), ConsoleColor.DarkCyan);
LaunchMiner();
return;
}
}
}
public void SendPingErrorList(List <IToken> errors)
{
foreach (IToken token in errors)
{
InlineKeyboardButton[][] testInlinekeyBoard = new InlineKeyboardButton[1][];
testInlinekeyBoard[0] = new InlineKeyboardButton[1];
testInlinekeyBoard[0][0] = new InlineKeyboardButton {
Text = $"stop ping", CallbackData = $"{TCmdType.stopPing}:{token.Name}"
};
InlineKeyboardMarkup keyboardInlineMarkUp = new InlineKeyboardMarkup(testInlinekeyBoard);
try
{
foreach (IToken user in Ctrl.TelegramUser)
{
try
{
Bot.Client?.SendTextMessageAsync(user.Id, $"Error {token.Name}", replyMarkup: keyboardInlineMarkUp);
}
catch (Exception e)
{
RigEx.WriteLineColors($"cannot send ping error {user.Id} message:Error {token.Name} e:{e.Message}".AddTimeStamp(), ConsoleColor.Red);
}
}
}
catch (Exception e)
{
RigEx.WriteLineColors($"cannot send ping error message:Error {token.Name} e:{e.Message}".AddTimeStamp(), ConsoleColor.DarkRed);
}
}
}
public Dictionary <string, double> GetDifficulty()
{
using (var client = new WebClient())
{
var json = client.DownloadString(JsonUrlWhattomine);
blob = JsonConvert.DeserializeObject <MineBlob>(json);
}
Dictionary <string, double> difficultyDictionary = new Dictionary <string, double>();
foreach (ICoin coin in ctrl.GetCoins)
{
if (!blob["coins"].ContainsKey(coin.Name))
{
RigEx.WriteLineColors($"{coin.Name} not found in WotToMine.com", ConsoleColor.DarkRed);
continue;
}
var blockReward = blob["coins"][coin.Name].BlockReward;
var blocksPerDay = blob["coins"][coin.Name].BlockTime;// * 24;//block count in day,
var netHash = blob["coins"][coin.Name].NetHash;
var proff = blob["coins"][coin.Name].Profitability;
string result = $"Rew: {blockReward} time: {blocksPerDay} nH: {netHash} = {86400 / blocksPerDay * blockReward / netHash * coin.Hashrate}";
RigEx.WriteLineColors($"{coin.Name}: \trew {blockReward} \tt:{blocksPerDay} \tnh {netHash} \t= {86400 / blocksPerDay * blockReward / netHash * coin.Hashrate} / {proff}", ConsoleColor.Cyan);
double reward = 86400 / blocksPerDay * blockReward / netHash * coin.Hashrate;
difficultyDictionary.Add(coin.Name, reward);
}
return(difficultyDictionary);
}
public override void Execute(IList <object> line)
{
if (line[1] == null || line[1].ToString() == string.Empty)
{
RigEx.WriteLineColors("Google Sheet cannot read miner name from B".AddTimeStamp(), ConsoleColor.Red);
}
gSheet.Data.MinersList.Add(new MinerInfo(line[1].ToString(), line[2].ToString()));
}
public void Execute()
{
RigEx.WriteLineColors($"Command {Name}", ConsoleColor.Yellow);
var d = srv.Ctrl.GetDiffucalty();
string diff = d.Aggregate(String.Empty, (current, d1) => current + $"\n{d1.Key}:\t{d1.Value}");
srv.SendMsg(diff);
}
private void CheckList()
{
if (data.MyPage.MyServerSheetId == null)
{
RigEx.WriteLineColors($"ERROR: not found Sheet Id for this PC will write on Default page".AddTimeStamp(), ConsoleColor.Red);
data.MyPage.MyServerSheetId = new ServerInfo();
}
}
public async void Execute(JsonData jd)
{
RigEx.WriteLineColors("Command send screen".AddTimeStamp(), ConsoleColor.Yellow);
srv.Ctrl.CreateScreenShot();
foreach (var user in srv.Ctrl.TelegramUser)
{
await Bot.Client?.SendPhotoAsync(user.Id, System.IO.File.OpenRead(MainClass.ScreenPath));
}
}
private void AddNewAlarmSensor(ISensorProperty s)
{
RigEx.WriteLineColors($"sensor detected: {s.Name} => {s.Dictionary.Keys.Last().ToString()}".AddTimeStamp(), ConsoleColor.DarkGray);
var alarmsensor = new AlarmSensor(s, ctrl);
alarmsensor.AlarmAction += OnAlarmAction;
alarmsensor.StopMiningAction += OnStopMiningAction;
ctrl.GetAlarmdata.AddifNew(alarmsensor);
}
public override void Execute(IList <object> line)
{
if (line == null || line.Count < 2)
{
RigEx.WriteLineColors("CoinName parametr error ".AddTimeStamp(), ConsoleColor.DarkRed);
return;
}
gSheet.Data.UserToKen.Add(GetUserTokenFromLine(line));
}
public bool VersionIsLiquid(int curVersion, int newversion)
{
if (newversion > curVersion)
{
RigEx.WriteLineColors($"start Update Version curent: {curVersion} to last version: {newversion}", ConsoleColor.Green);
RunLauncher();
return(false);
}
return(true);
}
public Miner(IMiningCtrl minerCtrl)
{
ctrl = minerCtrl;
var minerName = RigEx.Read(RigEx.Lastminer);
RigEx.WriteLineColors($"Last miner is: {minerName}".AddTimeStamp(), ConsoleColor.DarkCyan);
ChangeAndRunMinerAction(minerName);
ctrl.ButtonChangeAndRunMinerAction += ChangeAndRunMinerAction;
ctrl.MinerActivityAction += OnMinerActivityAction;
}
private IList <IList <object> > GetComandLineFrom(string sheetId)
{
var comandline = GetRange($"{sheetId}!A2:F2");
if (comandline == null)
{
RigEx.WriteLineColors($"cannot read ComandLine A2:Z2 from{sheetId}", ConsoleColor.DarkRed);
}
return(comandline);
}
private static string GetSpreadsheetId()
{
string path = Path.GetFullPath(Path.Combine(Path.Combine(System.Reflection.Assembly.GetEntryAssembly().Location, @"..\..\"), "sheetId.txt"));
if (!File.Exists(path))
{
RigEx.WriteLineColors($"Cannot faund file {path} ", ConsoleColor.Red);
return(String.Empty);
}
return(File.ReadAllText(path));
}
public async void ChangeAndRunMinerAction(IEventArgs minerName)
{
if (minerName != null && !string.IsNullOrEmpty(minerName.Value))
{
await ChangeAndRunMinerAction(minerName.Value);
}
else
{
RigEx.WriteLineColors("miner ChangeMiner => miner is null ", ConsoleColor.DarkRed);
}
}
private void OnStopMiningAction(IAlarmSensor sensor)
{
if (ctrl.MinerStatus && sensor.AlarmType == AlarmType.High)
{
RigEx.WriteLineColors($"Stop miner {sensor.Sensor.Name}=> {sensor.SensorType} :{sensor.Sensor.Dictionary[sensor.SensorType]} - {sensor.AlarmType}".AddTimeStamp(), ConsoleColor.Magenta);
ctrl.SetMinigActivityStatus(false);
}
else if (!ctrl.MinerStatus && sensor.AlarmType == AlarmType.Low)
{
RigEx.WriteLineColors($"Start miner {sensor.Sensor.Name}=> {sensor.SensorType} :{sensor.Sensor.Dictionary[sensor.SensorType]} - {sensor.AlarmType}".AddTimeStamp(), ConsoleColor.Magenta);
ctrl.SetMinigActivityStatus(true);
}
}
public override void Execute(IList <object> line)
{
if (line == null || line.Count < 3)
{
RigEx.WriteLineColors("Bot Id parametr error ".AddTimeStamp(), ConsoleColor.DarkRed);
return;
}
if (line[1].ToString().ToLower() != TeleSettings.MyName)
{
return;
}
gSheet.Data.BotId = line[2].ToString();
}
public async void SendMsg(string msg)
{
try
{
foreach (var token in Ctrl.TelegramUser)
{
await Bot.Client?.SendTextMessageAsync(token.Id, $"{msg}");
}
}
catch (Exception e)
{
RigEx.WriteLineColors($"Telegram Send:{msg}\nError: {e.Message}".AddTimeStamp(), ConsoleColor.DarkRed);
}
}
private void LaunchCommandLine(IEventArgs minerName = null)
{
if (ctrl?.CurMiner == null)
{
RigEx.WriteLineColors("LaunchMiner : current miner is null".AddTimeStamp(), ConsoleColor.Red);
return;
}
startInfo.CreateNoWindow = true;
startInfo.UseShellExecute = true;
startInfo.FileName = ctrl.CurMiner.Path;
startInfo.WindowStyle = ProcessWindowStyle.Normal;
LaunchMiner();
}
public JsonData(string jsonValue)
{
string[] data = jsonValue.Split(':');
if (data == null || data.Length < 1)
{
RigEx.WriteLineColors($"Cannot convert value {jsonValue}".AddTimeStamp(), ConsoleColor.Red);
return;
}
if (!Enum.TryParse(data[0], out type))
{
RigEx.WriteLineColors($"Cannot convert callback {data[0]}", ConsoleColor.Red);
return;
}
Value = data.Length > 1 ? data[1] : String.Empty;
}
private void OnAlarmAction(IAlarmSensor sensor)
{
var alarm = $"{Icons.ring} Alarm {sensor.SensorType.Icon()}: {sensor.Sensor.Dictionary[sensor.SensorType]} - {sensor.AlarmType.Icon()}";
try
{
foreach (IToken token in Ctrl.TelegramUser)
{
Bot.Client?.SendTextMessageAsync(token.Id, alarm, replyMarkup: GetAlarmInlinekeyBoard(sensor.SensorType));
}
}
catch (Exception e)
{
RigEx.WriteLineColors($"Telegram Error: {e.Message}".AddTimeStamp(), ConsoleColor.DarkRed);
}
}
private void OnMinerActivityAction()
{
if (ctrl.MinerStatus != IsActive)
{
if (ctrl.MinerStatus)
{
RigEx.WriteLineColors("Launch miner ".AddTimeStamp(), ConsoleColor.DarkCyan);
LaunchCommandLine();
}
else
{
RigEx.WriteLineColors("Stop miner ".AddTimeStamp(), ConsoleColor.DarkCyan);
Destroy();
}
}
}
public void Execute()
{
RigEx.WriteLineColors($"Command {Name}".AddTimeStamp(), ConsoleColor.Cyan);
try
{
foreach (IToken token in srv.Ctrl.TelegramUser)
{
Bot.Client?.SendTextMessageAsync(token.Id, srv?.CurMiner?.Name, replyMarkup: srv.GetMinersInlinekeyBoard());
}
}
catch (Exception e)
{
RigEx.WriteLineColors($"Telegram Send message Error: {e.Message}".AddTimeStamp(), ConsoleColor.DarkRed);
throw;
}
}
public override void Execute(IList <object> line)
{
if (line == null || line.Count < 2)
{
RigEx.WriteLineColors("CoinName parametr error ".AddTimeStamp(), ConsoleColor.DarkRed);
return;
}
int hashRate;
int.TryParse(line[2].ToString(), out hashRate);
hashRate = hashRate == 0 ? 1 : hashRate;
string coinName = line[1].ToString();
var coin = new Coin(coinName, hashRate);
gSheet.Data.CoinsList.AddOrReplase(coin);
}
public override void Execute(IList <object> line)
{
if (line.Count < 2)
{
gSheet.Data.PingDelayMillisec = 240000; // 4 min
return;
}
int minutes = 4;
if (!int.TryParse(line[1]?.ToString(), out minutes))
{
RigEx.WriteLineColors("ping alarm: can not parse to int from B colum ", ConsoleColor.Red);
}
minutes = minutes == 0 ? 4 : minutes;
gSheet.Data.PingDelayMillisec = minutes * 60000;
}
public async Task Destroy()
{
if (minerThread != null)
{
try
{
minerThread.Abort(startInfo);
minerThread.DisableComObjectEagerCleanup();
minerThread = null;
}
catch (Exception e)
{
RigEx.WriteLineColors($"Destroy miner Thread: cannot Abort Thread {e.Message}".AddTimeStamp(),
ConsoleColor.DarkRed);
}
}
if (minerProcess != null)
{
try
{
minerProcess.Kill();
minerThread = null;
}
catch (Exception e)
{
RigEx.WriteLineColors($"Destroy miner Process: cannot kill process {e.Message}".AddTimeStamp(),
ConsoleColor.DarkRed);
}
var processes = Process.GetProcesses().ToList();
var cc = processes.Where(i => i.ProcessName.StartsWith("ccminer") ||
i.ProcessName.StartsWith("excavator") ||
i.ProcessName.StartsWith("ethminer") ||
i.ProcessName.StartsWith("nheqminer") ||
i.ProcessName.StartsWith("sgminer") ||
i.ProcessName.StartsWith("xmrig") ||
i.ProcessName.StartsWith("xmr-stak-cpu")).ToList();
if (cc != null)
{
for (int i = 0; i < cc.Count(); i++)
{
RigEx.WriteLineColors($"miner: {cc[i].ProcessName}", ConsoleColor.Cyan);
cc[i].Kill();
}
}
}
}
protected void SendRequests()
{
var busr = new BatchUpdateSpreadsheetRequest {
Requests = request
};
try
{
var t = page.Service.Spreadsheets.BatchUpdate(busr, page.SpreadsheetId);
//t.Execute();
t.ExecuteAsStream();
}
catch (Exception e)
{
RigEx.WriteLineColors($"Exeption to send request{e.Message}".AddTimeStamp(), ConsoleColor.Red);
}
}