public ContentRepairSuggestion AlternateFix(string name, Func <IProgress <AsyncProgressEntry>, CancellationToken, Task <bool> > fix, bool affectsData = true,
bool showProgressDialog = true)
{
Fixes.Add(new ContentRepairSuggestionFix(this, name, fix)
{
AffectsData = affectsData,
ShowProgressDialog = showProgressDialog
});
return(this);
}
private NoxMemoryHack()
{
threads.Add(new Thread(new ThreadStart(RefreshThreadStart)));
foreach (Thread thread in threads)
{
thread.Start();
}
//TODO: make this optional
Fixes.ApplyFixes();
}
/// <summary>
/// Show the tooltip with the TrayIcon
/// </summary>
public void SetIconText()
{
var tooltipInfo = _tooltipInfoFactory.Get(CurrentTooltipInfo);
var text = tooltipInfo.TextToDisplay();
if (text == null)
{
return;
}
Fixes.SetNotifyIconText(_icon, $"{Application.ProductName}\n{text}");
}
/*
* Used for the breakable objects on the table - boosts is
* in the format [hygeine, sanity, energy, foodness].
*
* isGlobal corresponds to these, and is whether the boost is applied to
* the single player, or to all players.
*/
public Task(string label, int length, List <int> boosts, List <bool> boostsGlobal, Fixes fixes)
{
this.label = label;
this.length = length;
this.progress = 0;
this.boosts = boosts;
this.boostsGlobal = boostsGlobal;
this.isMilestone = false;
this.nextTasks = null;
this.special = true;
this.fixes = fixes;
}
public Player(int id)
{
this.id = id;
this.hygeine = 1000000;
this.sanity = 1000000;
this.energy = 1000000;
this.foodness = 1000000;
this.current = null;
this.boosts = null;
this.boostsGlobal = null;
this.justCompleted = null;
this.fixes = Fixes.None;
}
/// <summary>
/// Show the tooltip with the TrayIcon
/// </summary>
public void ShowTooltipInfo()
{
if (IsBallontipVisible)
{
return;
}
var tooltipInfo = _tooltipInfoFactory.Get(CurrentTooltipInfo);
var text = tooltipInfo.TextToDisplay();
if (text == null)
{
return;
}
Fixes.SetNotifyIconText(_icon, $"{Application.ProductName}\n{text}");
//_icon.ShowBalloonTip(1000, $"{Application.ProductName}: {TooltipInfo.titleTooltip}", text, ToolTipIcon.Info)
}
/// <inheritdoc/>
protected override Action <ITextControl> ExecutePsiTransaction(ISolution solution, IProgressIndicator progress)
{
return(textControl =>
{
using (solution.GetComponent <DocumentTransactionManager>()
.CreateTransactionCookie(DefaultAction.Commit, "action name"))
{
var services = solution.GetPsiServices();
services.Transactions.Execute(
"Code cleanup",
() => services.Locks.ExecuteWithWriteLock(() =>
{
ICSharpTypeAndNamespaceHolderDeclaration holder = _highlighting.TypeAndNamespaceHolder;
Fixes.FixOrder(holder, _highlighting.Config);
Fixes.FixSpacing(holder, _highlighting.Config);
}));
}
});
}
public void TestAutoWeight()
{
// We take as dataset the two-dimensional projection of iris so
// that it is not separable and remove half of predictors from
// class 1.
// We add one to the targets as a non-regression test: class_weight="auto"
// used to work only when the labels where a range [0..K).
var x = iris.Data.SubMatrix(0, iris.Data.RowCount, 0, 2);
var y = iris.Target.Select(v => v + 1).ToArray();
var indToDelete = y.Indices(v => v > 2).Where((v, i) => i % 2 == 0).ToList();
var unbalancedIndices = Enumerable.Range(0, y.Length).Where(v => !indToDelete.Contains(v)).ToList();
int[] yInd;
int[] classes = Fixes.Unique(y.ElementsAt(unbalancedIndices), out yInd);
var classWeights = ClassWeightEstimator <int> .Auto.ComputeWeights(classes, yInd);
Assert.AreEqual(2, classWeights.MaximumIndex());
foreach (var clf in new IClassifier <int>[]
{
new Svc <int>(kernel: Kernel.Linear, classWeightEstimator:ClassWeightEstimator <int> .Auto),
//svm.LinearSVC(random_state=0),
new LogisticRegression <int>(classWeightEstimator : ClassWeightEstimator <int> .Auto)
})
{
// check that score is better when class='auto' is set.
clf.Fit(x.RowsAt(unbalancedIndices), y.ElementsAt(unbalancedIndices));
var y_pred = clf.Predict(x);
clf.Fit(x.RowsAt(unbalancedIndices), y.ElementsAt(unbalancedIndices));
var yPredBalanced = clf.Predict(x);
var a = Learn.Metrics.Metrics.F1Score(y, y_pred);
var b = Learn.Metrics.Metrics.F1Score(y, yPredBalanced);
Assert.IsTrue(a.Zip(b, Tuple.Create).All(t => t.Item1 <= t.Item2));
}
}
public SarifErrorListItem(Run run, Result result, string logFilePath, ProjectNameCache projectNameCache) : this()
{
IRule rule;
run.TryGetRule(result.RuleId, result.RuleKey, out rule);
Message = result.GetMessageText(rule, concise: false);
ShortMessage = result.GetMessageText(rule, concise: true);
FileName = result.GetPrimaryTargetFile();
ProjectName = projectNameCache.GetName(FileName);
Category = result.GetCategory();
Region = result.GetPrimaryTargetRegion();
Level = result.Level;
SuppressionStates = result.SuppressionStates;
LogFilePath = logFilePath;
if (Region != null)
{
LineNumber = Region.StartLine;
ColumnNumber = Region.StartColumn;
}
Tool = run.Tool.ToToolModel();
Rule = rule.ToRuleModel(result.RuleId);
Invocation = run.Invocation.ToInvocationModel();
if (string.IsNullOrWhiteSpace(run.Id))
{
WorkingDirectory = Path.Combine(Path.GetTempPath(), run.GetHashCode().ToString());
}
else
{
WorkingDirectory = Path.Combine(Path.GetTempPath(), run.Id);
}
if (result.Locations != null)
{
foreach (Location location in result.Locations)
{
Locations.Add(location.ToAnnotatedCodeLocationModel());
}
}
if (result.RelatedLocations != null)
{
foreach (AnnotatedCodeLocation annotatedCodeLocation in result.RelatedLocations)
{
RelatedLocations.Add(annotatedCodeLocation.ToAnnotatedCodeLocationModel());
}
}
if (result.CodeFlows != null)
{
foreach (CodeFlow codeFlow in result.CodeFlows)
{
CallTrees.Add(codeFlow.ToCallTree());
}
CallTrees.Verbosity = 100;
CallTrees.IntelligentExpand();
}
if (result.Stacks != null)
{
foreach (Stack stack in result.Stacks)
{
Stacks.Add(stack.ToStackCollection());
}
}
if (result.Fixes != null)
{
foreach (Fix fix in result.Fixes)
{
Fixes.Add(fix.ToFixModel());
}
}
}
public SarifErrorListItem(Run run, Result result, string logFilePath, ProjectNameCache projectNameCache) : this()
{
if (!SarifViewerPackage.IsUnitTesting)
{
#pragma warning disable VSTHRD108 // Assert thread affinity unconditionally
ThreadHelper.ThrowIfNotOnUIThread();
#pragma warning restore VSTHRD108 // Assert thread affinity unconditionally
}
_runId = CodeAnalysisResultManager.Instance.CurrentRunId;
ReportingDescriptor rule = result.GetRule(run);
Tool = run.Tool.ToToolModel();
Rule = rule.ToRuleModel(result.RuleId);
Invocation = run.Invocations?[0]?.ToInvocationModel();
Message = result.GetMessageText(rule, concise: false).Trim();
ShortMessage = result.GetMessageText(rule, concise: true).Trim();
if (!Message.EndsWith("."))
{
ShortMessage = ShortMessage.TrimEnd('.');
}
FileName = result.GetPrimaryTargetFile(run);
ProjectName = projectNameCache.GetName(FileName);
Category = result.GetCategory();
Region = result.GetPrimaryTargetRegion();
Level = result.Level != FailureLevel.Warning ? result.Level : Rule.FailureLevel;
if (result.Suppressions?.Count > 0)
{
VSSuppressionState = VSSuppressionState.Suppressed;
}
LogFilePath = logFilePath;
if (Region != null)
{
LineNumber = Region.StartLine;
ColumnNumber = Region.StartColumn;
}
Tool = run.Tool.ToToolModel();
Rule = rule.ToRuleModel(result.RuleId);
Invocation = run.Invocations?[0]?.ToInvocationModel();
WorkingDirectory = Path.Combine(Path.GetTempPath(), _runId.ToString());
if (result.Locations?.Any() == true)
{
// Adding in reverse order will make them display in the correct order in the UI.
for (int i = result.Locations.Count - 1; i >= 0; --i)
{
Locations.Add(result.Locations[i].ToLocationModel(run));
}
}
if (result.RelatedLocations?.Any() == true)
{
for (int i = result.RelatedLocations.Count - 1; i >= 0; --i)
{
RelatedLocations.Add(result.RelatedLocations[i].ToLocationModel(run));
}
}
if (result.CodeFlows != null)
{
foreach (CodeFlow codeFlow in result.CodeFlows)
{
CallTree callTree = codeFlow.ToCallTree(run);
if (callTree != null)
{
CallTrees.Add(callTree);
}
}
CallTrees.Verbosity = 100;
CallTrees.IntelligentExpand();
}
if (result.Stacks != null)
{
foreach (Stack stack in result.Stacks)
{
Stacks.Add(stack.ToStackCollection());
}
}
if (result.Fixes != null)
{
foreach (Fix fix in result.Fixes)
{
Fixes.Add(fix.ToFixModel());
}
}
}
public bool Equals(Result other)
{
if (other == null)
{
return(false);
}
if (RuleId != other.RuleId)
{
return(false);
}
if (Kind != other.Kind)
{
return(false);
}
if (Message != other.Message)
{
return(false);
}
if (!Object.Equals(FormattedRuleMessage, other.FormattedRuleMessage))
{
return(false);
}
if (!Object.ReferenceEquals(Locations, other.Locations))
{
if (Locations == null || other.Locations == null)
{
return(false);
}
if (!Locations.SetEquals(other.Locations))
{
return(false);
}
}
if (CodeSnippet != other.CodeSnippet)
{
return(false);
}
if (ToolFingerprint != other.ToolFingerprint)
{
return(false);
}
if (!Object.ReferenceEquals(Stacks, other.Stacks))
{
if (Stacks == null || other.Stacks == null)
{
return(false);
}
if (!Stacks.SetEquals(other.Stacks))
{
return(false);
}
}
if (!Object.ReferenceEquals(CodeFlows, other.CodeFlows))
{
if (CodeFlows == null || other.CodeFlows == null)
{
return(false);
}
if (!CodeFlows.SetEquals(other.CodeFlows))
{
return(false);
}
}
if (!Object.ReferenceEquals(RelatedLocations, other.RelatedLocations))
{
if (RelatedLocations == null || other.RelatedLocations == null)
{
return(false);
}
if (!RelatedLocations.SetEquals(other.RelatedLocations))
{
return(false);
}
}
if (IsSuppressedInSource != other.IsSuppressedInSource)
{
return(false);
}
if (!Object.ReferenceEquals(Fixes, other.Fixes))
{
if (Fixes == null || other.Fixes == null)
{
return(false);
}
if (!Fixes.SetEquals(other.Fixes))
{
return(false);
}
}
if (!Object.ReferenceEquals(Properties, other.Properties))
{
if (Properties == null || other.Properties == null || Properties.Count != other.Properties.Count)
{
return(false);
}
foreach (var value_0 in Properties)
{
string value_1;
if (!other.Properties.TryGetValue(value_0.Key, out value_1))
{
return(false);
}
if (value_0.Value != value_1)
{
return(false);
}
}
}
if (!Object.ReferenceEquals(Tags, other.Tags))
{
if (Tags == null || other.Tags == null)
{
return(false);
}
if (!Tags.SetEquals(other.Tags))
{
return(false);
}
}
return(true);
}
public override string Execute(EventEntry evtlog)
{
string strAddress = evtlog.GetProcData <string>(address);
if (string.IsNullOrEmpty(strAddress))
{
Log.Info("Fail2ban[" + Name
+ "]: empty address attribute: " + address);
return(goto_error);
}
IPAddress addr = null;
try
{
addr = IPAddress.Parse(strAddress.Trim()).MapToIPv6();
}
catch (FormatException ex)
{
Log.Info("Fail2ban[" + Name
+ "]: invalid address " + address
+ "[" + strAddress + "]: " + ex.Message);
return(goto_error);
}
// get fail2ban network address for given IP and prefix
int prefix = ipv6_prefix;
if (addr.IsIPv4MappedToIPv6)
{
prefix = ipv4_prefix;
if (prefix <= 32)
{
prefix += 96;
}
}
if (prefix != 128)
{
addr = Utils.GetNetwork(addr, prefix);
}
// fix log event that came from future(?!), _we_ have correct time!
long now = DateTime.Now.Ticks;
long logtime = evtlog.Created.Ticks;
if (logtime > now)
{
// is clock skew too hight!? occasionally log warning
if (logtime > now + 300 * TimeSpan.TicksPerSecond)
{
if (clockskew + 60 * TimeSpan.TicksPerSecond < now)
{
clockskew = now;
Log.Warn("Fail2ban[" + Name + "]: logtime from future ("
+ ((logtime - now) / TimeSpan.TicksPerSecond) + " seconds) for "
+ evtlog.Input + "/" + evtlog.Input.SelectorName
+ " from " + evtlog.Machine);
}
}
logtime = now;
}
int failcnt = 0;
bool[] tresholdCheck = new bool[tresholds.Count];
lock (thisLock)
{
// update failed login fail2ban data
IFail fail;
if (!data.TryGetValue(addr, out fail))
{
switch (history)
{
case HistoryType.ALL: fail = new FailAll(findtime * TimeSpan.TicksPerSecond); break;
case HistoryType.ONE: fail = new FailOne(findtime * TimeSpan.TicksPerSecond); break;
case HistoryType.FIXED: fail = new FailFixed(findtime * TimeSpan.TicksPerSecond, history_fixed_count, history_fixed_decay); break;
case HistoryType.RRD: fail = new FailRRD(findtime * TimeSpan.TicksPerSecond, history_rrd_count, history_rrd_repeat); break;
}
data[addr] = fail;
}
failcnt = fail.Add(logtime);
for (int i = 0; i < tresholds.Count; i++)
{
tresholdCheck[i] = Check(addr, tresholds[i], failcnt);
}
}
// evaluate all defined tresholds
for (int i = 0; i < tresholds.Count; i++)
{
if (!tresholdCheck[i])
{
continue;
}
Treshold treshold = tresholds[i];
int tmpPrefix = prefix;
IPAddress tmpAddr = addr;
long expiration = now + TimeSpan.FromSeconds(treshold.Bantime).Ticks;
if (addr.IsIPv4MappedToIPv6)
{
// workaround for buggy MapToIPv4 implementation
tmpAddr = Fixes.MapToIPv4(addr);
tmpPrefix = prefix - 96;
}
Log.Info("Fail2ban[" + Name + "]: reached treshold "
+ treshold.Name + " (" + treshold.MaxRetry + "&"
+ failcnt + ") for " + tmpAddr + "/" + tmpPrefix);
if (evtlog.HasProcData("Fail2ban.All"))
{
string all = evtlog.GetProcData <string>("Fail2ban.All");
evtlog.SetProcData("Fail2ban.All", all + "," + Name);
}
else
{
evtlog.SetProcData("Fail2ban.All", Name);
}
evtlog.SetProcData("Fail2ban.Last", Name);
evtlog.SetProcData(Name + ".Address", tmpAddr);
evtlog.SetProcData(Name + ".Prefix", tmpPrefix);
evtlog.SetProcData(Name + ".FailCnt", failcnt);
evtlog.SetProcData(Name + ".Bantime", treshold.Bantime);
evtlog.SetProcData(Name + ".Expiration", expiration);
evtlog.SetProcData(Name + ".Treshold", treshold.Name);
// Add to "action" queue
Produce(new EventEntry(evtlog), treshold.Action, EventQueue.Priority.High);
}
return(goto_next);
}
public void Update(int tickSize)
{
this.sanity -= tickSize;
this.hygeine -= tickSize * 4;
this.energy -= tickSize * 8;
this.foodness -= tickSize * 16;
if (hygeine < 0)
{
hygeine = 0;
}
if (energy < 0)
{
energy = 0;
}
if (foodness < 0)
{
foodness = 0;
}
if (sanity < 0)
{
sanity = 0;
}
if (hygeine > 1000000)
{
hygeine = 1000000;
}
if (energy > 1000000)
{
energy = 1000000;
}
if (foodness > 1000000)
{
foodness = 1000000;
}
if (sanity > 1000000)
{
sanity = 1000000;
}
if (this.current == null)
{
return;
}
// Player works slower based on their values.
this.current.Update((int)(tickSize * PerformanceMultiplier()));
if (!this.current.IsComplete())
{
return;
}
if (this.current.special)
{
this.boosts = this.current.boosts;
this.boostsGlobal = this.current.boostsGlobal;
this.fixes = this.current.fixes;
}
this.justCompleted = current;
this.current = null;
// TODO: should we notify the players with some SFX or something?
}
/// <summary>
/// Fixes the order and spacing for the using blocks in a file or namespace declaration block.
/// </summary>
/// <param name="holder">The file or namespace declaration blocks to check.</param>
/// <param name="configuration">The configuration defining the correct order
/// and spacing.</param>
private void CleanUsings(
ICSharpTypeAndNamespaceHolderDeclaration holder, OrderUsingsConfiguration configuration)
{
Fixes.FixOrder(holder, configuration);
Fixes.FixSpacing(holder, configuration);
}
