internal override void Completed(MediatorContext mediatorContext, IClientContext clientContext, IPeerContext peerContext, OperationCompletedEventArgs oce)
{
ClientConst.OperationResult operationResult = oce.Result;
if (operationResult == ClientConst.OperationResult.Successful)
{
Logger.GetLog().Info("接続が完了しました（接続数： " + peerContext.Connections + "）。");
mediatorContext.State = new ConnectedState();
}
else if (operationResult == ClientConst.OperationResult.Restartable)
{
Logger.GetLog().Info("IPアドレスが変化しているため、再接続します。");
peerContext.DisconnectAll();
Logger.GetLog().Info("ピア接続をすべて切断しました（接続数: " + peerContext.Connections + "）");
mediatorContext.State = new DisconnectedState();
mediatorContext.Connect();
}
else if (operationResult == ClientConst.OperationResult.Retryable)
{
// FIXME: 再試行すること。いまは放置プレイ
Logger.GetLog().Info("接続に失敗しましたが、再試行可能なエラーです。");
mediatorContext.State = new DisconnectedState();
}
else
{
throw new NotSupportedException();
}
}
public void OffsetDefaultTest()
{
var mediatorContext = new MediatorContext();
var now = DateTime.Now;
var protocolTime = mediatorContext.CalcNowProtocolTime();
Assert.AreEqual(0, (protocolTime - now).TotalSeconds, 1.0);
}
public Activator(Configuration configuration, MediatorContext mediatorContext)
{
this.configuration = configuration;
mediatorContext.OnEarthquake += MediatorContext_OnEarthquake;
mediatorContext.OnTsunami += MediatorContext_OnTsunami;
mediatorContext.OnEEWTest += MediatorContext_OnEEWTest;
mediatorContext.OnNewUserquakeEvaluation += MediatorContext_OnNewUserquakeEvaluation;
}
internal override void Completed(MediatorContext mediatorContext, IClientContext clientContext, IPeerContext peerContext, OperationCompletedEventArgs oce)
{
if (oce.Result == ClientConst.OperationResult.Retryable)
{
mediatorContext.State = new ConnectedState();
return;
}
mediatorContext.State = new DisconnectedState();
}
public void OffsetMinusTest()
{
var mediatorContext = new MediatorContext();
SetOffset(mediatorContext, DateTime.Now.AddSeconds(-5));
var now = DateTime.Now;
var protocolTime = mediatorContext.CalcNowProtocolTime();
Assert.AreEqual(-5, (protocolTime - now).TotalSeconds, 1.0);
}
static void GrcpMain()
{
BasicConfigurator.Configure();
var mc = new MediatorContext();
var dr = ObserverFactory.CreateObserver(ObserverType.Dummy, mc);
var pr = ObserverFactory.CreateObserver(ObserverType.Print, mc);
var gr = ObserverFactory.CreateObserver(ObserverType.Grpc, mc);
Console.ReadLine();
}
private void SetOffset(MediatorContext mediatorContext, DateTime protocolTime)
{
var field = mediatorContext.GetType().GetField("clientContext", BindingFlags.NonPublic | BindingFlags.GetField | BindingFlags.Instance);
var clientContext = (ClientContext)field.GetValue(mediatorContext);
var requireProtocolTimeState = new RequireProtocolTimeState();
var packet = new Packet();
packet.Data = new string[] { protocolTime.ToString("yyyy/MM/dd HH-mm-ss") };
requireProtocolTimeState.ReceiveProtocolTime(clientContext, null, packet);
}
public Notifier(Configuration configuration, MediatorContext mediatorContext)
{
this.configuration = configuration;
this.mediatorContext = mediatorContext;
this.userquakeArea = Resource.epsp_area.Split('\n').Skip(1).Select(e => e.Split(',')).ToDictionary(e => e[0], e => e[4]);
mediatorContext.OnEarthquake += MediatorContext_OnEarthquake;
mediatorContext.OnTsunami += MediatorContext_OnTsunami;
mediatorContext.OnEEWTest += MediatorContext_OnEEWTest;
mediatorContext.OnNewUserquakeEvaluation += MediatorContext_OnNewUserquakeEvaluation;
ToastNotificationManagerCompat.OnActivated += ToastNotificationManagerCompat_OnActivated;
}
private static IObserver GenerateObserver(ObserverType type, MediatorContext m)
{
return(type switch
{
ObserverType.Dummy => new DummyObserver()
{
MediatorContext = m
},
ObserverType.Print => new PrintObserver()
{
MediatorContext = m
},
ObserverType.Grpc => GenerateGrpcObserver(m),
_ => throw new ArgumentException($"Unknown receiver type: {type}"),
});
public Server(MediatorContext mediatorContext)
{
// Additional configuration is required to successfully run gRPC on macOS.
// For instructions on how to configure Kestrel and gRPC clients on macOS, visit https://go.microsoft.com/fwlink/?linkid=2099682
Host.CreateDefaultBuilder(null)
.ConfigureWebHostDefaults(webBuilder =>
{
webBuilder.UseStartup <Startup>((_) =>
{
return(new Startup()
{
MediatorContext = mediatorContext
});
});
}).Build().RunAsync();
}
public static IObserver CreateObserver(ObserverType type, MediatorContext m)
{
var r = GenerateObserver(type, m);
m.StateChanged += r.StateChanged;
m.Completed += r.Completed;
m.ConnectionsChanged += r.ConnectionsChanged;
m.OnEarthquake += r.OnEarthquake;
m.OnTsunami += r.OnTsunami;
m.OnAreapeers += r.OnAreapeers;
m.OnEEWTest += r.OnEEWTest;
m.OnUserquake += r.OnUserquake;
m.OnNewUserquakeEvaluation += r.OnNewUserquakeEvaluation;
m.OnUpdateUserquakeEvaluation += r.OnUpdateUserquakeEvaluation;
return(r);
}
public Task Initialize(MatchConfig config)
{
Assert.IsTrue(config.IsValid);
PlayerSimulations = new PlayerSimulation[config.PlayerCount];
var tasks = new List <Task>();
for (int i = 0; i < PlayerSimulations.Length; i++)
{
PlayerSimulations[i] = new PlayerSimulation();
tasks.Add(PlayerSimulations[i].Initialize(config.PlayerConfigs[i]));
}
context = Mediator.Global.CreateContext();
context.Subscribe <PlayerResetEvent>(ResetPlayer);
return(Task.WhenAll(tasks));
}
public void SetUp()
{
mediatorContext = new MediatorContext();
mediatorContext.PeerId = 10;
mediatorContext.AreaCode = 901;
var key = new KeyData();
key.Expire = DateTime.Parse(keyExpire.Replace("-", ":"));
key.PublicKey = publicKey;
key.PrivateKey = privateKey;
key.Signature = keySignature;
mediatorContext.Key = key;
mediatorContext.TimeOffset = key.Expire.Subtract(DateTime.Now.AddMinutes(1));
peerContextMock = new Mock <IPeerContext>();
var field = mediatorContext.GetType().GetField("peerContext", BindingFlags.SetField | BindingFlags.NonPublic | BindingFlags.Instance);
field.SetValue(mediatorContext, peerContextMock.Object);
}
public void LongTimeConnectingTest()
{
var mediatorContext = new MediatorContext();
var maintainTimerField = mediatorContext.GetType().GetField("maintainTimer", BindingFlags.GetField | BindingFlags.NonPublic | BindingFlags.Instance);
var timer = (MaintainTimer)maintainTimerField.GetValue(mediatorContext);
var intervalField = timer.GetType().GetField("maintainInterval", BindingFlags.SetField | BindingFlags.NonPublic | BindingFlags.Instance);
intervalField.SetValue(timer, 1000);
var field = mediatorContext.GetType().GetField("clientContext", BindingFlags.SetField | BindingFlags.NonPublic | BindingFlags.Instance);
var clientContextMock = new Mock <IClientContext>();
field.SetValue(mediatorContext, clientContextMock.Object);
bool isCalled = false;
mediatorContext.StateChanged += (s, e) =>
{
Console.WriteLine("State: " + mediatorContext.State);
if (mediatorContext.State is DisconnectedState)
{
isCalled = true;
}
};
mediatorContext.Completed += (s, e) => { };
mediatorContext.ConnectionsChanged += (s, e) => { };
mediatorContext.Connect();
int waitSeconds = 120;
while (waitSeconds-- > 0 && !isCalled)
{
Thread.Sleep(1000);
}
Assert.IsTrue(isCalled);
}
internal virtual void Disconnect(MediatorContext mediatorContext, IClientContext clientContext, IPeerContext peerContext)
{
throw new InvalidOperationException($"Cannot disconnect in {GetType().Name}");
}
public Task Initialize(MatchConfig config)
{
Events = Mediator.Global.CreateContext();
Events.Subscribe <PlayerDiedEvent>(OnPlayerDied);
return(Task.CompletedTask);
}
internal virtual void Completed(MediatorContext mediatorContext, IClientContext clientContext, IPeerContext peerContext, OperationCompletedEventArgs oce)
{
throw new NotImplementedException();
}
public OperatorService(MediatorContext mediatorContext)
{
_m = mediatorContext;
}
internal virtual void Abort(MediatorContext mediatorContext, IClientContext clientContext, IPeerContext peerContext)
{
throw new NotImplementedException();
}
public ObserverService(MediatorContext mediatorContext)
{
_m = mediatorContext;
}
private static void BootP2PQuake(bool localMode)
{
// ViewModel を取得したりイベントハンドラをくっつけたりする
while (viewModel == null)
{
try
{
App.Current.Dispatcher.Invoke(() =>
{
if (App.Current?.MainWindow?.DataContext != null)
{
var window = (MainWindow)App.Current?.MainWindow;
viewModel = (RootViewModel)window?.DataContext;
viewModel.SettingViewModel.LoadFromConfiguration(ConfigurationManager.Configuration);
window.OnExit += Window_OnExit;
window.OnUserquake += Window_OnUserquake;
}
});
}
catch
{
// nothing to do
}
Thread.Sleep(1000);
}
;
client = new MediatorContext();
client.ConnectionsChanged += Client_ConnectionsChanged;
client.StateChanged += Client_StateChanged;
client.OnAreapeers += Client_OnAreapeers;
client.OnEarthquake += Client_OnEarthquake;
client.OnTsunami += Client_OnTsunami;
client.OnEEWTest += Client_OnEEWTest;
client.OnNewUserquakeEvaluation += Client_OnNewUserquakeEvaluation;
client.OnUpdateUserquakeEvaluation += Client_OnUpdateUserquakeEvaluation;
configuration.OnChangeEPSPConfiguration += (s, e) =>
{
ReflectEPSPConfiguration();
};
ReflectEPSPConfiguration();
notifier = new Notifier(configuration, client);
activator = new Notifications.Activator(configuration, client);
player = new Player(configuration, client);
if (localMode)
{
// 検証鍵をテスト用のものに差し替える
var verifierType = Type.GetType("PKCSPeerCrypto.Verifier, PKCSPeerCrypto");
var serverProofKey = verifierType.GetField("ServerProofKey", BindingFlags.NonPublic | BindingFlags.Static);
serverProofKey.SetValue(null, "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDB+t0YTWlu3FFiwTb05u2bHWJRpCQJeAzhia6pWJ5BqsVIXgG7zeiHu4cFWrKME7fHQsjlihjnhtaksEtkmnbODUHnNi26FStSSpyo8ex0FZDfXtoQ9VB0m6UxdrGznpzfO9PWbpC0iSoCAyeqILLcDDbuBv5xY6+0D35kQx74kQIDAQAB");
client.Verification = false;
// P2P 地震情報ネットワークに接続せず、 localhost:6910 に接続する
var field = client.GetType().GetField("peerContext", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
var peerContext = field.GetValue(client);
var peerDataType = Type.GetType("Client.Common.General.PeerData, Client");
var peerData = System.Activator.CreateInstance(peerDataType, new object[] { "localhost", 6910, 10 });
var peerDatas = Array.CreateInstance(peerDataType, 1);
peerDatas.SetValue(peerData, 0);
var connectMethod = Type.GetType("Client.Peer.Context, Client").GetMethod("Connect");
connectMethod.Invoke(peerContext, new object[] { peerDatas });
return;
}
client.Connect();
ReadHistories();
}
public Handler(MediatorContext context)
{
_context = context;
}
internal override bool Maintain(MediatorContext mediatorContext, IClientContext clientContext, IPeerContext peerContext)
{
mediatorContext.State = new MaintenanceState();
return(clientContext.Maintain());
}
internal override void Disconnect(MediatorContext mediatorContext, IClientContext clientContext, IPeerContext peerContext)
{
mediatorContext.State = new DisconnectingState();
peerContext.DisconnectAll();
clientContext.Part();
}
internal override bool Connect(MediatorContext mediatorContext, IClientContext clientContext, IPeerContext peerContext)
{
mediatorContext.State = new ConnectingState();
return(clientContext.Join());
}
internal virtual bool Maintain(MediatorContext mediatorContext, IClientContext clientContext, IPeerContext peerContext)
{
throw new InvalidOperationException($"Cannot maintain in {GetType().Name}");
}
