public void Dispose()
{
if (SecondaryPool != null)
{
SecondaryPool.Dispose();
}
}
protected override View GetContainerView(int position, View convertView, ViewGroup parent)
{
var item = GetItemAt(position);
var itemContainer = convertView as ContentControl;
if (itemContainer == null)
{
itemContainer = GenerateContainer(item);
}
// unwraps the actual value from the wrapper (used to identify the type of item)
// needs to be done after the GenerateContainer step, as it relies on the presence of this wrapper
var section = item as ItemWrapperBase;
if (section != null)
{
item = section.Content;
}
var selectorItem = itemContainer as SelectorItem;
if (selectorItem != null)
{
selectorItem.IsSelected = _selectedItems.Contains(item);
}
itemContainer.DataContext = item;
FrameworkElement.RegisterPhaseBinding(itemContainer, a => SecondaryPool.RegisterForRecycled(itemContainer, a));
return(itemContainer);
}
/// <summary>
/// Sets the selected state for the provided item.
/// </summary>
/// <param name="item">The item to alter selection</param>
/// <param name="view">An optional view associated with the item being selected</param>
/// <param name="selected">The new selection state</param>
public void SetItemSelection(object item, SelectorItem view, bool selected)
{
if (selected)
{
_selectedItems.Add(item);
}
else
{
_selectedItems.Remove(item);
}
if (view == null)
{
// A single item may be mapped multiple times because of the recycling, and
// we may not be able to know which one is actually displayed.
SecondaryPool?.GetAllViews()
.OfType <ItemContainerHolder>()
.Select(i => i.Child as SelectorItem)
.Trim()
.Where(p => p.DataContext.SafeEquals(item))
.ForEach(s => s.IsSelected = selected);
}
else
{
view.IsSelected = selected;
}
}
public MiningParameters GetMiningParameters()
{
Program.Print("[INFO] Checking latest parameters from pool...");
var getPoolEthAddress = GetPoolParameter("getPoolEthAddress");
var getPoolChallengeNumber = GetPoolParameter("getChallengeNumber");
var getPoolMinimumShareDifficulty = GetPoolParameter("getMinimumShareDifficulty", s_MinerAddress);
var getPoolMinimumShareTarget = GetPoolParameter("getMinimumShareTarget", s_MinerAddress);
bool success = true;
try
{
m_cacheParameters = MiningParameters.GetPoolMiningParameters(s_PoolURL, getPoolEthAddress, getPoolChallengeNumber,
getPoolMinimumShareDifficulty, getPoolMinimumShareTarget);
return(m_cacheParameters);
}
catch (AggregateException ex)
{
success = false;
m_retryCount++;
string errorMsg = ex.Message;
foreach (var iEx in ex.InnerExceptions)
{
errorMsg += ("\n " + iEx.Message);
}
Program.Print("[ERROR] " + errorMsg);
}
catch (Exception ex)
{
success = false;
m_retryCount++;
string errorMsg = ex.Message;
if (ex.InnerException != null)
{
errorMsg += ("\n " + ex.InnerException.Message);
}
Program.Print("[ERROR] " + errorMsg);
}
if (!success && SecondaryPool != null && m_retryCount >= m_maxScanRetry)
{
m_runFailover = true;
Program.Print("[INFO] Checking mining parameters from secondary pool...");
return(SecondaryPool.GetMiningParameters());
}
return(null);
}
public bool SubmitSolution(string digest, string fromAddress, string challenge, string difficulty, string target, string solution, Miner.IMiner sender)
{
if (string.IsNullOrWhiteSpace(solution) || solution == "0x")
{
return(false);
}
m_challengeReceiveDateTime = DateTime.Now;
var startSubmitDateTime = DateTime.Now;
if (m_runFailover)
{
if (SecondaryPool.SubmitSolution(digest, fromAddress, challenge, difficulty, target, solution, sender))
{
LastSubmitLatency = (int)((DateTime.Now - startSubmitDateTime).TotalMilliseconds);
Program.Print(string.Format("[INFO] Submission roundtrip latency: {0}ms", LastSubmitLatency));
if (m_submitDateTimeList.Count >= MAX_SUBMIT_DTM_COUNT)
{
m_submitDateTimeList.RemoveAt(0);
}
m_submitDateTimeList.Add(DateTime.Now);
}
return(false);
}
difficulty = new HexBigInteger(difficulty).Value.ToString(); // change from hex to base 10 numerics
var success = false;
var submitted = false;
int retryCount = 0, maxRetries = 10;
var devFee = (ulong)Math.Round(100 / Math.Abs(DevFee.UserPercent));
do
{
try
{
var poolAddress = fromAddress;
lock (this)
{
if (SubmittedShares == ulong.MaxValue)
{
SubmittedShares = 0u;
}
var minerAddress = ((SubmittedShares) % devFee) == 0 ? DevFee.Address : MinerAddress;
JObject submitShare;
submitShare = GetPoolParameter("submitShare", solution, minerAddress, digest, difficulty, challenge,
m_customDifficulity > 0 ? "true" : "false", Miner.Work.GetKingAddressString());
var response = Utils.Json.InvokeJObjectRPC(s_PoolURL, submitShare);
LastSubmitLatency = (int)((DateTime.Now - startSubmitDateTime).TotalMilliseconds);
var result = response.SelectToken("$.result")?.Value <string>();
success = (result ?? string.Empty).Equals("true", StringComparison.OrdinalIgnoreCase);
if (!success)
{
RejectedShares++;
}
SubmittedShares++;
Program.Print(string.Format("[INFO] {0} [{1}] submitted to {2} pool: {3} ({4}ms)",
(minerAddress == DevFee.Address ? "Dev. fee share" : "Miner share"),
SubmittedShares,
IsSecondaryPool ? "secondary" : "primary",
(success ? "success" : "failed"),
LastSubmitLatency));
#if DEBUG
Program.Print(submitShare.ToString());
Program.Print(response.ToString());
#endif
}
submitted = true;
}
catch (Exception ex)
{
Program.Print(string.Format("[ERROR] {0}", ex.Message));
retryCount += 1;
if (retryCount < maxRetries)
{
Task.Delay(500);
}
}
} while (!submitted && retryCount < maxRetries);
if (success)
{
if (m_submitDateTimeList.Count > MAX_SUBMIT_DTM_COUNT)
{
m_submitDateTimeList.RemoveAt(0);
}
m_submitDateTimeList.Add(DateTime.Now);
}
else
{
UpdateMiningParameters();
}
return(success);
}
public MiningParameters GetMiningParameters()
{
Program.Print(string.Format("[INFO] Checking latest parameters from {0} pool...", IsSecondaryPool ? "secondary" : "primary"));
var getPoolEthAddress = GetPoolParameter("getPoolEthAddress");
var getPoolChallengeNumber = GetPoolParameter("getChallengeNumber");
var getPoolMinimumShareDifficulty = GetPoolParameter("getMinimumShareDifficulty", MinerAddress);
var getPoolMinimumShareTarget = GetPoolParameter("getMinimumShareTarget", MinerAddress);
bool success = true;
var startTime = DateTime.Now;
try
{
return(MiningParameters.GetPoolMiningParameters(s_PoolURL, getPoolEthAddress, getPoolChallengeNumber,
getPoolMinimumShareDifficulty, getPoolMinimumShareTarget));
}
catch (AggregateException ex)
{
success = false;
m_retryCount++;
Program.Print("[ERROR] " + ex.Message);
}
catch (Exception ex)
{
success = false;
m_retryCount++;
string errorMsg = ex.Message;
if (ex.InnerException != null)
{
errorMsg += ("\n " + ex.InnerException.Message);
}
Program.Print("[ERROR] " + errorMsg);
}
finally
{
if (success)
{
m_runFailover = false;
var tempLatency = (int)(DateTime.Now - startTime).TotalMilliseconds;
try
{
using (var ping = new Ping())
{
var poolURL = s_PoolURL.Contains("://") ? s_PoolURL.Split("://")[1] : s_PoolURL;
try
{
var response = ping.Send(poolURL);
if (response.RoundtripTime > 0)
{
tempLatency = (int)response.RoundtripTime;
}
}
catch
{
try
{
poolURL = poolURL.Split('/').First();
var response = ping.Send(poolURL);
if (response.RoundtripTime > 0)
{
tempLatency = (int)response.RoundtripTime;
}
}
catch
{
try
{
poolURL = poolURL.Split(':').First();
var response = ping.Send(poolURL);
if (response.RoundtripTime > 0)
{
tempLatency = (int)response.RoundtripTime;
}
}
catch { }
}
}
}
}
catch { }
Latency = tempLatency;
}
}
var runFailover = (!success && SecondaryPool != null && m_maxScanRetry > -1 && m_retryCount >= m_maxScanRetry);
try
{
if (runFailover)
{
return(SecondaryPool.GetMiningParameters());
}
}
finally { m_runFailover = runFailover; }
return(null);
}
private void OnPICSProductInfo(SteamApps.PICSProductInfoCallback callback, JobID jobID)
{
var request = SteamProxy.Instance.IRCRequests.Find(r => r.JobID == jobID);
if (request != null)
{
SteamProxy.Instance.IRCRequests.Remove(request);
SecondaryPool.QueueWorkItem(SteamProxy.Instance.OnProductInfo, request, callback);
return;
}
foreach (var app in callback.Apps)
{
Log.WriteInfo("Steam", "AppID: {0}", app.Key);
var workaround = app;
IWorkItemResult mostRecentItem;
ProcessedApps.TryGetValue(workaround.Key, out mostRecentItem);
var workerItem = ProcessorPool.QueueWorkItem(delegate
{
if (mostRecentItem != null && !mostRecentItem.IsCompleted)
{
Log.WriteDebug("Steam", "Waiting for app {0} to finish processing", workaround.Key);
SmartThreadPool.WaitAll(new IWaitableResult[] { mostRecentItem });
}
new AppProcessor(workaround.Key).Process(workaround.Value);
});
ProcessedApps.AddOrUpdate(app.Key, workerItem, (key, oldValue) => workerItem);
}
foreach (var package in callback.Packages)
{
Log.WriteInfo("Steam", "SubID: {0}", package.Key);
var workaround = package;
IWorkItemResult mostRecentItem;
ProcessedSubs.TryGetValue(workaround.Key, out mostRecentItem);
var workerItem = ProcessorPool.QueueWorkItem(delegate
{
if (mostRecentItem != null && !mostRecentItem.IsCompleted)
{
Log.WriteDebug("Steam", "Waiting for package {0} to finish processing", workaround.Key);
SmartThreadPool.WaitAll(new IWaitableResult[] { mostRecentItem });
}
new SubProcessor(workaround.Key).Process(workaround.Value);
});
ProcessedSubs.AddOrUpdate(package.Key, workerItem, (key, oldValue) => workerItem);
}
foreach (uint app in callback.UnknownApps)
{
Log.WriteInfo("Steam", "Unknown AppID: {0}", app);
uint workaround = app;
IWorkItemResult mostRecentItem;
ProcessedApps.TryGetValue(workaround, out mostRecentItem);
var workerItem = ProcessorPool.QueueWorkItem(delegate
{
if (mostRecentItem != null && !mostRecentItem.IsCompleted)
{
Log.WriteDebug("Steam", "Waiting for app {0} to finish processing (unknown)", workaround);
SmartThreadPool.WaitAll(new IWaitableResult[] { mostRecentItem });
}
new AppProcessor(workaround).ProcessUnknown();
});
ProcessedApps.AddOrUpdate(app, workerItem, (key, oldValue) => workerItem);
}
foreach (uint package in callback.UnknownPackages)
{
Log.WriteInfo("Steam", "Unknown SubID: {0}", package);
uint workaround = package;
IWorkItemResult mostRecentItem;
ProcessedSubs.TryGetValue(workaround, out mostRecentItem);
var workerItem = ProcessorPool.QueueWorkItem(delegate
{
if (mostRecentItem != null && !mostRecentItem.IsCompleted)
{
Log.WriteDebug("Steam", "Waiting for package {0} to finish processing (unknown)", workaround);
SmartThreadPool.WaitAll(new IWaitableResult[] { mostRecentItem });
}
new SubProcessor(workaround).ProcessUnknown();
});
ProcessedSubs.AddOrUpdate(package, workerItem, (key, oldValue) => workerItem);
}
}
private void OnPICSChanges(SteamApps.PICSChangesCallback callback, JobID job)
{
if (PreviousChange == callback.CurrentChangeNumber)
{
return;
}
if (ProcessorPool.IsIdle)
{
Log.WriteDebug("Steam", "Cleaning processed apps and subs");
ProcessedApps.Clear();
ProcessedSubs.Clear();
}
var packageChangesCount = callback.PackageChanges.Count;
var appChangesCount = callback.AppChanges.Count;
Log.WriteInfo("Steam", "Changelist {0} -> {1} ({2} apps, {3} packages)", PreviousChange, callback.CurrentChangeNumber, appChangesCount, packageChangesCount);
PreviousChange = callback.CurrentChangeNumber;
DbWorker.ExecuteNonQuery("INSERT INTO `Changelists` (`ChangeID`) VALUES (@ChangeID) ON DUPLICATE KEY UPDATE `Date` = CURRENT_TIMESTAMP()", new MySqlParameter("@ChangeID", callback.CurrentChangeNumber));
if (appChangesCount == 0 && packageChangesCount == 0)
{
IRC.SendAnnounce("{0}»{1} Changelist {2}{3}{4} (empty)", Colors.RED, Colors.NORMAL, Colors.OLIVE, PreviousChange, Colors.DARK_GRAY);
return;
}
SecondaryPool.QueueWorkItem(SteamProxy.Instance.OnPICSChanges, callback);
// Packages have no tokens so we request info for them right away
if (packageChangesCount > 0)
{
Apps.PICSGetProductInfo(Enumerable.Empty <SteamApps.PICSRequest>(), callback.PackageChanges.Keys.Select(package => NewPICSRequest(package)));
}
if (appChangesCount > 0)
{
// Get all app tokens
Apps.PICSGetAccessTokens(callback.AppChanges.Keys, Enumerable.Empty <uint>());
SecondaryPool.QueueWorkItem(delegate
{
string changes = string.Empty;
foreach (var app in callback.AppChanges.Values)
{
if (callback.CurrentChangeNumber != app.ChangeNumber)
{
DbWorker.ExecuteNonQuery("INSERT INTO `Changelists` (`ChangeID`) VALUES (@ChangeID) ON DUPLICATE KEY UPDATE `Date` = `Date`", new MySqlParameter("@ChangeID", app.ChangeNumber));
}
DbWorker.ExecuteNonQuery("UPDATE `Apps` SET `LastUpdated` = CURRENT_TIMESTAMP() WHERE `AppID` = @AppID", new MySqlParameter("@AppID", app.ID));
changes += string.Format("({0}, {1}),", app.ChangeNumber, app.ID);
}
if (!changes.Equals(string.Empty))
{
changes = string.Format("INSERT INTO `ChangelistsApps` (`ChangeID`, `AppID`) VALUES {0} ON DUPLICATE KEY UPDATE `AppID` = `AppID`", changes.Remove(changes.Length - 1));
DbWorker.ExecuteNonQuery(changes);
}
});
}
if (packageChangesCount > 0)
{
SecondaryPool.QueueWorkItem(delegate
{
string changes = string.Empty;
foreach (var package in callback.PackageChanges.Values)
{
if (callback.CurrentChangeNumber != package.ChangeNumber)
{
DbWorker.ExecuteNonQuery("INSERT INTO `Changelists` (`ChangeID`) VALUES (@ChangeID) ON DUPLICATE KEY UPDATE `Date` = `Date`", new MySqlParameter("@ChangeID", package.ChangeNumber));
}
DbWorker.ExecuteNonQuery("UPDATE `Subs` SET `LastUpdated` = CURRENT_TIMESTAMP() WHERE `SubID` = @SubID", new MySqlParameter("@SubID", package.ID));
changes += string.Format("({0}, {1}),", package.ChangeNumber, package.ID);
}
if (!changes.Equals(string.Empty))
{
changes = string.Format("INSERT INTO `ChangelistsSubs` (`ChangeID`, `SubID`) VALUES {0} ON DUPLICATE KEY UPDATE `SubID` = `SubID`", changes.Remove(changes.Length - 1));
DbWorker.ExecuteNonQuery(changes);
}
});
}
}
