public NetworkControllerFactory(IEnumerable <ICapabilityController> capabilityControllers)
{
NetworkController = new NetworkController(new List <TableSyncController>(),
new Dictionary <string, NamespaceNotificationController>());
var tableSyncControllers = NetworkController.TableSyncControllers;
var notificationControllers = NetworkController.NamespaceNotificationControllers;
foreach (var controller in capabilityControllers)
{
object[] attrs = controller.GetType().GetCustomAttributes(true);
foreach (Attribute attr in attrs)
{
if (attr is HermesNotifyNamespaceAttribute nsAttr)
{
NamespaceNotificationController notificationController;
if (!notificationControllers.TryGetValue(nsAttr.Namespace, out notificationController))
{
notificationController = new NamespaceNotificationController(nsAttr.Namespace);
notificationControllers.Add(nsAttr.Namespace, notificationController);
}
notificationController.Notify += controller.OnNotification;
controller.SendMessage += NetworkController.SendMessage;
}
else if (attr is HermesSyncTableAttribute tableAttr)
{
var tableSyncController = new TableSyncController(tableAttr.TableType);
tableSyncControllers.Add(tableSyncController);
}
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="Utp"/> class.
/// </summary>
/// <param name="parent">Parent newtwork controller</param>
/// <param name="target">Target networkcontroller</param>
public Utp(IActiveNetworkController parent, INetworkController target)
{
this.IsActive = false;
this.Parent = parent;
this.Target = target;
this.Cables = new List <ICable>
{
new Cable(target)
{
X = this.Parent.X, Y = this.Parent.Y
}
};
this.Creator = this.Parent;
if (this.EnemyUTP() != null)
{
this.Mode = UtpModes.MoveToBattle;
this.EnemyUTP().Mode = UtpModes.MoveToBattle;
}
else
{
this.Mode = UtpModes.Attack;
}
this.Disconnect = false;
this.HeadArrive += this.UTP_HeadArrive;
}
public void SendPacket(Packet p, INetworkController src)
{
// пусть это будет хаб - посылает пакет на все порты, кроме исходного
foreach (var i in Interfaces)
if (i != src)
Lan.SendPacket(p, i);
}
private void IsoDrawCabel(INetworkController networkControlObject, DrawingContext drawingContext)
{
foreach (var item in networkControlObject.Utps)
{
foreach (var cabels in item.Cables)
{
// SolidColorBrush s = Brushes.Red;
// if (item.Creator.Owner is HumanPlayer)
// {
// s = Brushes.Green;
// }
// draw line
// drawingContext.DrawLine(new Pen(Brushes.Black, 2), vh.IsoPosition(new Point((int)item.Parent.X, (int)item.Parent.Y)), vh.IsoPosition(new Point((int)item.Target.X, (int)item.Target.Y)));
// First parameter should be defined by the player own color
// drawingContext.DrawEllipse(s, null, vh.IsoPosition(new Point(cabels.X, cabels.Y)), cabels.Width / 2, cabels.Height / 2);
if (cabels.Previous is ICable)
{
drawingContext.DrawLine(new Pen(cabels.ChargeOwner != null ? Brushes.Yellow : this.sdi[item.Creator.Owner.Type].SolidColor, 5), this.vh.IsoPosition(new Point(cabels.X, cabels.Y)), this.vh.IsoPosition(new Point((cabels.Previous as ICable).X, (cabels.Previous as ICable).Y)));
}
else
{
drawingContext.DrawLine(new Pen(cabels.ChargeOwner != null ? Brushes.Yellow : this.sdi[item.Creator.Owner.Type].SolidColor, 5), this.vh.IsoPosition(new Point(cabels.X, cabels.Y)), this.vh.IsoPosition(new Point(item.Parent.X, item.Parent.Y)));
}
}
}
}
private void IsoDrawRouter(INetworkController router, DrawingContext drawingContext)
{
Size size = new Size(this.vh.IsoLenght(), (double)this.vh.IsoLenght() * ServerDrawInfo.RouterHeightsPropotion);
Point p = this.vh.DrawPosition(new Point(router.X, router.Y));
p = new Point(p.X - size.Width + 1, p.Y - size.Height + 1);
Rect position = new Rect(p, size);
if (router.IsEnable)
{
ServerDrawInfo sDITemp = this.sdi[router.Owner.Type] as ServerDrawInfo;
ImageBrush routerImage = sDITemp.Router;
drawingContext.DrawRectangle(routerImage, null, position);
this.LifeTextDrawTransform(router.Life.ToString(), drawingContext, Brushes.Black, p);
}
else
{
ImageBrush routerImage = (this.sdi[PlayerType.Nobody] as ServerDrawInfo).Router;
drawingContext.DrawRectangle(routerImage, null, position);
IInactiveNetworkController iNCTemp = router as IInactiveNetworkController;
this.LifeTextDrawTransform($"{iNCTemp.CapturePoint}/{iNCTemp.CaptureLimit}", drawingContext, router.Owner != null ? (this.sdi[router.Owner.Type] as ServerDrawInfo).SolidColor : Brushes.Black, p);
}
DrawedNetworkControllers.Add(router, position);
}
static void Main(string[] args)
{
INetworkController iNetworkController = ModuleFactory.GetNetworkController();
//获取所有网卡名称列表
//List<string> networkList = iNetworkController.GetNetworkList();
//获取无线网卡
ManagementObject wirelessNetwork = iNetworkController.GetNetwork("Realtek RTL8723AE Wireless LAN 802.11n PCI-E NIC");
if (wirelessNetwork == null)
{
Console.WriteLine("获取无线网卡错误");
Console.WriteLine("进程3秒后关闭");
Thread.Sleep(3000);
return;
}
else
{
Console.WriteLine("已获取无线网卡：" + "\n" + "Realtek RTL8723AE Wireless LAN 802.11n PCI-E NIC");
}
//获取无线网卡状态
bool networkState = iNetworkController.GetNetworkState("Realtek RTL8723AE Wireless LAN 802.11n PCI-E NIC");
if (networkState)
{
Console.WriteLine("");
Console.WriteLine("无线网卡已开启");
Console.WriteLine("正在禁用无线网卡...");
Console.WriteLine("");
if (iNetworkController.DisableNetwork(wirelessNetwork))
{
Thread.Sleep(1000);
Console.WriteLine("无线网卡禁用成功");
}
else
{
Thread.Sleep(1000);
Console.WriteLine("无线网卡禁用失败");
}
}
else
{
Console.WriteLine("");
Console.WriteLine("无线网卡已禁用");
Console.WriteLine("正在开启无线网卡...");
Console.WriteLine("");
if (iNetworkController.EnableNetwork(wirelessNetwork))
{
Thread.Sleep(1000);
Console.WriteLine("无线网卡开启成功");
}
else
{
Thread.Sleep(1000);
Console.WriteLine("无线网卡开启失败");
}
}
Console.WriteLine("");
Console.WriteLine("进程3秒后关闭");
Thread.Sleep(3000);
}
public void SendPacket(Packet p, INetworkController src = null)
{
// перебор всех интерфейсов, поиск того, с которого можно отправить
INetworkController sender = null;
foreach (var i in Interfaces)
{
if (IP.CompareBySubnets(p.DestinationIP, i.IP, i.Netmask))
{
sender = i;
break;
}
}
if (sender != null && src != sender)
{
p.SourceIP = sender.IP;
Lan.SendPacket(p, sender);
}
else
{
if (defaultIface == null)
{
// пакет никуда не уходит
Lan.SendPacket(p, null);
}
else
{
if (src != defaultIface)
{
p.SourceIP = defaultIface.IP;
Lan.SendPacket(p, defaultIface);
}
}
}
}
public WalletController(
IBlockchainController blockchainController,
ICertificateService certificateService,
IMessagePublisher messagePublisher,
IMessageSubscriber messageSubscriber,
INetworkController networkController,
INotificationService notificationService,
ISettingsManager settingsManager)
{
this.blockchainController = blockchainController;
this.certificateService = certificateService;
this.messagePublisher = messagePublisher;
this.messageSubscriber = messageSubscriber;
this.networkController = networkController;
this.notificationService = notificationService;
this.blockchainDataDirectoryPath = settingsManager.BlockchainDataDirectoryPath;
this.localNodePort = settingsManager.LocalNodePort;
this.localWSPort = settingsManager.LocalWSPort;
this.certificateCachePath = settingsManager.CertificateCachePath;
this.certificateQueryResultCache = new Dictionary <ECPoint, CertificateQueryResult>();
}
static async Task StartAsync(INetworkController controller, CancellationToken cancellationToken)
{
var delay = Settings.Current.StartAfter;
INetworkStatusReporter reporter = new NetworkStatusReporter(Settings.Current.TestResultCoordinatorEndpoint, Settings.Current.ModuleId, Settings.Current.TrackingId);
foreach (Frequency item in Settings.Current.Frequencies)
{
Log.LogInformation($"Schedule task for type {controller.NetworkControllerType} to start after {delay} Offline frequency {item.OfflineFrequency} Online frequency {item.OnlineFrequency} Run times {item.RunsCount}");
var taskExecutor = new CountedTaskExecutor(
async cs =>
{
await SetNetworkControllerStatus(controller, NetworkControllerStatus.Enabled, reporter, cs);
await Task.Delay(item.OfflineFrequency, cs);
await SetNetworkControllerStatus(controller, NetworkControllerStatus.Disabled, reporter, cs);
},
delay,
item.OnlineFrequency,
item.RunsCount,
Log,
"restrict/default");
await taskExecutor.Schedule(cancellationToken);
// Only needs to set the start delay for first frequency, after that reset to 0
delay = TimeSpan.FromSeconds(0);
}
}
/// <summary>
/// Конструктор
/// </summary>
/// <param name="controller">Контроллер сети</param>
/// <param name="periodSync">Период следования запроса Sync, мсек</param>
public ServiceSync(INetworkController controller, Double periodSync)
: base(controller)
{
this._TimerSyncMessage = new Timer(periodSync);
this._TimerSyncMessage.AutoReset = true;
this._TimerSyncMessage.Elapsed +=
new ElapsedEventHandler(EventHandler_TimerSyncMessage_Elapsed);
}
public void AddInterface(INetworkController iface)
{
if (!(iface is EthernetController))
throw new ArgumentException("Для данного типа устройств поддерживаются только Ethernet-контроллеры");
iface.Device = this;
Interfaces.Add(iface as EthernetController);
}
public static INetworkController GetNetworkController()
{
if (iNetworkController == null)
{
iNetworkController = new NetworkController();
}
return(iNetworkController);
}
/// <summary>
///
/// </summary>
/// <param name="controller">Контроллер сети</param>
public ServiceSync(INetworkController controller)
: base(controller)
{
this._TimerSyncMessage = new Timer(PERIOD_SYNC);
this._TimerSyncMessage.AutoReset = true;
this._TimerSyncMessage.Elapsed +=
new ElapsedEventHandler(EventHandler_TimerSyncMessage_Elapsed);
}
public NetworkViewModel(INetworkController networkController)
{
this.networkController = networkController;
Models = new ObservableCollection <NetworkData>();
networkUseSubscription = networkController
.NetworkUse
.ObserveOn(SynchronizationContext.Current)
.Subscribe(x => Models.UpdateAndRemove(x));
}
/// <summary>
/// Конструктор
/// </summary>
/// <param name="controller">Контроллер сети</param>
public ServiceNmt(INetworkController controller)
: base(controller)
{
//Инициализируем контексты устройств
_Context = new Context(_NetworkController.Devices.ToArray());
_NetworkController.Devices.CollectionWasChanged +=
new EventHandler<KeyedCollectionWasChangedEventArgs<DeviceBase>>(
EventHandlerDevicesCollectionWasChanged);
}
/// <summary>
/// Конструктор
/// </summary>
/// <param name="controller">Контроллер сети</param>
public ServiceNodeGuard(INetworkController controller)
: base(controller)
{
_Context = new Context(_NetworkController.Devices.ToArray());
_NetworkController.Devices.CollectionWasChanged +=
new EventHandler <KeyedCollectionWasChangedEventArgs <DeviceBase> >(
EventHandlerDevicesCollectionWasChanged);
}
void BuildDependencies()
{
_networkController = new NetworkController();
_favoritesDataStore = new FavoritesDataStore();
_downloadsDataStore = new DownloadsDataStore();
_favVM = new FavoritesViewModel(_favoritesDataStore, _downloadsDataStore);
_dlVM = new DownloadsViewModel(_downloadsDataStore, _favoritesDataStore);
_latestVM = new LatestVideosViewModel(_networkController, _favoritesDataStore, _downloadsDataStore);
}
public DevicesCollection(INetworkController network)
{
if (network == null)
{
throw new NullReferenceException();
}
_Network = network;
}
public void CreateCharacter()
{
//TODO to improve
NetworkController = UsefulContainer.Instance.Resolve <GameController>().NetworkController;
NetworkController.SendPacket(new CharacterCreateRequest
{
Nickname = nickname.text
});
}
/// <inheritdoc/>
public void InteractionStart(INetworkController networkController)
{
IActiveNetworkController aNCTemp = networkController as IActiveNetworkController;
if (networkController.IsEnable && aNCTemp != null && networkController.Owner == this.LocalPlayer)
{
this.LocalPlayer.SelectController(aNCTemp);
}
}
/// <summary>
/// Конструктор
/// </summary>
/// <param name="controller"></param>
public ServiceSdoUpload(INetworkController controller)
: base(controller)
{
//Инициализируем контексты устройств
_Context = new Context(_NetworkController.Devices.ToArray());
_NetworkController.Devices.CollectionWasChanged +=
new EventHandler <KeyedCollectionWasChangedEventArgs <DeviceBase> >(
EventHandlerDevicesCollectionWasChanged);
}
public LatestVideosViewModel(INetworkController networkController,
IVideoDataStore favoritesDataStore,
IVideoDataStore downloadsDataStore)
{
_networkController = networkController;
_favoritesDataStore = favoritesDataStore;
_downloadsDataStore = downloadsDataStore;
IsRefreshEnabled = true;
videoPairs = new ObservableCollection <VideoPairModel>();
}
static async Task SetNetworkControllerStatus(INetworkController controller, NetworkControllerStatus networkControllerStatus, INetworkStatusReporter reporter, CancellationToken cs)
{
await reporter.ReportNetworkStatusAsync(NetworkControllerOperation.SettingRule, networkControllerStatus, controller.NetworkControllerType);
bool success = await controller.SetNetworkControllerStatusAsync(networkControllerStatus, cs);
success = await CheckSetNetworkControllerStatusAsyncResult(success, NetworkControllerStatus.Disabled, controller, cs);
await reporter.ReportNetworkStatusAsync(NetworkControllerOperation.RuleSet, networkControllerStatus, controller.NetworkControllerType, success);
}
public SatelliteController(string networkInterfaceName, string iotHubHostname, NetworkProfileSetting settings)
{
if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
this.underlyingController = new WindowsSatelliteController(networkInterfaceName);
}
else
{
this.underlyingController = new LinuxTrafficControlController(settings, networkInterfaceName, iotHubHostname);
}
}
public FirewallOfflineController(string networkInterfaceName, string iotHubHostname)
{
if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
this.underlyingController = new WindowsFirewallOfflineController(networkInterfaceName);
}
else
{
this.underlyingController = new LinuxFirewallOfflineController(networkInterfaceName, iotHubHostname);
}
}
public OfflineController(string networkInterfaceName, string hubHostname, NetworkProfileSetting settings)
{
if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
this.underlyingController = new WindowsFirewallOfflineController(networkInterfaceName);
}
else
{
this.underlyingController = new LinuxTrafficControlController(settings, networkInterfaceName, hubHostname);
}
}
public LocalMovementController(IUnityInputProxy unityInputProxy, INetworkController networkController,
IRotationCommand rotationCommand, IMovementCommand movementCommand, IUnityPhysicsProxy unityPhysicsProxy,
IUnityDebugProxy unityDebugProxy)
{
this.unityInputProxy = unityInputProxy;
this.unityPhysicsProxy = unityPhysicsProxy;
this.unityDebugProxy = unityDebugProxy;
this.networkController = networkController;
this.rotationCommand = rotationCommand;
this.movementCommand = movementCommand;
}
/// <inheritdoc/>
public void ConnectTwoServer(IActiveNetworkController source, INetworkController target)
{
if (this.IsEnableConnection(source, target))
{
source.Attack(target);
}
else
{
this.Messages.Add(new GameMessage("Firewall blocked connection"));
}
}
public DownloadFromResponseAsyncDelegate(
INetworkController networkController,
IStreamController streamController,
IFileController fileController,
IStatusController statusController)
{
this.networkController = networkController;
this.streamController = streamController;
this.fileController = fileController;
this.statusController = statusController;
}
/// <inheritdoc/>
public void InteractionEnd(INetworkController networkController)
{
if (this.LocalPlayer.SelectedController != null)
{
if (this.LocalPlayer.SelectedController != networkController)
{
this.ConnectTwoServer(this.LocalPlayer.SelectedController, networkController);
}
this.LocalPlayer.SelectController(null);
}
}
public UpdateScreenshotsAsyncDelegate(
IGetUpdateUriDelegate <Entity> getUpdateUriDelegate,
IDataController <ProductScreenshots> screenshotsDataController,
INetworkController networkController,
IItemizeDelegate <string, string> itemizeScreenshotsDelegates,
IStatusController statusController)
{
this.getUpdateUriDelegate = getUpdateUriDelegate;
this.screenshotsDataController = screenshotsDataController;
this.networkController = networkController;
this.itemizeScreenshotsDelegates = itemizeScreenshotsDelegates;
this.statusController = statusController;
}
private bool IsEnableConnection(IActiveNetworkController source, INetworkController target)
{
List <IFireWall> firewalls = this.Firewalls();
foreach (var item in firewalls)
{
if (this.FireWallDetection(source, target, item))
{
return(false);
}
}
return(true);
}
public void AddInterface(INetworkController iface)
{
string gw = iface.Gateway;
if (gw.Length > 0)
{
foreach (var i in Interfaces)
if (i.Gateway.Length > 0)
throw new GatewayAlreadyDefined("Шлюз по-умолчанию для этого устройства уже задан.");
defaultIface = iface;
}
iface.Device = this;
Interfaces.Add(iface);
}
public DownloadManualUrlFileAsyncDelegate(
INetworkController networkController,
IFormatDelegate <string, string> formatUriRemoveSessionDelegate,
IRoutingController routingController,
IDownloadFromResponseAsyncDelegate downloadFromResponseAsyncDelegate,
IDownloadProductFileAsyncDelegate downloadValidationFileAsyncDelegate,
IStatusController statusController)
{
this.networkController = networkController;
this.formatUriRemoveSessionDelegate = formatUriRemoveSessionDelegate;
this.routingController = routingController;
this.downloadFromResponseAsyncDelegate = downloadFromResponseAsyncDelegate;
this.downloadValidationFileAsyncDelegate = downloadValidationFileAsyncDelegate;
this.statusController = statusController;
}
/// <summary>
/// On mouse button up starts an interaction.
/// </summary>
/// <param name="point">Interaction start point</param>
public void OnMouseButtonUp(Point point)
{
INetworkController clickedcontroller = this.FindClickedContrller(point);
if (clickedcontroller != null && this.GM.LocalPlayer.SelectedController != null)
{
this.GL.InteractionEnd(clickedcontroller);
}
else
{
Point pointToGA = this.vh.NormalPosition(point);
System.Drawing.Point p = new System.Drawing.Point((int)pointToGA.X, (int)pointToGA.Y);
this.GL.InteractionEnd(p);
}
}
public void SendPacket(Packet p, INetworkController iface)
{
// пакет никуда не уходит, что-нибудь сообщить...
if (iface == null)
;
// ищем интерфейс, с которым связан iface
foreach (var i in Links)
{
if (i.Point1 == iface)
i.Point2.ReceivePacket(p);
else if (i.Point2 == iface)
i.Point1.ReceivePacket(p);
}
}
/// <summary>
/// Конструктор
/// </summary>
/// <param name="controller">Контроллер сети</param>
/// <param name="periodOfTimeSync">
/// Период синхронизации времени в удалённых устройствах сети, сек
/// </param>
public ServicePdoReceive(INetworkController controller,
Int32 periodOfTimeSync)
: base(controller)
{
if (periodOfTimeSync > 0)
{
_SynchronizationPeriod = periodOfTimeSync;
}
else
{
throw new ArgumentOutOfRangeException("Interval", String.Format(
"Попытка установить недопустимое значение периода синхронизации времени. " +
"Знаение {0}, ожидается строго больше нуля",
periodOfTimeSync.ToString()));
}
}
/// <summary>
/// Конструктор
/// </summary>
/// <param name="controller"></param>
public ServiceBootUp(INetworkController controller)
: base(controller)
{
}
/// <summary>
/// Конструктор
/// </summary>
/// <param name="controller">Контроллер сети</param>
/// <param name="periodSync">Период следования запроса Sync, мсек</param>
public ServiceSync(INetworkController controller, Double periodSync)
: base(controller)
{
this._TimerSyncMessage = new Timer(periodSync);
this._TimerSyncMessage.AutoReset = true;
this._TimerSyncMessage.Elapsed +=
new ElapsedEventHandler(EventHandler_TimerSyncMessage_Elapsed);
}
/// <summary>
///
/// </summary>
/// <param name="controller">Контроллер сети</param>
public ServiceSync(INetworkController controller)
: base(controller)
{
this._TimerSyncMessage = new Timer(PERIOD_SYNC);
this._TimerSyncMessage.AutoReset = true;
this._TimerSyncMessage.Elapsed +=
new ElapsedEventHandler(EventHandler_TimerSyncMessage_Elapsed);
}
/// <summary>
/// Конструктор
/// </summary>
/// <param name="controller"></param>
public ServiceEmcy(INetworkController controller)
: base(controller)
{
}
/// <summary>
/// Конструктор
/// </summary>
/// <param name="controller">Контроллер сети</param>
public ServicePdoTransmit(INetworkController controller)
: base(controller)
{
}
/// <summary>
/// Констуктор базового класса
/// </summary>
/// <param name="controller">Контроллер сети</param>
protected Service(INetworkController controller)
{
String msg;
if (controller == null)
{
msg = String.Format("Попытка создать сетевой сервис {0}, " +
"для несуществующего контроллера сети", ServiceType);
throw new NullReferenceException(msg);
}
_TotalAttempts = 1;
_Status = Status.Stopped;
_NetworkController = controller;
}
/// <summary>
/// Конструктор
/// </summary>
/// <param name="controller">Контроллер сети</param>
public ServiceNodeGuard(INetworkController controller)
: base(controller)
{
_Context = new Context(_NetworkController.Devices.ToArray());
_NetworkController.Devices.CollectionWasChanged +=
new EventHandler<KeyedCollectionWasChangedEventArgs<DeviceBase>>(
EventHandlerDevicesCollectionWasChanged);
}
