private void LogEvent(string event_name, ServerEventParameter[] param = null)
{
ServerEvent e = new ServerEvent(user_id, CurrentTimestamp(), game_name, event_name, param);
Debug.Log("logging event: " + event_name);
event_manager.LogEvent(e);
}
public void UpdateClientPositionOverride(INetworkingClient networkingClient, Vector3?position)
{
ServerEvent serverEvent;
if (position != null)
{
var clientPositionOverrideChangeEvent = new ClientPositionOverrideChangeEvent
{
PositionX = position.Value.X, PositionY = position.Value.Y, PositionZ = position.Value.Z
};
serverEvent = new ServerEvent {
ClientPositionOverrideChange = clientPositionOverrideChangeEvent
};
}
else
{
var clientPositionStopOverrideChangeEvent = new ClientPositionStopOverrideChangeEvent();
serverEvent = new ServerEvent
{
ClientPositionStopOverrideChange = clientPositionStopOverrideChangeEvent
};
}
var bytes = serverEvent.ToByteArray();
lock (networkingClient)
{
if (networkingClient.Exists)
{
networkingClient.WebSocket?.SendAsync(bytes, true);
}
}
}
/// <summary>
/// Creates the script from all the specified parts.
/// </summary>
/// <param name="serverEvent">The server event.</param>
/// <param name="request">if set to <c>true</c> this is a DICOM request message otherwise it is a response.</param>
/// <param name="userScript">The user created script.</param>
/// <param name="se">The ScriptEngine.</param>
/// <returns>A valid VBScript class file.</returns>
public string CreateScript(ServerEvent serverEvent, string userScript, ScriptEngine se, out int lineCount)
{
StringBuilder sb = new StringBuilder();
Match match = _MethodFinder.Match(userScript);
List <string> methods = new List <string>();
string additionalMethods = string.Empty;
while (match.Success)
{
string method = ExtractMethod(ref userScript, match);
if (method.Length > 0)
{
methods.Add(method);
}
match = _MethodFinder.Match(userScript);
}
additionalMethods = string.Join(@"\n", methods.ToArray());
sb.Append(se.Namespaces);
sb.Append("\n\n");
sb.Append(_ScriptHeader);
sb.Append(ScriptFunctions.GetScript(serverEvent));
sb.Append("\n\n");
lineCount = sb.ToString().Count(c => c == '\n');
sb.Append(userScript);
sb.Append("\n");
sb.Append(string.Format(_ScriptFooter, _Additional + @"
" + additionalMethods));
return(sb.ToString());
}
void onConnectToConnector()
{
ServerEvent.onChat(delegate(ServerEvent.onChat_event ret)
{
string strMsg = string.Format("{0} : {1}.", ret.from, ret.msg);
if (text)
{
text.text = text.text.Insert(text.text.Length, strMsg);
text.text = text.text.Insert(text.text.Length, "\n");
}
});
ServerEvent.onAdd(delegate(ServerEvent.onAdd_event msg)
{
string strMsg = string.Format("{0} Joined.", msg.user);
if (text)
{
text.text = text.text.Insert(text.text.Length, strMsg);
text.text = text.text.Insert(text.text.Length, "\n");
}
});
ServerEvent.onLeave(delegate(ServerEvent.onLeave_event msg)
{
string strMsg = string.Format("{0} Leaved.", msg.user);
if (text)
{
text.text = text.text.Insert(text.text.Length, strMsg);
text.text = text.text.Insert(text.text.Length, "\n");
}
});
login();
}
private async Task CheckIfRemoteServerAlreadySavedAsync(ServerEvent serverEvent)
{
if (_state.DoNotRequestServerInfo)
{
return;
}
var exists = SharedFunctions.CheckIfRemoteServerAlreadySaved(
_state.LocalServer.MyInfo,
serverEvent.RemoteServerIpAddress,
serverEvent.RemoteServerPortNumber,
_state.Settings.RemoteServers);
if (exists)
{
return;
}
_state.DoNotRequestServerInfo = true;
_state.DoNotRefreshMainMenu = true;
_state.PromptUserForServerName = false;
await
SharedFunctions.RequestServerInfoAsync(
_state,
serverEvent.RemoteServerIpAddress,
serverEvent.RemoteServerPortNumber);
_state.DoNotRequestServerInfo = false;
_state.DoNotRefreshMainMenu = false;
}
public void CreateEntity(INetworkingEntity networkingEntity)
{
if (networkingEntity.StreamingType == StreamingType.EntityStreaming)
{
return;
}
byte[] bytes;
if (networkingEntity.StreamingType == StreamingType.DataStreaming)
{
// Remove data before sending it over the wire
var entityWithoutData = networkingEntity.StreamedEntity.Clone();
entityWithoutData.Data.Clear();
var entityCreateEvent = new EntityCreateEvent {
Entity = entityWithoutData
};
var serverEvent = new ServerEvent {
Create = entityCreateEvent
};
bytes = serverEvent.ToByteArray();
}
else
{
var entityCreateEvent = new EntityCreateEvent {
Entity = networkingEntity.StreamedEntity
};
var serverEvent = new ServerEvent {
Create = entityCreateEvent
};
bytes = serverEvent.ToByteArray();
}
AltNetworking.Module.ClientPool.SendToAll(bytes);
}
static void Main(string[] args)
{
var builder = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.json", optional: true)
.AddJsonFile("appsettings.local.json", optional: true)
.AddCommandLine(args);
var configurationRoot = builder.Build();
var serverAdress = configurationRoot["address"];
var serverPort = int.Parse(configurationRoot["port"]);
var password = configurationRoot["password"];
var soldatClient = new SoldatClient(new PacketParser());
soldatClient.Connect(serverAdress, serverPort, password);
while (true)
{
ServerEvent serverEvent = soldatClient.ReadNextEvent().Result;
Console.WriteLine(serverEvent);
var jsonServerEvent = JsonConvert.SerializeObject(serverEvent);
File.AppendAllText("output.json", ",\r\n" + jsonServerEvent);
Thread.Sleep(500);
}
}
public IHttpActionResult PutServerEvent(int id, ServerEvent serverEvent)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != serverEvent.ServerEventId)
{
return(BadRequest());
}
serverEvent.UpTimes = serverEvent.UpTimes.HasValue ? serverEvent.UpTimes.Value.Date : serverEvent.UpTimes;
Context.Entry(serverEvent).State = EntityState.Modified;
try
{
Context.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!ServerEventExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public async override Task <SubscribeResponseMessage> SubscribeService(SubscribeRequestMessage request, ServerCallContext context)
{
bool response;
try
{
var serverInfo = new ServerInfo
{
Id = request.ServerId,
Host = request.ServerHost
};
messageBrokerPersistance.Add(serverInfo);
var serverEvent = new ServerEvent
{
Url = request.ServerHost
};
await queueService.Enqueue(serverEvent);
Console.WriteLine($">> New server added: {serverInfo.Id} and host {serverInfo.Host} <<");
response = true;
}
catch (Exception)
{
response = false;
}
return(await Task.FromResult(new SubscribeResponseMessage
{
Success = response
}));
}
async Task ReceiveFileBytesCompleteAsync(ServerEvent serverEvent)
{
var fileSize = serverEvent.FileSizeInBytes;
var startTime = serverEvent.FileTransferStartTime;
var completeTime = serverEvent.FileTransferCompleteTime;
var timeElapsed = (completeTime - startTime).ToFormattedString();
var transferRate = serverEvent.FileTransferRate;
_state.ProgressBar.BytesReceived = fileSize;
_state.ProgressBar.Report(1);
Thread.Sleep(Constants.OneHalfSecondInMilliseconds);
var report =
Environment.NewLine + Environment.NewLine +
$"Download Started...: {startTime:MM/dd/yyyy hh:mm:ss.fff tt}{Environment.NewLine}" +
$"Download Finished..: {completeTime:MM/dd/yyyy hh:mm:ss.fff tt}{Environment.NewLine}" +
$"Elapsed Time.......: {timeElapsed}{Environment.NewLine}" +
$"Transfer Rate......: {transferRate}";
Console.WriteLine(report);
_state.SignalReturnToMainMenu.Set();
TearDownProgressBar();
await Task.Delay(Constants.OneHalfSecondInMilliseconds).ConfigureAwait(false);
_state.SignalReturnToMainMenu.WaitOne();
}
void ReceivedServerInfo(ServerEvent serverEvent)
{
var serverInfo = new ServerInfo
{
TransferFolder = serverEvent.RemoteFolder,
PublicIpAddress = serverEvent.PublicIpAddress,
LocalIpAddress = serverEvent.LocalIpAddress,
SessionIpAddress = serverEvent.RemoteServerIpAddress,
PortNumber = serverEvent.RemoteServerPortNumber,
Platform = serverEvent.RemoteServerPlatform
};
if (_state.PromptUserForServerName)
{
_state.SelectedServerInfo = serverInfo;
SharedFunctions.DisplayLocalServerInfo(_state);
_state.SelectedServerInfo.Name =
SharedFunctions.SetSelectedServerName(_state, _state.SelectedServerInfo);
_state.WaitingForUserToConfirmServerDetails = false;
}
_state.Settings.RemoteServers.Add(serverInfo);
_state.SaveSettingsToFile();
_state.WaitingForServerInfoResponse = false;
}
public void UpdateEntityData(INetworkingEntity entity, string key, MValue value)
{
lock (entity.StreamedInClients)
{
if (entity.StreamedInClients.Count <= 0)
{
return;
}
var entityDataChangeEvent = new EntityDataChangeEvent {
Id = entity.Id, Key = key, Value = value
};
var serverEvent = new ServerEvent {
DataChange = entityDataChangeEvent
};
var bytes = serverEvent.ToByteArray();
foreach (var streamedInClient in entity.StreamedInClients)
{
lock (streamedInClient)
{
if (streamedInClient.Exists)
{
streamedInClient.WebSocket?.SendAsync(bytes, true);
}
}
}
}
}
public void Log <TState>(LogLevel logLevel, EventId eventId, TState state, Exception exception, Func <TState, Exception, string> formatter)
{
if (!IsEnabled(logLevel))
{
return;
}
if (formatter == null)
{
throw new ArgumentNullException(nameof(formatter));
}
var message = formatter(state, exception);
if (string.IsNullOrEmpty(message))
{
return;
}
if (exception != null)
{
message += "\n" + exception;
}
message = message.Length > MessageMaxLength?message.Substring(0, MessageMaxLength) : message;
ServerEvent serverEvent = new ServerEvent
{
Message = message,
EventId = eventId.Id,
LogLevel = (int)logLevel,
Time = DateTime.Now
};
_helper.InsertLog(serverEvent);
}
/// <summary>
/// При подключении клиента
/// </summary>
void OnClientConnect(NetworkMessage msg)
{
if (_connectionId == -1)
{
_connectionId = msg.conn.connectionId;
ServerEvent.ClientConnected(msg);
}
}
public void Parse_AuthRevoked_ShouldParseProperly()
{
// Act
var parsedEvent = ServerEvent.Parse("event: auth_revoked", "data: sorry m8, you auth was revoked");
// Assert
Assert.AreEqual(parsedEvent.Type, ServerEventType.AuthRevoked);
Assert.IsNull(parsedEvent.Data);
}
public void Parse_Cancel_ShouldParseProperly()
{
// Act
var parsedEvent = ServerEvent.Parse("event: cancel", "null");
// Assert
Assert.AreEqual(parsedEvent.Type, ServerEventType.Cancel);
Assert.IsNull(parsedEvent.Data);
}
public EntityServiceImpl()
{
universe = new Universe();
universe.Add(new BehaviorProcessor());
runner = new Runner();
runner.Universe = universe;
running = runner.Run();
universe.Stepped += (s, e) =>
{
var se = new ServerEvent();
foreach (var entity in universe.Entities)
{
var pc = entity.GetComponent <PhysicsComponent>();
var ec = entity.GetComponent <EntityComponent>();
se.Entities.Add(new Proto.Entity
{
Id = entity.Identifier.ToString(),
Position = ProtoConverter.Convert(pc.Body.LinearPosition),
Velocity = ProtoConverter.Convert(pc.Body.LinearVelocity),
Rotation = ProtoConverter.Convert(pc.Body.AngularPosition),
Class = ec?.Class ?? ""
});
}
// Console.WriteLine("Emitting " + se.Entities.Count);
foreach (var writer in writers)
{
writer.Value.WriteAsync(se);
}
};
for (int i = 0; i < 10; i++)
{
var bloid = new SimulationEntity();
bloid.Components.Add(new TransformComponent
{
Scaling = new Vector3(0.2f, 0.2f, 0.2f)
});
bloid.Components.Add(new BehaviorComponent());
bloid.Components.Add(new PhysicsComponent(new Body
{
LinearPosition = Functions.Random.NextVector3(-10, 10),
LinearVelocity = Functions.Random.NextVector3(-10, 10),
AngularPosition = Functions.Random.NextQuaternion()
}));
bloid.Components.Add(new EntityComponent {
Class = "ai"
});
universe.Add(bloid);
}
}
public void Parse_KeepAlive_ShouldParseProperly()
{
// Act
var parsedEvent = ServerEvent.Parse("event: keep-alive", "null");
// Assert
Assert.AreEqual(parsedEvent.Type, ServerEventType.KeepAlive);
Assert.IsNull(parsedEvent.Data);
}
protected virtual void OnEventOccurred(ServerEvent serverEvent)
{
// Make a temporary copy of the event to avoid possibility of
// a race condition if the last subscriber unsubscribes
// immediately after the null check and before the event is raised.
var handler = EventOccurred;
handler?.Invoke(this, serverEvent);
}
/// <summary>
/// Initializes a server response hanlder
/// </summary>
private void InitializeEventHandlerSecure()
{
// Start a background thread
Task.Run(() =>
{
try
{
// Continiously try and see if there's any data avaiilable
while (true)
{
// Read the first 8 bytes so we know the size of the request
byte[] sizeBuffer = new byte[8];
int readBytes = _secureStream.Read(sizeBuffer, 0, 8);
if (readBytes == 0)
{
Debugger.Break();
return;
}
;
// Get request size and read the request entirely without needing to call Read() multiple times
int requestSize = GetRequestSize(sizeBuffer);
byte[] buffer = new byte[requestSize];
readBytes = _secureStream.Read(buffer);
// If the client sent a message to the server and is expecting a result
if (_handleReceivedEvents == false)
{
// If we reached here, all data was read. Deserilize the data to a ServerEvent
NetworkMessage networkMessage = _serializer.Deserialize <NetworkMessage>(buffer);
_receviedResponse = () => networkMessage;
_manualResetEvent.Set();
// Don't handle *this request
continue;
}
// If we reached here, all data was read. Deserilize the data to a ServerEvent
ServerEvent serverEvent = _serializer.Deserialize <ServerEvent>(buffer);
// Handle the received server event
DelegateReceivedEvent(serverEvent);
}
;
}
catch (IOException ioException)
{
_client.Close();
_secureStream.Close();
}
});
}
private void Awake()
{
if (singleton == null)
{
singleton = this;
}
if (PlayerChange == null)
{
PlayerChange = new ServerEvent();
}
}
public IHttpActionResult GetServerEvent(int id)
{
ServerEvent serverEvent = Context.ServerEvents.Find(id);
if (serverEvent == null)
{
return(NotFound());
}
return(Ok(serverEvent));
}
private async Task SaveServerEventInDatabase(string description, EventType eventType, Server server)
{
var serverPowerEvent = new ServerEvent
{
CreatedAt = DateTime.Now,
EventType = eventType,
Description = description,
ServerId = server.Id
};
await _unitOfWork.ServerEvents.Insert(serverPowerEvent);
}
void HandleFileTransferProgress(object sender, ServerEvent serverEvent)
{
if (_state.OutboundFileTransferInProgress)
{
return;
}
_state.InboundFileTransferId = serverEvent.FileTransferId;
_state.ProgressBar.BytesReceived = serverEvent.TotalFileBytesReceived;
_state.ProgressBar.Report(serverEvent.PercentComplete);
}
/// <summary>
/// Handle an event.
/// </summary>
/// <param name="ev">The event type.</param>
/// <param name="data">The event data.</param>
public void Handle(ServerEvent ev, EventData data = null)
{
if (!events.TryGetValue(ev, out var handlers))
{
return;
}
foreach (Action <EventData> handler in handlers)
{
handler(data);
}
}
public bool InsertLog(ServerEvent log)
{
string command = @"INSERT INTO [dbo].[ServerLog] ([EventID],[LogLevel],[Message],[Time]) VALUES (@EventID, @LogLevel, @Message, @Time)";
List<SqlParameter> paramList = new List<SqlParameter>
{
new SqlParameter("EventID", log.EventId),
new SqlParameter("LogLevel", log.LogLevel),
new SqlParameter("Message", log.Message),
new SqlParameter("Time", log.Time)
};
return ExecuteNonQuery(command, paramList);
}
public void EventCreator(string commandType, string action)
{
ISenderService logManager = new SenderService();
ServerEvent eventToLog = new ServerEvent
{
EventType = commandType,
LogBody = action,
Time = DateTime.Now
};
logManager.CreateApiLog(eventToLog);
}
public void UpdateClientDimension(INetworkingClient networkingClient, int dimension)
{
var clientDimensionChangeEvent = new ClientDimensionChangeEvent {
Dimension = dimension
};
var serverEvent = new ServerEvent {
ClientDimensionChange = clientDimensionChangeEvent
};
var bytes = serverEvent.ToByteArray();
networkingClient.WebSocket.SendAsync(bytes, true);
}
public void UpdateEntityPosition(Entity.Entity entity, Position position)
{
var entityPositionChangeEvent = new EntityPositionChangeEvent {
Id = entity.Id, Position = position
};
var serverEvent = new ServerEvent {
PositionChange = entityPositionChangeEvent
};
var bytes = serverEvent.ToByteArray();
AltNetworking.Module.ClientPool.SendToAll(bytes);
}
public void UpdateEntityRange(Entity.Entity entity, float range)
{
var entityRangeChangeEvent = new EntityRangeChangeEvent {
Id = entity.Id, Range = range
};
var serverEvent = new ServerEvent {
RangeChange = entityRangeChangeEvent
};
var bytes = serverEvent.ToByteArray();
AltNetworking.Module.ClientPool.SendToAll(bytes);
}
public void multiple_listeners_get_the_events_when_new_events_are_written_to_the_channel()
{
var task1 = theChannel.FindEvents(null);
var task2 = theChannel.FindEvents(null);
var task3 = theChannel.FindEvents(null);
var e1 = new ServerEvent("1", "data-1");
var e2 = new ServerEvent("2", "data-2");
var e3 = new ServerEvent("3", "data-3");
theChannel.Write(q =>
{
q.Write(e1, e2, e3);
});
task1.Result.ShouldHaveTheSameElementsAs(e1, e2, e3);
task2.Result.ShouldHaveTheSameElementsAs(e1, e2, e3);
task3.Result.ShouldHaveTheSameElementsAs(e1, e2, e3);
}
public void multiple_listeners_at_different_places_in_their_queue()
{
var task1 = theChannel.FindEvents(new FakeTopic{LastEventId = "1"});
var task2 = theChannel.FindEvents(new FakeTopic{LastEventId = "2"});
var task3 = theChannel.FindEvents(null);
var e1 = new ServerEvent("1", "data-1");
var e2 = new ServerEvent("2", "data-2");
var e3 = new ServerEvent("3", "data-3");
theChannel.Write(q =>
{
q.Write(e1, e2, e3);
});
task1.Result.ShouldHaveTheSameElementsAs(e2, e3);
task2.Result.ShouldHaveTheSameElementsAs(e3);
task3.Result.ShouldHaveTheSameElementsAs(e1, e2, e3);
}
public void find_events_that_are_already_published()
{
var e1 = new ServerEvent("1", "data-1");
var e2 = new ServerEvent("2", "data-2");
var e3 = new ServerEvent("3", "data-3");
theChannel.Write(q =>
{
q.Write(e1, e2, e3);
});
var task1 = theChannel.FindEvents(new FakeTopic { LastEventId = "1" });
var task2 = theChannel.FindEvents(new FakeTopic { LastEventId = "2" });
var task3 = theChannel.FindEvents(null);
task1.Result.ShouldHaveTheSameElementsAs(e2, e3);
task2.Result.ShouldHaveTheSameElementsAs(e3);
task3.Result.ShouldHaveTheSameElementsAs(e1, e2, e3);
}
public void disconnected_channel_returns_empty_enumerable()
{
var e1 = new ServerEvent("1", "data-1");
var e2 = new ServerEvent("2", "data-2");
var e3 = new ServerEvent("3", "data-3");
theChannel.Write(q =>
{
q.Write(e1, e2, e3);
});
theChannel.Flush();
theChannel.IsConnected().ShouldBeFalse();
var task = theChannel.FindEvents(null);
task.Wait(150).ShouldBeTrue();
task.Result.ShouldHaveCount(0);
}
public static void CancelEvent(ServerEvent e)
{
}
public static bool IsEventCancled(ServerEvent e)
{
return false;
}
private void OnServerEvent(ServerEvent evt)
{
switch (evt.Event)
{
case "Test run start":
RefreshContainer(string.Format("Test run started for {0}", Name));
break;
case "Test run requested":
if (IsValid && _refreshing)
{
_refreshing = false;
Tests = evt.Tests.ToList();
if (AutoRun)
{
Discoverer.RunTests();
}
}
break;
}
}
/// <summary>
/// Cancel a server event
/// </summary>
/// <param name="e">The event you want to cancel</param>
public static void CancelServerEvent(ServerEvent e)
{
switch (e)
{
case ServerEvent.ConsoleCommand:
Server.cancelcommand = true;
break;
case ServerEvent.ServerAdminLog:
Server.canceladmin = true;
break;
case ServerEvent.ServerLog:
Server.cancellog = true;
break;
case ServerEvent.ServerOpLog:
Server.canceloplog = true;
break;
}
}
