public static void Main()
{
//init instances:
LogControl logControl = new LogControl();
SystemControl sysControl = new SystemControl(logControl);
ReplayManager replayManager = new ReplayManager();
SessionIdHandler sidHandler = new SessionIdHandler();
GameCenter gameCenter = new GameCenter(sysControl, logControl, replayManager, sidHandler);
var commHandler = CommunicationHandler.GetInstance();
MessageEventHandler eventHandler = new MessageEventHandler(gameCenter, sysControl,
logControl, replayManager, sidHandler);
gameCenter.SetMessageHandler(eventHandler);
var webEventHandler = new WebEventHandler(new ServerEventHandler(sidHandler, null,
gameCenter, sysControl, logControl, replayManager, null));
WebCommHandler webCommHandler = new WebCommHandler(webEventHandler);
Task commTask = Task.Factory.StartNew(commHandler.Start);
Task webCommTask = Task.Factory.StartNew(webCommHandler.Start);
Console.WriteLine("starting comm");
Task eventTask = Task.Factory.StartNew(eventHandler.HandleIncomingMsgs);
commTask.Wait();
webCommTask.Wait();
}
public GdbStub(int port, ICpuSupportingGdb cpu, bool autostartEmulation)
{
this.cpu = cpu;
Port = port;
pcktBuilder = new PacketBuilder();
commands = new CommandsManager(cpu);
commands.ShouldAutoStart = autostartEmulation;
TypeManager.Instance.AutoLoadedType += commands.Register;
terminal = new SocketServerProvider();
terminal.DataReceived += OnByteWritten;
terminal.ConnectionAccepted += delegate
{
cpu.Halted += OnHalted;
cpu.ExecutionMode = ExecutionMode.SingleStep;
};
terminal.ConnectionClosed += delegate
{
cpu.Halted -= OnHalted;
cpu.ExecutionMode = ExecutionMode.Continuous;
};
terminal.Start(port);
commHandler = new CommunicationHandler(this);
}
public ActionResult PrivateRoomSchedule(PrivateRooms model, string returnUrl)
{
var returnModel = new PrivateRoomModel();
var bdModel = DbContextHelper.RoomExistBD(model);
//Room n'exist pas dans bd
if (bdModel.RoomId == 0)
{
ModelHelper.PrivateRoomModel(model);
ConnectToAvailableHub();
returnModel = CommunicationHandler.CreatePrivateRoom(model);
}
else //Regarde si la room est en cours
{
var hubUrl = GetHubRoomExist(model.RoomName);
if (hubUrl != "no")
{
ConnectToHub(hubUrl); //Connexion au room
}
else
{
ConnectToAvailableHub(); //Prend le hub le plus libre pour la room
}
returnModel = CommunicationHandler.GetPrivateRoom(model.RoomName);
}
returnModel.UserName = System.Web.HttpContext.Current.User.Identity.Name; //User name de l'utilisateur connecter
returnModel.SetListCourse(); //La liste des cours pour le dropdown de cours
CommunicationHandler.DisposeConnection(); //Arrete la connexion, inutile de la garder ouverte.
return(View(returnModel));
}
static void Main(string[] parameters)
{
Thread.Sleep(1000);
//kad se server i posluzitelj pokreću istovremeno u Visual Studiju,
//tada unatoč postavljanja da se klijentska aplikacija pokreće prije serverske,
//klijentska uspije prije zauzeti defaultni port
CommunicationHandler sockObj = null;
switch (parameters.Length)
{
case 0:
//ili čini spajanje na neki defaultni hostname (možda na Azureu?)
MessageBox.Show("Hostname ili IP adresa (ni port) nisu proslijeđeni prilikom pokretanja programa!");
return;
case 1: // IP/hostname
sockObj = new CommunicationHandler(false, parameters[0]);
break;
case 2: // IP/hostname i port
ushort portNum;
if (!ushort.TryParse(parameters[1], out portNum))
{
MessageBox.Show("Pod vrijednost porta aplikacije je unešena nevaljana vrijednost");
return;
}
sockObj = new CommunicationHandler(false, parameters[0], portNum);
break;
}
DataHandler.entityNamesWithReferencesToBelongingDataStores = new Dictionary <string, BindingList <object> >();
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new Login(sockObj));
}
public void End()
{
CommunicationHandler?.Invoke(null, new CommunicationEventArgs()
{
Description = "end"
});
}
public Context(CommunicationHandler commHandler, bool useBuffering)
{
this.commHandler = commHandler;
if (useBuffering)
{
buffer = new Queue <byte>();
}
}
/// <summary>
/// Konstruktor bazne korisnički definirane klase forme gdje se definira mrežna utičnica putem koje će se vršiti mrežna komunikacija
/// </summary>
/// <param name="sockObj">Mrežna utičnica putem koje se vrši mrežna komunikacija u svim ostalim formama naslijeđenim od bazne</param>
protected ApstraktnaForma(CommunicationHandler sockObj)
{
if (ApstraktnaForma.sockObj == null)
{
ApstraktnaForma.sockObj = sockObj;
}
InitializeComponent();
}
public async Task ShouldReplyWithResponseMessage()
{
var handler = new CommunicationHandler();
var context = new TestableMessageHandlerContext();
await handler.Handle(new Message { name = "test" }, context)
.ConfigureAwait(false);
Assert.Single(context.RepliedMessages);
}
void OnEnable() {
_gameController = GetComponent<GameController>();
SessionData session = GameObject.Find("Lobby Settings").GetComponent<SessionData>();
ServerComs = session.ServerCom;
Guid = session.Guid;
CornerId = session.OwnId;
ServerComs.SetGuid(Guid);
ServerComs.SetErrorHandler(this);
ServerComs.SetProcessor(new DataProcessor(this, this, null));
}
void Start() {
GameObject go = GameObject.Find("Lobby Settings");
SessionData session = go.GetComponent<SessionData>();
LobbyId.text = session.LobbyId;
SetPlayers(session.Players);
ComHandler = new CommunicationHandler(session.LobbyConnection, this, null, null, this);
ComHandler.SetGuid(session.Guid);
ComHandler.SendTcp("[Request:PlayerList]");
}
public Context(CommunicationHandler commHandler)
{
this.commHandler = commHandler;
Monitor.Enter(commHandler.internalLock);
commHandler.counter++;
if (commHandler.counter > 1)
{
commHandler.stub.cpu.Log(LogLevel.Debug, "Gdb stub: entering nested communication context. All bytes will be queued.");
}
}
internal PluginEventHandler(string ipPort)
{
CommunicationHandler = new CommunicationHandler(ipPort, this);
Synapse.Api.Events.EventHandler.Get.Server.UpdateEvent += OnServerUpdateEvent;
Synapse.Api.Events.EventHandler.Get.Player.PlayerJoinEvent += OnPlayerJoinEvent;
Synapse.Api.Events.EventHandler.Get.Player.PlayerLeaveEvent += OnPlayerLeaveEvent;
Synapse.Api.Events.EventHandler.Get.Round.RoundEndEvent += OnRoundEndEvent;
Synapse.Api.Events.EventHandler.Get.Player.PlayerDeathEvent += OnPlayerDeathEvent;
Synapse.Api.Events.EventHandler.Get.Player.PlayerBanEvent += OnPlayerBanEvent;
}
public bool SendMessage(Message message)
{
bool temp = CommunicationHandler.SendMessage(message);
if (!temp)
{
RaisePropertyChanged("Connected");
RaisePropertyChanged("ConnectedString");
}
return(temp);
}
private async Task MainAsync()
{
Console.Title = "Syncord";
Console.WriteLine($"Syncord Plugin Version >>{Assembly.GetExecutingAssembly().GetName().Version}<<");
if (!Directory.Exists("logs"))
{
Directory.CreateDirectory("logs");
}
//Instantiate Logger
_logger = new LoggerConfiguration()
.WriteTo.Console()
.WriteTo.File("logs/log.txt",
rollingInterval: RollingInterval.Hour,
rollOnFileSizeLimit: true,
retainedFileCountLimit: 24)
.CreateLogger();
//Load Discord Bot Configs
LoadConfigs();
random = new Random();
PresenceString = BotConfig.DiscordActivity.Name;
_logger.Information($"Loaded Translation: {TranslationConfig.Translation.Language}.");
//Instantiate EasyHost
TcpServer = new SimpleTcpServer("0.0.0.0", BotConfig.Port);
TcpServer.Settings.StreamBufferSize = 16384;
await SetupDiscordClient();
//Adding Singletons of the Bot & EasyHost
_service = new ServiceCollection()
.AddSingleton(this)
.AddSingleton(TcpServer)
.BuildServiceProvider();
LoadCommands();
//Fire and forget
new Task(async() => await UpdatePresence()).Start();
//Instatiate CommunicationHandler
CommunicationHandler = new CommunicationHandler(TcpServer, this, _logger);
await CommunicationHandler.CreateChannelEmbedQueues();
await Task.Delay(-1);
}
public static void RegisterHandler(object Identification, object baseObject, CommunicationHandler funct)
{
KeyValuePair <object, object> key = new KeyValuePair <object, object>(Identification, baseObject);
if (RegisteredHandlers.ContainsKey(key))
{
RegisteredHandlers[key].Add(funct);
}
else
{
RegisteredHandlers.Add(key, new List <CommunicationHandler>());
RegisteredHandlers[key].Add(funct);
}
}
void RegisterExecute() // AMEND LATER
{
try
{
CommunicationHandler.Connect(Username, Password, true);
if (CommunicationHandler.Connected)
{
ns.Navigate(new Uri("Views/MessagingPage.xaml", UriKind.Relative));
}
}
catch (Exception e)
{
OutputString = e.Message;
}
}
public static void RegisterHandler(object Identification, object baseObject, CommunicationHandler funct)
{
if (RegisteredHandlers.ContainsKey(Identification))
{
RegisteredHandlers[Identification].Add(funct);
}
else
{
RegisteredHandlers.Add(Identification, new List <CommunicationHandler>());
RegisteredHandlers[Identification].Add(funct);
}
if (RegisteredObjects.ContainsKey(baseObject))
{
RegisteredObjects[baseObject].Add(Identification);
}
else
{
RegisteredObjects.Add(baseObject, new List <object>());
RegisteredObjects[baseObject].Add(Identification);
}
}
public GdbStub(Machine machine, IEnumerable <ICpuSupportingGdb> cpus, int port, bool autostartEmulation, bool blockOnStep)
{
this.cpus = cpus;
Port = port;
this.blockOnStep = blockOnStep;
LogsEnabled = true;
pcktBuilder = new PacketBuilder();
commandsManager = new CommandsManager(machine, cpus, blockOnStep);
commandsManager.ShouldAutoStart = autostartEmulation;
TypeManager.Instance.AutoLoadedType += commandsManager.Register;
terminal = new SocketServerProvider(false);
terminal.DataReceived += OnByteWritten;
terminal.ConnectionAccepted += delegate
{
commandsManager.CanAttachCPU = false;
foreach (var cpu in commandsManager.ManagedCpus.Values)
{
cpu.Halted += OnHalted;
cpu.ExecutionMode = blockOnStep ? ExecutionMode.SingleStepBlocking : ExecutionMode.SingleStepNonBlocking;
cpu.DebuggerConnected = true;
}
};
terminal.ConnectionClosed += delegate
{
foreach (var cpu in commandsManager.ManagedCpus.Values)
{
cpu.Halted -= OnHalted;
cpu.ExecutionMode = ExecutionMode.Continuous;
cpu.DebuggerConnected = false;
}
commandsManager.CanAttachCPU = true;
};
terminal.Start(port);
commHandler = new CommunicationHandler(this, commandsManager);
LogsEnabled = false;
}
//nakon što završi izrada softvera, potrebno je kolnikApp-komponente kompajlirati kao Release verziju, kao što je
//ujedno potrebno nakon njenog rebuildanja u projektu aplikacije za klijenta i poslužitelja referencirati .DLL
//iz Release foldera (drugi dio vise nije potreban jer se vrsi conditional referencing)
static void Main(string[] args)
{
SerialPort arduinoPort = new SerialPort();
arduinoPort.PortName = "COM5";
arduinoPort.BaudRate = 9600;
switch (args.Length)
{
case 2:
int baudRate;
if (!int.TryParse(args[1], out baudRate))
{
Console.WriteLine("Ako se već navodi drugi parametar, on mora biti cjelobrojna vrijednost");
return;
}
arduinoPort.BaudRate = baudRate;
goto case 2;
case 1:
switch (args[0])
{
case "\\h":
case "/h":
case "--h":
case "-h":
case "--help":
case "-help":
Console.WriteLine("Popis parametara:");
Console.WriteLine("\tnazivPorta - opcionalan (default: COM6)");
Console.WriteLine("\tbrojPulsevaUSekundi - opcionalan (default: 9600)");
return;
default:
arduinoPort.PortName = args[0];
break;
}
break;
default:
break;
}
try
{
arduinoPort.Open();
arduinoPort.DataReceived += CommunicationHandler.DataThroughSerialCommunicationHasBeenReceived;
DataHandler.ArduinoPort = arduinoPort;
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
CommunicationHandler uticnica = new CommunicationHandler();
do
{
Console.Write("> ");
string inputString = Console.ReadLine();
switch (inputString)
{
case "exit":
case "quit":
return;
case "retry":
try
{
arduinoPort.Open();
DataHandler.ArduinoPort = arduinoPort;
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
break;
case "calibrate low":
case "calibrate high":
case "calibrate default":
try
{
arduinoPort.WriteLine(inputString);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
break;
default:
Console.WriteLine("Command you've entered is not valid!");
break;
}
} while (true);
}
public string GetHubRoomExist(string roomName)
{
var exist = CommunicationHandler.GlobalInvokeFindRightHub("GetExistingRoom", roomName);
return(exist);
}
private void OnCommunicationHandler(object arg1, CommunicationEventArgs arg2)
{
CommunicationHandler?.Invoke(arg1, arg2);
}
/// <summary>
/// Konstruktor istoimene klase koji, naravno, instancira objekt navedene klase
/// </summary>
/// <param name="sockObj">Mrežna utičnica putem kojem se osluškuje mrežna sabirnica kao što se i lansiraju podaci prema njoj</param>
public Login(CommunicationHandler sockObj) : base(sockObj)
{
InitializeComponent();
loginUsingUsername = true;
}
public CommunicationHandlerTests()
{
_locationHelperProcessorMock = new Mock <ILocationHelperProcessor>();
_decoderServiceMock = new Mock <IDecoder>();
communicationHandler = new CommunicationHandler(_decoderServiceMock.Object, _locationHelperProcessorMock.Object);
}
public void ConnectToAvailableHub()
{
CommunicationHandler.SetAvailableHubConnection();
}
/// <summary>
/// Konstruktor bazne korisnički definirane klase forme gdje se definira mrežna utičnica putem koje će se vršiti mrežna komunikacija
/// </summary>
/// <param name="sockObj">Mrežna utičnica putem koje se vrši mrežna komunikacija u svim ostalim formama naslijeđenim od bazne</param>
protected PosrednaFormaZaDebugVerziju(CommunicationHandler sockObj) : base(sockObj)
{
}
public static IApplicationBuilder MapWebSocketManager(this IApplicationBuilder app,
PathString path,
CommunicationHandler handler)
{
return(app.Map(path, (_app) => _app.UseMiddleware <CommunicationMiddleware>(handler)));
}
public void CloseConnection()
{
CommunicationHandler.CloseConnection();
RaisePropertyChanged("Connected");
RaisePropertyChanged("ConnectedString");
}
public MTObservableCollection <User> ParseC010Message(string inputMessage)
{
return(CommunicationHandler.ParseC010Message(inputMessage));
}
private void ConnectToHub(string hubUrl)
{
CommunicationHandler.SetCurrentHubConnection(hubUrl);
}
public StateInitiator()
{
handler = new CommunicationHandler();
lines = new List <string>();
}
