public ListeningEntity FromBusinessEntity(Listening businessEntity)
{
if (businessEntity == null)
{
return(null);
}
ListeningEntity dataEntity = new ListeningEntity()
{
ID = businessEntity.ID,
ListenRating = businessEntity.ListenRating,
PrivateMarks = businessEntity.PrivateMarks,
Review = businessEntity.Review,
Comments = businessEntity.Comments,
Date = businessEntity.Date,
Album = new AlbumEntity()
{
ID = businessEntity.Album.ID
},
Mood = FromBusinessEntity(businessEntity.Mood),
Place = FromBusinessEntity(businessEntity.Place)
};
return(dataEntity);
}
public void OnProcessOutput(string line)
{
if (!IsListening && line.Trim().Contains("So, the first input will not be recognized."))
{
IsListening = true;
Listening?.Invoke();
}
else if (line.Trim().StartsWith("sentence1: <s> "))
{
IsPass1Recognizing = false;
IsPass1Complete = true;
Pass1Text = line.Replace("sentence1: <s> ", "").Replace("</s>", "").Trim();
Debug("Recognized text: {0}", Pass1Text);
Recognized?.Invoke(Pass1Text);
}
/*
* if (line.Trim().StartsWith("pass1_best"))
* {
* IsListening = false;
* IsPass1Recognizing = true;
* Pass1RecognizingOp = Begin("Recognizing");
* }
* else if (line.Trim().StartsWith("sentence1: <s> "))
* {
* Pass1RecognizingOp.Complete();
* IsPass1Recognizing = false;
* IsPass1Complete = true;
* Pass1Text = line.Replace("sentence1: <s> ", "").Replace("</s>", "").Trim();
* Info("Recognized text: {0}", Pass1Text);
* Info("Listening...");
* }*/
}
public bool SaveListening(Listening listening)
{
bool result = false;
ISession session = SessionFactory.GetSession();
ITransaction tx = session.BeginTransaction();
try
{
EntityConverter converter = new EntityConverter();
ListeningEntity dataEntity = converter.FromBusinessEntity(listening);
session.SaveOrUpdate(dataEntity);
tx.Commit();
listening.ID = dataEntity.ID;
result = true;
}
catch (Exception ex)
{
Logger.Write(ex);
tx.Rollback();
}
finally
{
session.Close();
tx.Dispose();
}
return(result);
}
public void Status(ConcurrentDictionary <string, string> dict)
{
try
{
dict.TryAdd("_Listening", Listening.ToString());
dict.TryAdd("Started", Started.ToString());
dict.TryAdd("TickTime", tickTime.ToString());
//dict.TryAdd("ByteReceivedPerSecond", ByteReceivedPerSecond.ToString());
//dict.TryAdd("ByteSendPerSecond", ByteSendPerSecond.ToString());
//dict.TryAdd("MessageReceivedPerSecond", MessageReceivedPerSecond.ToString());
//dict.TryAdd("MessageSendPerSecond", MessageSendPerSecond.ToString());
//dict.TryAdd("ConnectionCount", ConnectionCount.ToString());
//foreach (var agent in RankServer.Instance.Agents.ToArray())
//{
// dict.TryAdd(agent.Key + " Latency", agent.Value.Latency.ToString());
// dict.TryAdd(agent.Key + " ByteReceivedPerSecond", agent.Value.ByteReceivedPerSecond.ToString());
// dict.TryAdd(agent.Key + " ByteSendPerSecond", agent.Value.ByteSendPerSecond.ToString());
// dict.TryAdd(agent.Key + " MessageReceivedPerSecond", agent.Value.MessageReceivedPerSecond.ToString());
// dict.TryAdd(agent.Key + " MessageSendPerSecond", agent.Value.MessageSendPerSecond.ToString());
//}
}
catch (Exception ex)
{
Logger.Error(ex, "RankServerControl Status Error!{0}");
}
}
public bool RemoveListening(Listening listening)
{
bool result = false;
ISession session = SessionFactory.GetSession();
ITransaction tx = session.BeginTransaction();
try
{
ListeningEntity dataEntity = session.CreateCriteria <ListeningEntity>().
Add(Restrictions.Eq("ID", listening.ID)).UniqueResult <ListeningEntity>();
if (dataEntity != null)
{
session.Delete(dataEntity);
tx.Commit();
}
result = true;
}
catch (Exception ex)
{
Logger.Write(ex);
tx.Rollback();
}
finally
{
session.Close();
tx.Dispose();
}
return(result);
}
public IPagedList <Listening> GetListenings(ILoadOptions options)
{
IPagedList <Listening> result = new PagedList <Listening>();
if (options == null)
{
return(result);
}
if (options.MaxResults <= 0)
{
return(result);
}
ISession session = SessionFactory.GetSession();
try
{
DetachedCriteria countCriteria = GetListeningsImpl(options);
DetachedCriteria listCriteria = GetListeningsImpl(options);
countCriteria.SetProjection(Projections.RowCount());
countCriteria.ClearOrders();
listCriteria.
SetFirstResult(options.FirstResult).
SetMaxResults(options.MaxResults);
IMultiCriteria multiCriteria = session.CreateMultiCriteria();
multiCriteria.Add(countCriteria);
multiCriteria.Add(listCriteria);
IList queryResult = multiCriteria.List();
result.TotalItems = (int)((IList)queryResult[0])[0];
IList recordsList = (IList)queryResult[1];
EntityConverter entityConverter = new EntityConverter();
foreach (var e in recordsList)
{
ListeningEntity dataEntity = e as ListeningEntity;
Listening businessEntity = entityConverter.FromDataEntity(dataEntity);
result.Add(businessEntity);
}
}
catch (Exception ex)
{
Logger.Write(ex);
}
finally
{
session.Close();
}
return(result);
}
private void listening_Click(object sender, RoutedEventArgs e)
{
Listening Listening = new Listening();
Listening.WindowStartupLocation = System.Windows.WindowStartupLocation.CenterScreen;
this.Close();
Listening.Show();
}
private void OnAddListeningCommand(object parameter)
{
var newListening = new Listening()
{
NeedValidate = true
};
CreateOrViewListening(newListening, false);
}
internal void UpdateMembers()
{
Listening.ToList().ForEach(cl =>
{
if (!IsMember(cl))
{
Leave(cl);
}
});
}
public bool Join(Client player, int pin)
{
bool isNew = !ChannelMembers.Contains(player.GetCharacterId());
ChannelMembers.Add(player.GetCharacterId());
Listening.Add(player);
player.SetRadioChannel(ChannelFrequency);
Unmute(player, true);
return(true);
}
void OnGetLeaderboard(GetLeaderboardResult result)
{
foreach (PlayerLeaderboardEntry player in result.Leaderboard)
{
GameObject tempListing = Instantiate(listingPrefab, listingContainer);
Listening LL = tempListing.GetComponent <Listening>();
LL.Name.text = player.DisplayName;
LL.Score.text = player.StatValue.ToString();
Debug.Log(player.DisplayName + ": " + player.StatValue);
}
}
public void Unmute(Client player, bool silent = false)
{
if (Listening.Add(player))
{
if (!silent)
{
player.Message("Radio on.");
}
}
player.setData("RADIO_MODE", "on");
player.UpdateHUD();
}
public void Mute(Client player, bool silent = false)
{
if (Listening.TryRemove(player))
{
if (!silent)
{
player.Message("Radio off.");
}
}
Speaking.TryRemove(player);
player.setData("RADIO_MODE", "off");
player.UpdateHUD();
}
private void CreateOrViewListening(Listening listening, bool isViewMode)
{
var viewModel = container.Resolve <IListeningEditViewModel>();
viewModel.IsViewMode = isViewMode;
viewModel.Listening = listening;
DialogModeEnum mode = isViewMode ? DialogModeEnum.View : DialogModeEnum.Create;
var dialog = new CommonDialog()
{
DialogContent = new ListeningEditView(viewModel),
HeaderText = HeaderTextHelper.CreateHeaderText(typeof(Listening), mode)
};
dialog.ShowDialog();
}
public bool Leave(Client player, bool removeMember = true)
{
bool wasRemoved = false;
if (removeMember)
{
wasRemoved = ChannelMembers.Remove(player.GetCharacterId());
}
wasRemoved |= Listening.TryRemove(player);
Speaking.TryRemove(player);
if (wasRemoved)
{
player.SetRadioChannel(0);
player.resetData("RADIO_MODE");
player.UpdateHUD();
}
return(wasRemoved);
}
public Task ListenAsync(int port)
{
var ep = new IPEndPoint(IPAddress.Any, port);
_listener = new TcpListener(ep);
_listener.Start();
LocalEndPoint = _listener.LocalEndpoint?.ToNetEndPoint();
Listening?.Invoke(this, EventArgs.Empty);
return(Task.Factory
.StartNew(
ListenSocketsAsync,
CancellationToken.None,
TaskCreationOptions.LongRunning,
TaskScheduler.Default)
.Unwrap());
}
void OnGetLeaderboard(GetLeaderboardResult result)
{
int kol = 0, i = 1;
foreach (PlayerLeaderboardEntry player in result.Leaderboard)
{
kol++;
GameObject tempListing = Instantiate(listingPrefab, listingContainer);
Listening LL = tempListing.GetComponent <Listening>();
LL.Name.text = player.DisplayName;
LL.Score.text = player.StatValue.ToString();
switch (i)
{
case 1:
LL.Reward.text = "No reward";
i++;
break;
case 2:
LL.Reward.text = "No reward";
i++;
break;
case 3:
LL.Reward.text = "No reward";
i++;
break;
default:
LL.Reward.text = "No reward";
break;
}
Debug.Log(player.DisplayName + ": " + player.StatValue);
}
for (int k = 0; k < 10 - kol; k++)
{
GameObject tempListing = Instantiate(listingPrefab, listingContainer);
Listening LL = tempListing.GetComponent <Listening>();
LL.Name.text = "";
LL.Score.text = "";
LL.Reward.text = "";
}
}
/// <summary>
/// 启动服务
/// </summary>
/// <param name="localEndPoint"></param>
public bool Start(IPEndPoint localEndPoint)
{
try
{
ClientList.Clear();
_listenSocket = new Socket(localEndPoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
_listenSocket.Bind(localEndPoint);
// start the server with a listen backlog of 100 connections
_listenSocket.Listen(_maxConnectNum);
// post accepts on the listening socket
Listening?.Invoke(localEndPoint);
StartAccept(null);
return(true);
}
catch (Exception ex)
{
Error?.Invoke(ex);
return(false);
}
}
/// <summary>
///
/// </summary>
/// <param name="et"></param>
/// <param name="arg"></param>
private void CompleteProcessing(EventEntry entry)
{
switch (entry.Type)
{
case EventType.Connecting:
Connecting?.Invoke(this, ( int )entry.Argument);
break;
case EventType.Listening:
Listening?.Invoke(this, ( int )entry.Argument);
break;
case EventType.Connected:
Connected?.Invoke(this, ( int )entry.Argument);
break;
case EventType.Disconnected:
Disconnected?.Invoke(this, ( int )entry.Argument);
break;
case EventType.Terminated:
Terminated?.Invoke(this, EventArgs.Empty);
break;
case EventType.Sent:
Sent?.Invoke(this, (Tuple <byte [], Message>)entry.Argument);
break;
case EventType.Received:
Received?.Invoke(this, (Tuple <byte [], Message>)entry.Argument);
break;
case EventType.T3Timeout:
T3Timeout?.Invoke(this, ( Message )entry.Argument);
break;
default: break;
}
}
public IPEndPoint StartListening(IPAddress ipAddress)
{
var localEndPoint = new IPEndPoint(ipAddress, 0);
listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
try
{
listener.Bind(localEndPoint);
listener.Listen(100);
Listening?.Invoke(((IPEndPoint)listener.LocalEndPoint).Address.ToString(), ((IPEndPoint)listener.LocalEndPoint).Port);
var result = ((IPEndPoint)listener.LocalEndPoint);
Task.Run(() =>
{
try
{
while (true)
{
allDone.Reset();
listener.BeginAccept(new AsyncCallback(AcceptCallback), listener);
allDone.WaitOne();
}
}
catch (Exception ex)
{
Debug.WriteLine(ex.ToString());
}
});
return(result);
}
catch (Exception ex)
{
Debug.WriteLine(ex.ToString());
return(null);
}
}
public Listening FromDataEntity(ListeningEntity dataEntity)
{
if (dataEntity == null)
{
return(null);
}
Listening businessEntity = new Listening()
{
ID = dataEntity.ID,
Date = dataEntity.Date,
ListenRating = dataEntity.ListenRating,
PrivateMarks = dataEntity.PrivateMarks,
Review = dataEntity.Review,
Comments = dataEntity.Comments
};
businessEntity.Album = FromDataEntity(dataEntity.Album, AlbumConvertOptions.Small);
businessEntity.Mood = FromDataEntity(dataEntity.Mood, MoodConvertOptions.Short);
businessEntity.Place = FromDataEntity(dataEntity.Place, PlaceConvertOptions.Short);
return(businessEntity);
}
protected virtual void OnListening() => Listening?.Invoke();
public WebsocketConnection(int propertyId, string endpoint, bool silent)
{
_webSocket = new WebSocket(endpoint);
_webSocket.OnOpen += (s, e) =>
{
// Send init message
var initialRequest = new
{
type = "connection_request",
request_type = "connect_to_prop",
prop_id = propertyId
};
var json = JsonConvert.SerializeObject(initialRequest);
_webSocket.Send(json);
};
_webSocket.OnMessage += (s, e) =>
{
try
{
var message = (JObject)JsonConvert.DeserializeObject(e.Data);
var t = message["type"];
var tv = t.ToString();
var pn = message["value_name"];
var pnVv = pn.ToString();
if (tv == "property_update" &&
pnVv == "prop_number")
{
// Init reply arrived
var propertyId1 = int.Parse(message["value"].Value <string>());
if (!silent)
{
Console.WriteLine($"PropertyId is: \n{propertyId1}");
}
Listening?.Invoke(this, EventArgs.Empty);
}
OnMessage?.Invoke(this, new MessageEventArgs(message));
}
catch (Exception ex)
{
if (!silent)
{
Console.WriteLine($"{ex.Message}\n{ex.StackTrace}");
}
}
};
_webSocket.OnClose += (s, e) => { };
_webSocket.OnError += (s, e) =>
{
// F**k up
if (!silent)
{
Console.WriteLine(
$"Fuckup: {e.Message}, Ex: {e.Exception.Message + "\n" + e.Exception.StackTrace}");
}
throw e.Exception;
};
_webSocket.Connect();
}
private void OnListening()
{
Listening?.Invoke(this, EventArgs.Empty);
}
public bool RemoveListening(Listening listening)
{
DataProvider provider = new DataProvider();
return(provider.RemoveListening(listening));
}
static void Main(string[] args)
{
try
{
sContainer = new Container();
sContainer.Register <Logger>(Lifestyle.Singleton);
sContainer.Register <DatabaseConnection>(Lifestyle.Singleton);
sContainer.Register <LoginQueue>(Lifestyle.Singleton);
sContainer.Register <ConnectionManager>(Lifestyle.Singleton);
sContainer.Register <SystemManager>(Lifestyle.Singleton);
sContainer.RegisterInstance(General.LoadFromFile("configuration.conf", sContainer));
sContainer.Register <AccountDB>(Lifestyle.Singleton);
sContainer.Register <GeneralDB>(Lifestyle.Singleton);
sContainer.Register <SolarSystemDB>(Lifestyle.Singleton);
// disable auto-verification on the container as it triggers creation of instances before they're needed
sContainer.Options.EnableAutoVerification = false;
// setup logging
sLog = sContainer.GetInstance <Logger>();
// initialize main logging channel
sChannel = sLog.CreateLogChannel("main");
// add console log streams
sLog.AddLogStream(new ConsoleLogStream());
// load server's configuration
sConfiguration = sContainer.GetInstance <General>();
if (sConfiguration.LogLite.Enabled == true)
{
sLog.AddLogStream(new LogLiteStream("ClusterController", sLog, sConfiguration.LogLite));
}
if (sConfiguration.FileLog.Enabled == true)
{
sLog.AddLogStream(new FileLogStream(sConfiguration.FileLog));
}
// run a thread for log flushing
new Thread(() =>
{
while (true)
{
sLog.Flush();
Thread.Sleep(1);
}
}).Start();
sChannel.Info("Initializing EVESharp Cluster Controler and Proxy");
sChannel.Fatal("Initializing EVESharp Cluster Controler and Proxy");
sChannel.Error("Initializing EVESharp Cluster Controler and Proxy");
sChannel.Warning("Initializing EVESharp Cluster Controler and Proxy");
sChannel.Debug("Initializing EVESharp Cluster Controler and Proxy");
sChannel.Trace("Initializing EVESharp Cluster Controler and Proxy");
sConnectionManager = sContainer.GetInstance <ConnectionManager>();
// initialize system manager information
sContainer.GetInstance <SystemManager>().Init(sConnectionManager);
Listening listening = sContainer.GetInstance <Listening>();
try
{
sChannel.Trace($"Initializing server socket on port {listening.Port}...");
sServerSocket = new EVEServerSocket(listening.Port, sLog.CreateLogChannel("ServerSocket"));
sServerSocket.Listen();
sServerSocket.BeginAccept(acceptAsync);
sChannel.Debug($"Waiting for incoming connections on port {listening.Port}");
}
catch (Exception e)
{
sChannel.Error($"Error listening on port {listening.Port}: {e.Message}");
throw;
}
long lastPickedNodeID = 0;
while (true)
{
// sleep for ten minutes
Thread.Sleep(1000 * 60 * 10);
// check for any nodes available and pick one from the list to handle timed events
lock (sConnectionManager.Nodes)
{
// ignore the timed events if there's no nodes to handle them
if (sConnectionManager.Nodes.Count == 0)
{
continue;
}
// get the first available node and request it to handle the timed events
// TODO: ASSIGN SOME KIND OF LOAD INDICATION TO NODES TO ENSURE THAT ONLY LOW-LOADED ONES ARE USED?
NodeConnection node = null;
try
{
// get the next node available
node = sConnectionManager.Nodes.First(x => x.Key > lastPickedNodeID).Value;
}
catch (InvalidOperationException)
{
// no extra node was found, so the first one has to be used
node = sConnectionManager.Nodes.First().Value;
}
lastPickedNodeID = node.NodeID;
sConnectionManager.NotifyNode(lastPickedNodeID, "OnClusterTimer", new PyTuple(0));
sChannel.Info($"Requested node {lastPickedNodeID} to handle cluster-wide timed events");
}
}
}
catch (Exception e)
{
if (sLog is null || sChannel is null)
{
Console.WriteLine(e.ToString());
}
static void Main(string[] args)
{
try
{
sContainer = new Container();
sContainer.Register <Logger>(Lifestyle.Singleton);
sContainer.Register <DatabaseConnection>(Lifestyle.Singleton);
sContainer.Register <LoginQueue>(Lifestyle.Singleton);
sContainer.Register <ConnectionManager>(Lifestyle.Singleton);
sContainer.Register <SystemManager>(Lifestyle.Singleton);
sContainer.RegisterInstance(General.LoadFromFile("configuration.conf", sContainer));
sContainer.Register <AccountDB>(Lifestyle.Singleton);
sContainer.Register <GeneralDB>(Lifestyle.Singleton);
sContainer.Register <SolarSystemDB>(Lifestyle.Singleton);
// disable auto-verification on the container as it triggers creation of instances before they're needed
sContainer.Options.EnableAutoVerification = false;
// setup logging
sLog = sContainer.GetInstance <Logger>();
// initialize main logging channel
sChannel = sLog.CreateLogChannel("main");
// add console log streams
sLog.AddLogStream(new ConsoleLogStream());
// load server's configuration
sConfiguration = sContainer.GetInstance <General>();
if (sConfiguration.LogLite.Enabled == true)
{
sLog.AddLogStream(new LogLiteStream("ClusterController", sLog, sConfiguration.LogLite));
}
if (sConfiguration.FileLog.Enabled == true)
{
sLog.AddLogStream(new FileLogStream(sConfiguration.FileLog));
}
// run a thread for log flushing
new Thread(() =>
{
while (true)
{
sLog.Flush();
Thread.Sleep(1);
}
}).Start();
sChannel.Info("Initializing EVESharp Cluster Controler and Proxy");
sChannel.Fatal("Initializing EVESharp Cluster Controler and Proxy");
sChannel.Error("Initializing EVESharp Cluster Controler and Proxy");
sChannel.Warning("Initializing EVESharp Cluster Controler and Proxy");
sChannel.Debug("Initializing EVESharp Cluster Controler and Proxy");
sChannel.Trace("Initializing EVESharp Cluster Controler and Proxy");
sConnectionManager = sContainer.GetInstance <ConnectionManager>();
// initialize system manager information
sContainer.GetInstance <SystemManager>().Init(sConnectionManager);
Listening listening = sContainer.GetInstance <Listening>();
try
{
sChannel.Trace($"Initializing server socket on port {listening.Port}...");
sServerSocket = new EVEServerSocket(listening.Port, sLog.CreateLogChannel("ServerSocket"));
sServerSocket.Listen();
sServerSocket.BeginAccept(acceptAsync);
sChannel.Debug($"Waiting for incoming connections on port {listening.Port}");
}
catch (Exception e)
{
sChannel.Error($"Error listening on port {listening.Port}: {e.Message}");
throw;
}
while (true)
{
Thread.Sleep(1);
}
}
catch (Exception e)
{
if (sLog == null || sChannel == null)
{
Console.WriteLine(e.ToString());
}
else
{
sChannel?.Fatal(e.ToString());
sLog?.Flush();
}
}
}
public void ConnectionListening()
{
ListeningCount++;
Listening?.Invoke(this, EventArgs.Empty);
}
private void Form2_Load(object sender, EventArgs e)
{
server = new TcpListener(IPAddress.Any, port);
Listening.Start();
}
/// <summary>
/// Triggered when a listener is ready and listening
/// </summary>
/// <param name="receivedData">Byte array with the received data</param>
/// <param name="receivedDataAsText">Received data converted to hexadecimals</param>
/// <param name="client">The client instance on which the data has been received</param>///
private void HandleListening(Listener listener)
{
Listening?.Invoke(listener);
}
