public void FireStatusEvent(Transform target, StatusMessage message, float value)
{
if (StatusEventHandler != null)
{
StatusEventHandler(Source, target, message, value);
}
}
private void HandleStatusEvent(Transform originator, Transform target, StatusMessage message, float value)
{
if (message == StatusMessage.CharacterSelected)
{
_objectWasSelected = true;
}
}
void AccountStatus_Delete(object sender, EventArgs e)
{
AuthoriseRequestSid();
long messageId = core.Functions.FormLong("id", 0);
if (messageId > 0)
{
StatusMessage message = new StatusMessage(core, messageId);
if (message.Owner.Id == Owner.Id)
{
ItemKey messageKey = message.ItemKey;
long count = message.Delete();
DeleteQuery dQuery = new DeleteQuery(typeof(BoxSocial.Internals.Action));
dQuery.AddCondition("action_primitive_id", Owner.Id);
dQuery.AddCondition("action_primitive_type_id", Owner.TypeId);
dQuery.AddCondition("action_item_id", messageKey.Id);
dQuery.AddCondition("action_item_type_id", messageKey.TypeId);
core.Db.Query(dQuery);
core.Response.SendStatus("messageDeleted");
return;
}
}
// IsAjax true
core.Response.ShowMessage("permissionDenied", "Permission Denied", "You cannot delete this item.");
}
private void HandleStatusEvent(Transform originator, Transform target, StatusMessage message, float value)
{
switch (message)
{
case StatusMessage.CharacterActivated: _renderer.enabled = (_parentTransform == target); break;
case StatusMessage.CharacterDeactivated: _renderer.enabled = false; break;
}
}
private void HandleStatusEvent(Transform originator, Transform target, StatusMessage message, float value)
{
switch (message)
{
case StatusMessage.ReduceHealth: UpdateThreatFromAttacker(target, originator, value); break;
case StatusMessage.IncreaseHealth: UpdateThreatFromHealer(originator, value); break;
}
}
private void HandleStatusEvent(Transform originator, Transform target, StatusMessage message, float value)
{
switch (message)
{
case StatusMessage.NpcActionTargetRequested: AttemptTargetAssignment(originator); break;
case StatusMessage.CharacterDead: RemovePotentialTarget(originator); break;
}
}
public static void Test_Null_Reciever()
{
//arrange
Mock<StatusChangePayload> payload = new Mock<StatusChangePayload>(MockBehavior.Strict);
StatusMessage message = new StatusMessage(payload.Object);
//assert
Assert.Throws<ArgumentNullException>(() => message.Dispatch(null, null)); //expect an exception
}
public static void Test_Construction([EnumRange(typeof(NetStatus))] NetStatus status)
{
//arrange
StatusChangePayload payload = new StatusChangePayload(status);
//act
StatusMessage message = new StatusMessage(payload);
//assert
Assert.AreEqual((message.Payload.Data as StatusChangePayload).Status, status);
}
/**
* Prefered constructor for a Connection
*/
public Connection(Edge e, Address a,
string connectiontype,
StatusMessage sm, LinkMessage peerlm)
{
_e = e;
_a = a;
_ct = String.Intern(connectiontype);
_stat = sm;
_lm = peerlm;
_creation_time = DateTime.UtcNow;
MainType = StringToMainType(_ct);
}
public static void Test_Dispatch()
{
//arrange
Mock<StatusChangePayload> payload = new Mock<StatusChangePayload>(MockBehavior.Strict);
Mock<INetworkMessageReceiver> reciever = new Mock<INetworkMessageReceiver>();
//act
StatusMessage message = new StatusMessage(payload.Object);
message.Dispatch(reciever.Object, null);
//assert
//We check that the proper method was called.
reciever.Verify(x => x.OnNetworkMessageReceive(message, null), Times.Once());
}
/**
* Prefered constructor for a Connection
*/
public Connection(Edge e, Address a,
string connectiontype,
StatusMessage sm, LinkMessage peerlm)
{
_e = e;
_a = a;
_ct = String.Intern(connectiontype);
_stat = sm;
_lm = peerlm;
_creation_time = DateTime.UtcNow;
MainType = StringToMainType(_ct);
_as_dict = new WriteOnce<ListDictionary>();
_sub_type = new WriteOnce<string>();
}
public StatusMessageViewModel(StatusMessage statusMessage)
{
this.Model = statusMessage;
this.ProfileImage = ReactiveProperty.FromObject(
statusMessage.Status.User,
x => x.ProfileImageUrlHttps);
this.ScreenName = ReactiveProperty.FromObject(
statusMessage.Status.User,
x => x.ScreenName);
this.Text = ReactiveProperty.FromObject(
statusMessage.Status,
x => x.Text);
}
public StatusMessage TestDeleteLocationType(string LookupName = "Business")
{
StatusMessage StatusMsg = new StatusMessage();
StatusMsg.ObjectName = LookupName;
//TEST Delete a LocationType
var LookupItem = Repositories.LocationTypeRepo.GetByName(LookupName).FirstOrDefault();
if (LookupItem != null)
{
StatusMsg = Repositories.LocationTypeRepo.Delete(LookupItem);
}
else
{
StatusMsg.Message = string.Format("'{0}' was not found and can not be deleted.", LookupName);
StatusMsg.Success = false;
}
return StatusMsg;
}
public StatusMessage DeleteAllLocations(bool Confirm)
{
var ResultMsg = new StatusMessage();
if (Confirm)
{
int delCounter = 0;
List<Guid> allKeys = new List<Guid>();
var allLocations = Repositories.LocationRepo.GetAll();
var totCounter = allLocations.Count();
foreach (var loc in allLocations)
{
allKeys.Add(loc.Key);
}
foreach (var key in allKeys)
{
var stat = Repositories.LocationRepo.Delete(key);
ResultMsg.InnerStatuses.Add(stat);
if (stat.Success)
{
delCounter++;
}
}
ResultMsg.Message = string.Format("{0} Location(s) deleted out of a total of {1} Location(s)", delCounter, totCounter);
ResultMsg.Success = true;
}
else
{
ResultMsg.Success = false;
ResultMsg.Code = "NotConfirmed";
ResultMsg.Message = "The operation was not confirmed, and thus did not run.";
}
return ResultMsg;
}
public async Task RetweetAsync(StatusMessage statusMessage)
{
await this.tokens.Statuses.RetweetAsync(id => statusMessage.Status.Id);
}
protected override void EnrichStatusMessage(StatusMessage statusMessage)
{
base.EnrichStatusMessage(statusMessage);
statusMessage.ForkId =
ForkInfo.CalculateForkId(_specProvider, SyncServer.Head.Number, SyncServer.Genesis.Hash);
}
protected override async Task GameOver()
{
var winners = Battle.GetTeam(Battle.GetWinner());
if (Battle.GetWinner() == Team.A)
{
if (Battle.GetWinner() == Team.A)
{
winners.OfType <PlayerFighter>().ToList().ForEach(async p => await ServerGames.UserWonBattle(UserAccountProvider.GetById(p.Id), matchup.RewardTables.GetRewards(), p.battleStats, lobbyChannel, BattleChannel));
}
Battle.TeamA.ForEach(p =>
{
p.RemoveNearlyAllConditions();
p.Buffs = new List <Buff>();
p.Heal((uint)(p.Stats.HP * 5 / 100));
});
SetNextEnemy();
if (!EndOfDungeon)
{
await SummonsMessage.ModifyAsync(m => m.Content = matchup.FlavourText);
var text = $"{winners.First().Name}'s Party wins Battle!";
await Task.Delay(2000);
await StatusMessage.ModifyAsync(m => { m.Content = text; m.Embed = null; });
await Task.Delay(2000);
Battle.turn = 0;
_ = StartBattle();
}
else
{
winners.OfType <PlayerFighter>().ToList().ForEach(async p => await ServerGames.UserWonDungeon(UserAccountProvider.GetById(p.Id), Dungeon, lobbyChannel));
if (DateTime.Now <= new DateTime(2020, 11, 8) && Global.Random.Next(4) == 0)
{
var r = new List <Rewardable>()
{
new DefaultReward()
{
Dungeon = "Halloween Special"
}
};
winners.OfType <PlayerFighter>().ToList().ForEach(async p => await ServerGames.UserWonBattle(UserAccountProvider.GetById(p.Id), r, new BattleStats(), lobbyChannel, BattleChannel));
}
_ = WriteGameOver();
}
}
else
{
var losers = winners.First().battle.GetTeam(winners.First().enemies);
losers.ConvertAll(s => (PlayerFighter)s).ForEach(async p => await ServerGames.UserLostBattle(UserAccountProvider.GetById(p.Id), lobbyChannel));
_ = WriteGameOver();
}
}
internal protected virtual void OnStatusMessage(StatusMessageEventArgs eventArgs)
{
StatusMessage?.Invoke(this, eventArgs);
}
void IChangeMessageHandler.OnErrorStatusNotification(StatusMessage message)
{
}
public abstract void OnStatus(StatusMessage mes);
private void HandleStatusEvent(Transform originator, Transform target, StatusMessage message, float value)
{
switch (message)
{
case StatusMessage.ReduceHealth: HandleCharacterHurt(target); break;
case StatusMessage.CharacterDead: HandleCharacterDeath(originator); break;
}
}
public void FillStatusMessageInfo(StatusMessage message)
{
}
public override StatusMessage StatusUpdateDestructive(StatusMessage msg, object mon)
{
return(ep.RaiseStatusDestructive(msg));
}
public override void StatusUpdate(StatusMessage msg, object mon)
{
ep.RaiseStatus(msg);
}
// this is the callback from the RM thread
private int OnStatus(StatusMessage status, int hr, IntPtr pvParam, IntPtr pvContext)
{
if (hr == S_DRM_COMPLETED || hr < 0)
{
_exception = null; // we are resetting this variable, so that the instance of this class will be reusable even after exception
try
{
_hr = hr; // we are assigning hr first as the next command can potentially throw, and we would like to have hr value preserved
if (pvParam != IntPtr.Zero)
{
_callbackData = Marshal.PtrToStringUni(pvParam);
}
}
// disabling PreSharp false positive. In this case we are actually re-throwing the same exception
// on the application thread inside WaitForCompletion() function
#pragma warning disable 56500
catch (Exception e)
{
// We catch all exceptions of the second worker thread (created by the unmanaged RM SDK)
// preserve them , and then rethrow later on the main thread from the WaitForCompletion method
_exception = e;
}
#pragma warning restore 56500
finally
{
// After this signal, OnStatus will NOT be invoked until we instigate another "transaction"
// from the user thread.
_resetEvent.Set();
}
}
return 0;
}
public override void Unpack(BinaryReader reader)
{
base.Unpack(reader);
ItemID = reader.ReadUInt32();
Reason = (StatusMessage)reader.ReadUInt32();
}
public static void Main(string[] args)
{
if (args.Length < 2)
{
System.Console.WriteLine("Usage: WrapperForFastLDATuning.exe <WorkerRole> <NumOfThreads> [MetricsType]");
System.Console.WriteLine(DetailUsage);
Environment.Exit(1);
}
if (!Enum.TryParse(args[0], true, out WorkerRole))
{
StatusMessage.Write("Unrecognized value for worker role. Exiting...");
return;
}
if (!Int32.TryParse(args[1], out NumOfThreads))
{
StatusMessage.Write("Invalid value for number of threads. Exiting...");
return;
}
if (WorkerRole == WorkerRoles.Metrics)
{
if (args.Length < 3)
{
// By default we compute both intrinsic and extrinsic metrics.
MetricsType = ModelMetricTypes.Both;
}
else if (!Enum.TryParse(args[2], true, out MetricsType))
{
StatusMessage.Write("Unrecognized value for metrics type. Exiting...");
return;
}
if (args.Length > 3)
{
RunAllMetrics = args[3].Equals("all", StringComparison.OrdinalIgnoreCase);
}
}
Initialize();
// Load default LDA config as seed
var defaultLDAConfig = LoadLDAConfig(DefaultModelConfigFile);
// Get the folders of parameter range files and training config files.
// Examples of folder structure: d:\ModelRepository\TuneLDAParameters\RangesOfParams
// d:\ModelRepository\TuneLDAParameters\LDALearningConfigFiles
string folderOfParamRangeFiles = Path.Combine(ModelRepositoryPath, ProjResourceSubFolder, RangeOfParamsSubFolder);
string folderOfTrainingConfigFiles = Path.Combine(ModelRepositoryPath, ProjResourceSubFolder, LDALearningConfigsSubFolder);
List <string> listOfLDAConfigFilesForFeaturization = new List <string>();
List <string> listOfLDAConfigFilesForTest = new List <string>();
// Generate multiple LDA configs for featurization, training and test.
List <string> listOfLDAConfigFilesForTrain;
if (NeedLoadLDAConfigFiles)
{
listOfLDAConfigFilesForTrain =
LDAConfigFileGenerator.LoadLDAConfigFiles(ModelRepositoryPath,
TrainingSampleName,
defaultLDAConfig,
SourceFolderOfLDAConfigFiles,
folderOfTrainingConfigFiles,
ref listOfLDAConfigFilesForFeaturization,
ref listOfLDAConfigFilesForTest);
}
else if (NeedLoadLDAParameterTable)
{
listOfLDAConfigFilesForTrain =
LDAConfigFileGenerator.LoadLDAParameterTable(ModelRepositoryPath,
TrainingSampleName,
defaultLDAConfig,
LDAParameterTablePath,
folderOfTrainingConfigFiles,
ref listOfLDAConfigFilesForFeaturization,
ref listOfLDAConfigFilesForTest);
}
else
{
listOfLDAConfigFilesForTrain =
LDAConfigFileGenerator.GenerateLDAConfigFiles(ModelRepositoryPath,
folderOfParamRangeFiles,
TrainingSampleName,
defaultLDAConfig,
folderOfTrainingConfigFiles,
ref listOfLDAConfigFilesForFeaturization,
ref listOfLDAConfigFilesForTest);
}
switch (WorkerRole)
{
case WorkerRoles.Training:
FeaturizeSample(listOfLDAConfigFilesForFeaturization, TrainingSampleName, NumOfThreads);
if (NeedCopyToRemote)
{
CopyVocabularies(listOfLDAConfigFilesForTest.First(), RemoteModelRepositoryPath);
// Start a thread that:
// 1). monitors model directory;
// 2). copies models to remote model repository when they are done;
// 3). deletes them once copy is successful.
Thread newThread = new Thread(Program.CopyModels);
newThread.Start(NeedDeleteFromLocal);
}
TrainLDAModels(listOfLDAConfigFilesForTrain, listOfLDAConfigFilesForTest, NumOfThreads);
if (NeedCopyToRemote)
{
WaitForCopyThread();
}
break;
case WorkerRoles.Metrics:
if (RunAllMetrics)
{
long numOfModelsMeasured = 0;
ComputeMetrics(listOfLDAConfigFilesForTest, NumOfThreads, MetricsType, ref numOfModelsMeasured);
break;
}
// Get common parent of individual model directories.
string commonParentOfModelDirectories = FileManager.GetGrandparentOfFilePath(listOfLDAConfigFilesForTest.First());
ComputeMetrics(commonParentOfModelDirectories, NumOfThreads, MetricsType);
break;
default:
return;
}
StatusMessage.Write("Done!");
}
void UpdateStatusMessage(string status)
{
StatusMessage?.Invoke(status);
}
protected override async Task GameOver()
{
var winners = Battle.GetTeam(Battle.GetWinner());
if (Battle.SizeTeamB == 0)
{
Console.WriteLine("Game Over with no enemies existing.");
}
if (Battle.GetWinner() == Team.A)
{
winsInARow++;
var RewardTables = Rewards;
var chests = chestTable[Difficulty];
chests.RemoveAll(s => s is DefaultReward d && !d.HasChest);
var lurCapBonus = new[] { 16, 12, 10, 9, 8 };
if (!Battle.TeamB.Any(f => f.Name.Contains("Mimic")))
{
chests.Add(new DefaultReward {
Weight = chests.Weight * lurCapBonus[LureCaps]
});
}
RewardTables.Add(chests);
if (Battle.TeamB.Any(f => f.Name.Contains("Djinn")))
{
var djinnTable = new RewardTable();
var djinnWeight = (int)Difficulty;
if (Battle.TeamB.Any(f => f.Name.Contains("Venus Djinn")))
{
djinnTable.Add(new DefaultReward()
{
Djinn = "Venus", Weight = 1
});
}
if (Battle.TeamB.Any(f => f.Name.Contains("Mars Djinn")))
{
djinnTable.Add(new DefaultReward()
{
Djinn = "Mars", Weight = 1
});
}
if (Battle.TeamB.Any(f => f.Name.Contains("Jupiter Djinn")))
{
djinnTable.Add(new DefaultReward()
{
Djinn = "Jupiter", Weight = 1
});
}
if (Battle.TeamB.Any(f => f.Name.Contains("Mercury Djinn")))
{
djinnTable.Add(new DefaultReward()
{
Djinn = "Mercury", Weight = 1
});
}
djinnTable.Add(new DefaultReward()
{
Weight = djinnTable.Weight * (10 - (int)Difficulty) * 2 - djinnTable.Weight
});
RewardTables.Add(djinnTable);
}
winners.OfType <PlayerFighter>().ToList().ForEach(async p => await ServerGames.UserWonBattle(p.avatar, RewardTables.GetRewards(), p.battleStats, lobbyChannel, BattleChannel));
winners.OfType <PlayerFighter>().ToList().ForEach(async p => await ServerGames.UserWonEndless(p.avatar, lobbyChannel, winsInARow, mode, p.battleStats.TotalTeamMates + 1, string.Join(", ", Battle.TeamA.Select(pl => pl.Name))));
chests.RemoveAll(s => s is DefaultReward d && !d.HasChest);
Battle.TeamA.ForEach(p =>
{
p.PPrecovery += (winsInARow <= 8 * 4 && winsInARow % 4 == 0) ? 1 : 0;
p.RemoveNearlyAllConditions();
p.Buffs = new List <Buff>();
p.Heal((uint)(p.Stats.HP * 5 / 100));
});
var text = $"{winners.First().Name}'s Party wins Battle {winsInARow}! Battle will reset shortly.";
await Task.Delay(3000);
await StatusMessage.ModifyAsync(m => { m.Content = text; m.Embed = null; });
await Task.Delay(3000);
SetNextEnemy();
Battle.turn = 0;
_ = StartBattle();
}
else
{
var losers = winners.First().battle.GetTeam(winners.First().enemies);
losers.ConvertAll(s => (PlayerFighter)s).ForEach(async p => await ServerGames.UserLostBattle(p.avatar, lobbyChannel));
winners.OfType <PlayerFighter>().ToList().ForEach(async p => await ServerGames.UserFinishedEndless(p.avatar, lobbyChannel, winsInARow, mode));
_ = WriteGameOver();
}
}
private void syncServerCtl1_StatusHandler(StatusMessage sm)
{
switch (sm.Status)
{
case status.server_client_added:
label4.Text = syncServerCtl1.ClientsCount.ToString();
notifyIcon1.Text = "Server Started, #Client: " + label4.Text;
notifyIcon1.BalloonTipText = "New Client Joined, #Client: " + label4.Text;
notifyIcon1.ShowBalloonTip(3);
break;
case status.server_client_removed:
DisconnectClient(sm.ID);
label4.Text = syncServerCtl1.ClientsCount.ToString();
notifyIcon1.Text = "Server Started, #Client: " + label4.Text;
notifyIcon1.BalloonTipText = "Client Disconnected, #Client: " + label4.Text;
notifyIcon1.ShowBalloonTip(3);
break;
case status.info:
switch (sm.CodeMessage)
{
case "server_started":
label3.Text = "Server Started";
label4.Text = "0";
pictureBox1.Image = Resources.gear_run;
notifyIcon1.Icon = Resources.gear_run1;
notifyIcon1.Text = "BxEventServer Started, #Client: 0";
notifyIcon1.BalloonTipText = "Server Started";
numericUpDown1.Enabled = false;
button1.Text = "Stop";
notifyIcon1.ShowBalloonTip(3);
DictUserListener.Clear();
//CreateWarningLetter();
timer1.Enabled = true;
break;
case "method_Stop":
label3.Text = "Server Stopped";
button1.Text = "Start";
numericUpDown1.Enabled = true;
pictureBox1.Image = Resources.gear_stop;
notifyIcon1.Icon = Resources.gear_stop1;
notifyIcon1.BalloonTipText = "Server Stopped";
notifyIcon1.ShowBalloonTip(3);
timer1.Enabled = false;
break;
}
break;
case status.error:
if (sm.CodeMessage == "method_StartServer")
{
pictureBox1.Image = Resources.gear_stop;
notifyIcon1.Icon = Resources.gear_stop1;
notifyIcon1.Text = "Server Stopped";
numericUpDown1.Enabled = true;
label3.Text = "Server Stopped";
label4.Text = "0";
button1.Text = "Start";
notifyIcon1.BalloonTipText = "Server Cannot started, Port Already Used !";
notifyIcon1.ShowBalloonTip(5);
}
break;
}
}
public int Load()
{
// Do nothing if already loaded
if (this.Vectors != null)
{
return(0);
}
if (this.RowCount > 0)
{
this.Vectors = new Tuple <string, DenseVector> [this.RowCount];
}
else
{
return(0);
}
var vectors = File.ReadLines(this.FilePath);
string[] serialializedVectors = new string[this.RowCount];
int i = 0;
foreach (var vector in vectors)
{
// Vector file format has 4 space-separated colunms: label, market, domain, vector
char colSeparator = ColSeparatorTab;
int labelDelimiterIndex = vector.IndexOf(colSeparator);
// Tabs might not be teh delimeter. Try spaces
if (labelDelimiterIndex < 0)
{
colSeparator = ColSeparatorSpace;
labelDelimiterIndex = vector.IndexOf(colSeparator);
}
string itemLabel = vector.Substring(0, labelDelimiterIndex);
// Skip over the next two spaces
int vectorStartIndex = vector.IndexOf(colSeparator, labelDelimiterIndex + 1);
vectorStartIndex = vector.IndexOf(colSeparator, vectorStartIndex + 1) + 1;
serialializedVectors[i] = vector.Substring(vectorStartIndex);
this.Vectors[i] = new Tuple <string, DenseVector>(string.IsNullOrEmpty(itemLabel) ? i.ToString() : itemLabel, new DenseVector());
i++;
if (i >= this.RowCount)
{
break;
}
}
if (this.Verbose)
{
StatusMessage.Write("Deserializing vectors from " + this.FilePath);
}
Stopwatch timer = new Stopwatch();
timer.Start();
for (i = 0; i < this.RowCount; i++)
{
this.Vectors[i].Item2.Deserialize(serialializedVectors[i]);
this.Vectors[i].Item2.L2Normalize();
serialializedVectors[i] = null; // No longer needed
}
timer.Stop();
if (this.Verbose)
{
System.Console.WriteLine("Deserialized {0} vectors. Elapsed time {1:D2}:{2:D2}:{3:F2}", this.RowCount, timer.Elapsed.Hours, timer.Elapsed.Minutes, (timer.Elapsed.TotalMilliseconds / 1000));
}
if (this.Verbose)
{
System.Console.WriteLine("Average {0:F4} milliseconds/vector.", timer.Elapsed.TotalMilliseconds / this.RowCount);
}
return(this.RowCount);
}
public static void LogStatus(StatusMessage message)
{
DispatcherHelper.CheckBeginInvokeOnUI(() => Messenger.Default.Send(message));
}
public abstract StatusMessage OnStatusDestructive(StatusMessage mes);
/// <summary>
/// Handles the <see cref="E:StatusMessage" /> event.
/// </summary>
/// <param name="args">The <see cref="StatusMessageEventArgs"/> instance containing the event data.</param>
internal void OnStatusMessage(StatusMessageEventArgs args)
{
StatusMessage?.Invoke(this, args);
}
/// <summary>
/// Handles the <see cref="E:StatusMessage" /> event.
/// </summary>
/// <param name="args">The <see cref="StatusMessageEventArgs"/> instance containing the event data.</param>
void IWebBrowserInternal.OnStatusMessage(StatusMessageEventArgs args)
{
StatusMessage?.Invoke(this, args);
}
public ErrorReport AssembleReport(StatusMessage status)
{
return(new ErrorReport {
Status = status, StatusString = _stringStatuses[status]
});
}
public bool TryParseResponse(MemoryStream ms)
{
ResponseStream = ms;
RawContent = ms.GetBuffer();
var p = UTF8Encoding.UTF8.GetString(RawContent);
string[] HeaderAndData = p.Split(new String[] { "\r\n\r\n" }, StringSplitOptions.RemoveEmptyEntries);
try
{
if (HeaderAndData.Length < 1)
{
throw new FormatException();
}
var headerFields = HeaderAndData[0].Split(new String[] { "\r\n" }, StringSplitOptions.RemoveEmptyEntries);
var MethodResourceversion = headerFields[0];
var MethodResourceversionSplitted = MethodResourceversion.Split(' ');
Version = Version.Parse(MethodResourceversionSplitted[0].ToLower().Replace("http/", ""));
StatusCode = Convert.ToInt32(MethodResourceversionSplitted[1]);
for (int i = 2; i < MethodResourceversionSplitted.Length; i++)
{
StatusMessage += MethodResourceversionSplitted[i] + " ";
}
StatusMessage = StatusMessage.Trim();
for (int i = 1; i < headerFields.Length; i++)
{
var PropertyValue = headerFields[i].Split(new String[] { ": " }, StringSplitOptions.None);
var key = PropertyValue[0].Trim();
var value = PropertyValue[1].Trim();
if (Headers.Any(v => v.Key.ToLower().Equals(key.ToLower())) && !string.IsNullOrEmpty(key) && !string.IsNullOrEmpty(value))
{
Headers[key] = value;
}
if (!Headers.ContainsKey(key))
{
HttpHandler.Log(LogLevel.Warning, "Key \"" + key + "\" is missing in header list");
}
}
if (!string.IsNullOrEmpty(Headers["Content-Type"]))
{
ContentType = Headers["Content-Type"];
}
if (!string.IsNullOrEmpty(Headers["Content-Length"]))
{
ContentLength = Convert.ToInt32(Headers["Content-Length"]);
}
if (HeaderAndData.Length >= 2)
{
HasPayload = true;
var contentLength = RawContent.Length - HeaderAndData[0].Length - 4;
Content = new byte[contentLength];
Array.Copy(RawContent, RawContent.Length - contentLength, Content, 0, contentLength);
}
return(true);
}
catch (Exception e)
{
HttpHandler.Log(LogLevel.Error, "Http request parsing error : " + e.Message);
return(false);
}
}
private void onStatus(StatusMessage statusMessage)
{
try {
using (var context = new TwitterContext()) {
var status = statusMessage.Status;
context.Upsert(new Core.Twitter.Model.Status(status));
if (status.RetweetedStatus != null && status.User?.Id != null && status.RetweetedStatus.User?.Id != null)
{
//RT
context.Upsert(new ReactiveEvent(
status.User.Id.Value,
status.RetweetedStatus.Id,
status.CreatedAt.LocalDateTime,
status.RetweetedStatus.User.Id.Value,
status.Id,
ReacteveEventType.Retweet
));
context.Upsert(new SpanTime(status.User.Id.Value, status.CreatedAt.LocalDateTime, status.CreatedAt - status.RetweetedStatus.CreatedAt));
}
else if (status.QuotedStatus != null && status.User?.Id != null && status.QuotedStatus.User?.Id != null)
{
//Quote
context.Upsert(new ReactiveEvent(
status.User.Id.Value,
status.QuotedStatus.Id,
status.CreatedAt.LocalDateTime,
status.QuotedStatus.User.Id.Value,
status.Id,
ReacteveEventType.Quote
));
context.Upsert(new SpanTime(status.User.Id.Value, status.CreatedAt.LocalDateTime, status.CreatedAt - status.QuotedStatus.CreatedAt));
}
else if (status.InReplyToStatusId != null && status.InReplyToUserId != null && status.User?.Id != null)
{
//Reply
context.Upsert(new ReactiveEvent(
status.User.Id.Value,
status.InReplyToStatusId.Value,
status.CreatedAt.LocalDateTime,
status.InReplyToUserId.Value,
status.Id,
ReacteveEventType.Reply
));
Core.Twitter.Model.Status targetStatus = null;
try {
targetStatus =
context.Statuses.FirstOrDefault(x => x.Id == status.InReplyToStatusId.Value)
??
new Core.Twitter.Model.Status(tokens.Statuses.ShowAsync(id: status.InReplyToStatusId.Value).Result);
context.Upsert(targetStatus);
} catch (Exception) { }
if (targetStatus != null)
{
context.Upsert(new SpanTime(status.User.Id.Value, status.CreatedAt.LocalDateTime, status.CreatedAt - targetStatus.CreatedAt));
}
}
if (status.User?.Id != null)
{
context.Upsert(new ActiveTime(status.User.Id.Value, status.CreatedAt.LocalDateTime));
}
context.SaveChanges();
}
} catch (Exception e) {
Console.Out.WriteLine($"onStatus : {e.Message}");
}
}
private void SerialMan_StatusMessageReceived(StatusMessage msg)
{
Console.WriteLine("Status: {0}", msg);
}
public void FireStatusEvent(Transform target, StatusMessage message)
{
FireStatusEvent(target, message, 0.0f);
}
/// <summary>
/// Simulates responding to a challenge, performs a sample configuration and attempts to
/// verify it.
/// </summary>
/// <param name="serverManager"> </param>
/// <param name="managedCertificate"> </param>
/// <returns> APIResult </returns>
/// <remarks>
/// The purpose of this method is to test the options (permissions, configuration) before
/// submitting a request to the ACME server, to avoid creating failed requests and hitting
/// usage limits.
/// </remarks>
public async Task <List <StatusMessage> > TestChallengeResponse(
ILog log,
ICertifiedServer serverManager,
ManagedCertificate managedCertificate,
bool isPreviewMode,
bool enableDnsChecks,
ICredentialsManager credentialsManager,
IProgress <RequestProgressState> progress = null
)
{
var results = new List <StatusMessage>();
var requestConfig = managedCertificate.RequestConfig;
if (string.IsNullOrEmpty(requestConfig.PrimaryDomain))
{
return(new List <StatusMessage> {
new StatusMessage {
IsOK = false, Message = "There is no primary domain set for this certificate."
}
});
}
var domains = new List <string> {
requestConfig.PrimaryDomain
};
if (requestConfig.SubjectAlternativeNames != null)
{
domains.AddRange(requestConfig.SubjectAlternativeNames);
}
domains = domains.Distinct().ToList();
// TODO: some of these checks can be moved/shared with general item validation
// if wildcard domain included, check first level labels not also specified, i.e.
// *.example.com & www.example.com cannot be mixed, but example.com, *.example.com &
// test.wwww.example.com can
var invalidLabels = new List <string>();
if (domains.Any(d => d.StartsWith("*.")))
{
foreach (var wildcard in domains.Where(d => d.StartsWith("*.")))
{
var rootDomain = wildcard.Replace("*.", "");
// add list of domains where label count exceeds root domain label count
invalidLabels.AddRange(domains.Where(domain => domain != wildcard && domain.EndsWith(rootDomain) && domain.Count(s => s == '.') == wildcard.Count(s => s == '.')));
if (invalidLabels.Any())
{
results.Add(new StatusMessage {
IsOK = false, Message = $"Wildcard domain certificate requests (e.g. {wildcard}) cannot be mixed with requests including immediate subdomains (e.g. {invalidLabels[0]})."
});
return(results);
}
}
}
var generatedAuthorizations = new List <PendingAuthorization>();
try
{
// if DNS checks enabled, attempt them here
if (isPreviewMode && enableDnsChecks)
{
var includeIPResolution = false;
if (managedCertificate.RequestConfig.Challenges.Any(c => c.ChallengeType == SupportedChallengeTypes.CHALLENGE_TYPE_HTTP))
{
includeIPResolution = true;
}
log.Information("Performing preview DNS tests. {managedItem}", managedCertificate);
var tasks = new List <Task <List <ActionResult> > >();
foreach (var d in domains)
{
tasks.Add(_netUtil.CheckDNS(log, d.Replace("*.", ""), includeIPResolution));
}
var allResults = await Task.WhenAll(tasks);
// add DNS check results. DNS check fails are considered a warning instead of an error.
foreach (var checkResults in allResults)
{
foreach (var c in checkResults)
{
results.Add(new StatusMessage
{
IsOK = true,
HasWarning = !c.IsSuccess,
Message = c.Message
});
}
}
}
foreach (var domain in domains)
{
var challengeConfig = managedCertificate.GetChallengeConfig(domain);
var challengeType = challengeConfig.ChallengeType;
if (challengeType == SupportedChallengeTypes.CHALLENGE_TYPE_SNI)
{
log.Warning("tls-sni-01 challenge type is no longer supported by the Certificate Authority. Falling back to http-01");
challengeType = SupportedChallengeTypes.CHALLENGE_TYPE_HTTP;
}
if (challengeType == SupportedChallengeTypes.CHALLENGE_TYPE_HTTP)
{
// if dns validation not selected but one or more domains is a wildcard, reject
if (domain.StartsWith("*."))
{
results.Add(new StatusMessage {
IsOK = false, Message = $"http-01 authorization cannot be used for wildcard domains: {domain}. Use DNS (dns-01) validation instead."
});
return(results);
}
var challengeFileUrl = $"http://{domain}/.well-known/acme-challenge/configcheck";
var simulatedAuthorization = new PendingAuthorization
{
Challenges = new List <AuthorizationChallengeItem> {
new AuthorizationChallengeItem
{
ChallengeType = SupportedChallengeTypes.CHALLENGE_TYPE_HTTP,
ResourcePath = Path.Combine(".well-known", "acme-challenge", "configcheck"),
ResourceUri = challengeFileUrl,
Value = "Extensionless File Config Test - OK"
}
}
};
generatedAuthorizations.Add(simulatedAuthorization);
var httpChallengeResult = await PerformChallengeResponse_Http01(
log, serverManager, domain, managedCertificate, simulatedAuthorization
);
if (!httpChallengeResult.IsSuccess)
{
var result = new StatusMessage();
result.IsOK = false;
result.FailedItemSummary.Add($"Config checks failed to verify http://{domain} is both publicly accessible and can serve extensionless files e.g. {challengeFileUrl}");
result.Message = httpChallengeResult.Message;
results.Add(result);
// don't check any more after first failure
break;
}
else
{
results.Add(new StatusMessage {
IsOK = true, Message = httpChallengeResult.Message, Result = httpChallengeResult
});
}
}
else if (challengeType == SupportedChallengeTypes.CHALLENGE_TYPE_SNI)
{
var result = new StatusMessage();
result.IsOK = false;
result.FailedItemSummary.Add($"The {SupportedChallengeTypes.CHALLENGE_TYPE_SNI} challenge type is no longer available.");
results.Add(result);
return(results);
/*
*
* var serverVersion = await serverManager.GetServerVersion();
*
* if (serverVersion.Major < 8)
* {
* result.IsOK = false;
* result.FailedItemSummary.Add($"The {SupportedChallengeTypes.CHALLENGE_TYPE_SNI} challenge is only available for IIS versions 8+.");
* results.Add(result);
*
* return results;
* }
*
* var simulatedAuthorization = new PendingAuthorization
* {
* Challenges = new List<AuthorizationChallengeItem> {
* new AuthorizationChallengeItem
* {
* ChallengeType = SupportedChallengeTypes.CHALLENGE_TYPE_SNI,
* HashIterationCount= 1,
* Value = GenerateSimulatedKeyAuth()
* }
* }
* };
*
* generatedAuthorizations.Add(simulatedAuthorization);
*
* result.IsOK =
* PrepareChallengeResponse_TlsSni01(
* log, serverManager, domain, managedCertificate, simulatedAuthorization
* )();
*
* results.Add(result);
*/
}
else if (challengeType == SupportedChallengeTypes.CHALLENGE_TYPE_DNS)
{
var recordName = $"_acme-challenge-test.{domain}".Replace("*.", "");
// ISSUE: dependency on changing behavior for a specific plugin
if (challengeConfig.ChallengeProvider == "DNS01.API.AcmeDns" || challengeConfig.ChallengeProvider == "DNS01.API.CertifyDns")
{
// use real cname to avoid having to setup different records
recordName = $"_acme-challenge.{domain}".Replace("*.", "");
}
var simulatedAuthorization = new PendingAuthorization
{
Challenges = new List <AuthorizationChallengeItem> {
new AuthorizationChallengeItem
{
ChallengeType = SupportedChallengeTypes.CHALLENGE_TYPE_DNS,
Key = recordName,
Value = GenerateSimulatedDnsAuthValue()
}
}
};
generatedAuthorizations.Add(simulatedAuthorization);
var dnsResult =
await PerformChallengeResponse_Dns01(
log,
domain,
managedCertificate,
simulatedAuthorization,
isTestMode : true,
credentialsManager
);
var result = new StatusMessage();
result.Message = dnsResult.Result.Message;
result.IsOK = dnsResult.Result.IsSuccess;
if (!result.IsOK)
{
result.FailedItemSummary.Add(dnsResult.Result.Message);
}
results.Add(result);
}
else
{
throw new NotSupportedException($"ChallengeType not supported: {challengeConfig.ChallengeType}");
}
}
}
finally
{
//FIXME: needs to be filtered by managed site: result.Message = String.Join("\r\n", GetActionLogSummary());
generatedAuthorizations.ForEach(ga => ga.Cleanup());
}
return(results);
}
public IPCMessage(StatusMessage status)
{
StatusMsg = status;
}
/// <summary>
/// Called when a subscription expires.
/// </summary>
/// <param name="subscription">The subscription.</param>
internal void SubscriptionExpired(Subscription subscription)
{
lock (m_statusMessages)
{
StatusMessage message = new StatusMessage();
message.SubscriptionId = subscription.Id;
message.Message = subscription.PublishTimeout();
Queue<StatusMessage> queue = null;
if (subscription.SessionId != null && m_statusMessages.TryGetValue(subscription.SessionId, out queue))
{
queue.Enqueue(message);
}
}
}
/// <summary>
/// The on status message.
/// </summary>
/// <param name="eventArgs">
/// The event args.
/// </param>
public void OnStatusMessage(StatusMessageEventArgs eventArgs)
{
StatusMessage?.Invoke(this, eventArgs);
}
public void PushMessage(IPipe pipe, IMessage message)
{
if (message is ResetMessage)
{
_timeStamper.Reset();
}
else if (message is StatusMessage)
{
StatusMessage statusMsg = message as StatusMessage;
_data.SendStatus(statusMsg.body as StatusASO);
}
else if (message is RtmpMessage)
{
// Make sure chunk size has been sent
if (!_chunkSizeSent)
{
SendChunkSize();
}
RtmpMessage rtmpMsg = message as RtmpMessage;
IRtmpEvent msg = rtmpMsg.body;
int eventTime = msg.Timestamp;
#if !SILVERLIGHT
if (log.IsDebugEnabled)
{
log.Debug(string.Format("Message timestamp: {0}", eventTime));
}
#endif
if (eventTime < 0)
{
#if !SILVERLIGHT
if (log.IsDebugEnabled)
{
log.Debug(string.Format("Message has negative timestamp: {0}", eventTime));
}
#endif
return;
}
byte dataType = msg.DataType;
// Create a new header for the consumer
RtmpHeader header = _timeStamper.GetTimeStamp(dataType, eventTime);
switch (msg.DataType)
{
case Constants.TypeStreamMetadata:
Notify notify = new Notify((msg as Notify).Data);
notify.Header = header;
notify.Timestamp = header.Timer;
_data.Write(notify);
break;
case Constants.TypeFlexStreamEnd:
// TODO: okay to send this also to AMF0 clients?
FlexStreamSend send = new FlexStreamSend((msg as Notify).Data);
send.Header = header;
send.Timestamp = header.Timer;
_data.Write(send);
break;
case Constants.TypeVideoData:
VideoData videoData = new VideoData((msg as VideoData).Data);
videoData.Header = header;
videoData.Timestamp = header.Timer;
_video.Write(videoData);
break;
case Constants.TypeAudioData:
AudioData audioData = new AudioData((msg as AudioData).Data);
audioData.Header = header;
audioData.Timestamp = header.Timer;
_audio.Write(audioData);
break;
case Constants.TypePing:
Ping ping = new Ping((msg as Ping).PingType, (msg as Ping).Value2, (msg as Ping).Value3, (msg as Ping).Value4);
ping.Header = header;
_connection.Ping(ping);
break;
case Constants.TypeBytesRead:
BytesRead bytesRead = new BytesRead((msg as BytesRead).Bytes);
bytesRead.Header = header;
bytesRead.Timestamp = header.Timer;
_connection.GetChannel((byte)2).Write(bytesRead);
break;
default:
_data.Write(msg);
break;
}
}
}
private void HandleStatusEvent(Transform originator, Transform target, StatusMessage message, float value)
{
switch (message)
{
case StatusMessage.CharacterActivated: _isActive = (_transform == target); break;
case StatusMessage.CharacterDeactivated: _isActive = false; break;
case StatusMessage.StartedFieldMovement: HandleFieldMovementStart(); break;
case StatusMessage.CompletedFieldMovement: HandleFieldMovementCompletion(target); break;
case StatusMessage.EnemyActionTargetSelected: HandleActionTargetAssignment(target, originator); break;
case StatusMessage.AlliedActionTargetSelected: HandleActionTargetAssignment(originator, target); break;
}
}
public void AddStatusMessage(StatusMessage statusMessage)
{
this.StatusMessages.Insert(0, statusMessage);
TrimStatusMessages();
}
public void AddMessage(PlayerAIBase.STATUS status, Player about, List<Passenger> pickup)
{
StatusMessage msg = new StatusMessage(status, about, pickup);
lock (messages)
messages.Enqueue(msg);
EventThread.Set();
}
public void FireStatusEvent(StatusMessage message)
{
FireStatusEvent(Source, message, 0.0f);
}
private void VerifyButton_Click(object sender, EventArgs e)
{
log.LogMessage("Verify Button Click");
Status = StatusMessage.Verify;
for (int i = 0; i < barCodeList.ControlList.Count; i++)
{
BarCodeListItemControl item = (BarCodeListItemControl)barCodeList.ControlList[i];
item.btnCheck.PerformClick();
var itm = barCodeList.DataSource[i];
if (!itm.Verify)
{
MessageBox.Show("Invalid value in " + item.Name, Text, MessageBoxButtons.OK, MessageBoxIcon.Stop);
return;
}
}
//if (BarCodeItems.Any(x => !x.Verify))
// return;
if (VerifyDirectory(defaults.ManualSuccessFolder))
{
try
{
if (rec.BubbleItems.Count == 0)
{
for (int i = 0; i < bac.CheckBoxArr.Length; i++)
{
BubbleItem bi = new BubbleItem();
Bubble b = (Bubble)bac.CheckBoxArr[i].Tag;
bi.Bubble = b;
bi.CheckedBubble = new CheckedBubble();
bi.CheckedBubble.isChecked = bac.CheckBoxArr[i].Checked;
rec.BubbleItems.Add(bi);
}
}
DrawBubbleItems(false);
bool emty = true;
for (int k = 0; k < rec.BubbleItems.Count; k++)
{
if (rec.BubbleItems[k].CheckedBubble.isChecked)
{
emty = false;
break;
}
}
if (emty)
{
if (MessageBox.Show("Are you sure you want verify this sheet? No answers selected."
, Text, MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.No)
{
Status = StatusMessage.NULL;
return;
}
}
rec.VerifySheetManual(BarCodeItems.ToList(), rec.BubbleItems.ToList());
allAreasNaturalSize = new Rectangle[0];
}
catch (Exception)
{
allAreasNaturalSize = new Rectangle[0];
VerifyButton.Enabled = false;
NextButton.Enabled = true;
DeleteButton.Enabled = true;
Status = StatusMessage.NULL;
return;
}
lastSheetId = rec.SheetIdentifier;
lastTestId = testId;
lastAmoutOfQuestions = rec.AmoutOfQuestions.ToString();
lastIndexOfQuestion = rec.IndexOfFirstQuestion.ToString();
lastDistrictId = districtId;
errList.Clear();
lblErr.Visible = false;
DeleteTempFiles(rec.FileName, rec.AuditFileName);
if (linsForm != null)
linsForm_FormClosing(null, new FormClosingEventArgs(CloseReason.None, false));
}
}
private void OnStatusMessage(string message)
{
StatusMessage?.Invoke(this, new EventArgs <string>(message));
}
/**
* Display a message in the notifications bar
*/
public void DisplayStatusText(string text)
{
Gtk.Application.Invoke(delegate {
messageId = notificationBar.Push(contextId, text);
StatusMessage message = new StatusMessage(this,messageId, contextId);
message.StartTimer();
});
}
private void HandleStatusEvent(Transform originator, Transform target, StatusMessage message, float value)
{
switch (message)
{
case StatusMessage.CharacterSelected: HandleCharacterSelection(target); break;
case StatusMessage.CharacterActivated: SetActiveCharacter(target); break;
case StatusMessage.CharacterDeactivated: SetActiveCharacter(null); break;
}
}
public void RaiseStatusMessage(string message)
{
StatusMessage?.Invoke(this, new StringEventArgs(message));
}
/**
* When we're here, we have the status message
*/
protected void StatusCloseHandler(object q, EventArgs args) {
try {
Channel resq = (Channel)q;
//If we got no result
RpcResult res = (RpcResult)resq.Dequeue();
StatusMessage sm = new StatusMessage((IDictionary)res.Result);
if(_node.EdgeVerifyMethod != null) {
if(!_node.EdgeVerifyMethod(_node, _e, LinkMessageReply.Local.Address)) {
throw new Exception("Edge verification failed!");
}
}
Connection c = new Connection(_e, LinkMessageReply.Local.Address,
_contype, sm, LinkMessageReply);
_node.ConnectionTable.Add(c);
_con.Value = c;
Finish(Result.Success);
}
catch(InvalidOperationException) {
/*
* This is unexpected.
*/
string message = String.Format(
"No StatusMessage returned from open({1}) Edge: {0}",
_e, !_e.IsClosed);
if(ProtocolLog.LinkDebug.Enabled) {
ProtocolLog.Write(ProtocolLog.LinkDebug, message);
}
/*
* We got a link message from this guy, but not a status response,
* so let's try this TA again.
*/
Finish(Result.RetryThisTA);
}
catch(Exception x) {
/*
* Clearly we got some response from this edge, but something
* unexpected happened. Let's try it this edge again if we
* can
*/
if(ProtocolLog.LinkDebug.Enabled) {
ProtocolLog.Write(ProtocolLog.LinkDebug, String.Format(
"LPS.StatusResultHandler Exception: {0}", x));
}
Finish(Result.RetryThisTA);
}
}
public Kbtter4Notification(StatusMessage st)
{
SourceStatus = st;
Kind = Kbtter4NotificationKind.Retweeted;
}
private void HandleStatusEvent(Transform originator, Transform target, StatusMessage message, float value)
{
if (target == _transform)
{
switch (message)
{
case StatusMessage.StartedAutoAction: SetActionInProgressFlag(originator, true); break;
case StatusMessage.CompletedAutoAction: SetActionInProgressFlag(originator, false); break;
case StatusMessage.ReduceHealth: HandleHealthLoss(value); break;
case StatusMessage.IncreaseHealth: HandleHealthGain(value); break;
}
}
}
// -------------------------------------------------------------------------------------
// FluidStatusBar
// -------------------------------------------------------------------------------------
#region FluidStatusBar
void DoWork(object sender, DoWorkEventArgs e)
{
if (bgWorker.CancellationPending)
{
return;
}
StatusMessage msg = new StatusMessage("Verifying Code!", true);
bgWorker.ReportProgress(0, msg);
Thread.Sleep(200 + _rnd.Next(600));
if (bgWorker.CancellationPending)
{
return;
}
msg.Message = "Verifying : 10%";
msg.IsAnimated = true;
bgWorker.ReportProgress(0, msg);
Thread.Sleep(100 + _rnd.Next(400));
for (int i = 1; i < 10; i++)
{
if (bgWorker.CancellationPending)
{
return;
}
msg.Message = String.Format("Verifying : {0}%", (i + 1) * 10);
msg.IsAnimated = false;
bgWorker.ReportProgress(0, msg);
Thread.Sleep(200 + _rnd.Next(200));
}
Thread.Sleep(750);
if (bgWorker.CancellationPending)
{
return;
}
msg.Message = "Compiling Code!";
msg.IsAnimated = true;
bgWorker.ReportProgress(0, msg);
Thread.Sleep(300 + _rnd.Next(200));
if (bgWorker.CancellationPending)
{
return;
}
msg.Message = "Compiling : 10%";
msg.IsAnimated = true;
bgWorker.ReportProgress(0, msg);
Thread.Sleep(100 + _rnd.Next(200));
for (int i = 1; i < 10; i++)
{
if (bgWorker.CancellationPending)
{
return;
}
msg.Message = String.Format("Compiling : {0}%", (i + 1) * 10);
msg.IsAnimated = false;
bgWorker.ReportProgress(0, msg);
Thread.Sleep(300);
}
Thread.Sleep(200 + _rnd.Next(600));
if (bgWorker.CancellationPending)
{
return;
}
msg.Message = "Linking!";
msg.IsAnimated = true;
bgWorker.ReportProgress(0, msg);
Thread.Sleep(200 + _rnd.Next(600));
if (bgWorker.CancellationPending)
{
return;
}
msg.Message = "Linking : 10%";
msg.IsAnimated = true;
bgWorker.ReportProgress(0, msg);
Thread.Sleep(100 + _rnd.Next(300));
for (int i = 1; i < 10; i++)
{
if (bgWorker.CancellationPending)
{
return;
}
msg.Message = String.Format("Linking : {0}%", (i + 1) * 10);
msg.IsAnimated = false;
bgWorker.ReportProgress(0, msg);
Thread.Sleep(200 + _rnd.Next(100));
}
Thread.Sleep(200 + _rnd.Next(300));
if (bgWorker.CancellationPending)
{
return;
}
msg.Message = "Build Completed!";
msg.IsAnimated = true;
bgWorker.ReportProgress(0, msg);
}
/**
* Get a StatusMessage for this node
*/
public IDictionary GetStatus(IDictionary status_message, ISender edge) {
//we just got s status request
if( 1 == _disconnecting ) {
throw new AdrException((int)ErrorMessage.ErrorCode.Disconnecting, "disconnecting");
}
StatusMessage sm = new StatusMessage(status_message);
Edge from = GetEdge(edge);
if(ProtocolLog.LinkDebug.Enabled) {
ProtocolLog.Write(ProtocolLog.LinkDebug, String.Format(
"{0} -start- sys:link.GetStatus({1},{2})", _node.Address, sm, edge));
}
CphState cphstate = null;
if(from != null) {
cphstate = _edge_to_cphstate[from] as CphState;
}
/**
* StatusMessage objects are used to verify the completion
* of the Link protocol. If we receive a StatusMessage request
* after we send a LinkMessage response, we know the other
* Node got our LinkMessage response, and the connection
* is active
*/
StatusMessage response = null;
ConnectionTable tab = _node.ConnectionTable;
if (cphstate != null) {
try {
LinkMessage lm_to_add = cphstate.LM;
//This is part of connection process:
response = _node.GetStatus( sm.NeighborType, lm_to_add.Local.Address );
Connection con = new Connection(from,
lm_to_add.Local.Address,
lm_to_add.ConTypeString,
sm,
lm_to_add);
tab.Add(con);
}
finally {
from.CloseEvent -= this.CloseHandler;
CloseHandler(from, null);
}
} else {
//This is just a "regular" status request
//update our table:
Address fadd = null;
Connection c = tab.GetConnection(from);
if( c != null ) {
fadd = c.Address;
tab.UpdateStatus(c, sm);
}
response = _node.GetStatus( sm.NeighborType, fadd );
}
if(ProtocolLog.LinkDebug.Enabled) {
ProtocolLog.Write(ProtocolLog.LinkDebug, String.Format(
"{0} -end- sys:link.GetStatus()->{1}", _node.Address,response));
}
return response.ToDictionary();
}
public void OnErrorStatusNotification(StatusMessage message)
{
Console.WriteLine("<null change handler>.OnErrorStatusNotification: " + message);
}
