public void UpdateWorldServer(string name, Uri location, RealmFlags flags, RealmCategory category, RealmType type, RealmStatus status,
int characterCount, int characterCapacity, Version clientVersion)
{
var id = OperationContext.Current.SessionId;
Contract.Assume(!string.IsNullOrEmpty(id));
Realm realm = null;
RealmManager.Instance.PostWait(mgr => realm = mgr.GetRealm(id)).Wait();
if (realm == null)
throw new InvalidOperationException("A realm has not registered before updating itself.");
RealmManager.Instance.PostAsync(() =>
{
realm.Name = name;
realm.Location = location;
realm.Flags = flags;
realm.Category = category;
realm.Type = type;
realm.Status = status;
realm.Population = characterCount;
realm.Capacity = characterCapacity;
realm.ClientVersion = clientVersion;
});
}
public void UpdateWorldServer(string name, Uri location, RealmFlags flags, RealmCategory category, RealmType type, RealmStatus status,
int characterCount, int characterCapacity, Version clientVersion)
{
Contract.Requires(!string.IsNullOrEmpty(name));
Contract.Requires(location != null);
Contract.Requires(characterCount >= 0);
Contract.Requires(characterCapacity >= 0);
Contract.Requires(clientVersion != null);
}
internal void OnStatusChange(RealmStatus oldStatus)
{
Instance.UpdateRealm();
var evt = StatusChanged;
if (evt != null)
{
evt(oldStatus);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="T:System.Object"/> class.
/// </summary>
public Realm(string realmName, RealmType serverType, RealmStatus serverStatus, RealmTimeZone timeZone,
RealmColor color, int maxPlayers)
{
RealmName = realmName;
ServerType = serverType;
ServerStatus = serverStatus;
TimeZone = timeZone;
Color = color;
MaxPlayers = maxPlayers;
}
internal void OnStatusChange(RealmStatus oldStatus)
{
Instance.UpdateRealm();
Action <RealmStatus> statusChanged = StatusChanged;
if (statusChanged == null)
{
return;
}
statusChanged(oldStatus);
}
static void Main(string[] args)
{
var realmStatus = new RealmStatus("wowApiEndpoint");
var response = realmStatus.GetStatus("Medivh,Blackrock");
foreach (var realm in response.Realms)
{
Console.WriteLine(string.Format("{0}, {1}", realm.Name, realm.Population));
}
Console.ReadKey();
}
internal void OnStatusChange(RealmStatus oldStatus)
{
ServerApp <WCell.RealmServer.RealmServer> .Instance.UpdateRealm();
Action <RealmStatus> statusChanged = this.StatusChanged;
if (statusChanged == null)
{
return;
}
statusChanged(oldStatus);
}
public void RegisterWorldServer(string name, Uri location, RealmFlags flags, RealmCategory category, RealmType type, RealmStatus status,
int characterCount, int characterCapacity, Version clientVersion)
{
var id = OperationContext.Current.SessionId;
Contract.Assume(!string.IsNullOrEmpty(id));
RealmManager.Instance.PostAsync(mgr => mgr.AddRealm(new Realm(id, name, location, clientVersion)
{
Flags = flags,
Category = category,
Type = type,
Status = status,
Population = characterCount,
Capacity = characterCapacity,
}));
}
private void FillListView(RealmStatus status)
{
if (status == null)
{
MessageBox.Show(String.Format("Failed to get realm status for region {0}", m_region));
return;
}
if (listView1.InvokeRequired)
{
listView1.Invoke(new AddListViewItem(FillListView), status);
}
else
{
listView1.Items.Clear();
listView1.BeginUpdate();
foreach (var realm in status.realms)
listView1.Items.Add(new ListViewItem(realm.ToStringArray()));
listView1.EndUpdate();
}
}
public static void HandleRealmList(WorldSession session, ClientRealmList realmList)
{
var serverRealmList = new ServerRealmList();
foreach (ServerInfo server in ServerManager.Instance.Servers)
{
RealmStatus status = RealmStatus.Up;
if (!server.IsOnline && server.Model.Id != WorldServer.RealmId)
{
status = RealmStatus.Down;
}
serverRealmList.Realms.Add(new ServerRealmList.RealmInfo
{
RealmId = server.Model.Id,
RealmName = server.Model.Name,
Type = (RealmType)server.Model.Type,
Status = status,
Population = RealmPopulation.Low,
Unknown8 = new byte[16],
AccountRealmInfo = new ServerRealmList.RealmInfo.AccountRealmData
{
RealmId = server.Model.Id
}
});
}
serverRealmList.Messages = ServerManager.Instance.ServerMessages
.Select(m => new NetworkMessage
{
Index = m.Index,
Messages = m.Messages
})
.ToList();
session.EnqueueMessageEncrypted(serverRealmList);
}
private void FillListView(RealmStatus status)
{
if (status == null)
{
MessageBox.Show(String.Format("Failed to get realm status for region {0}", m_client.Region));
return;
}
if (listView1.InvokeRequired)
{
listView1.Invoke(new AddListViewItem(FillListView), status);
}
else
{
listView1.Items.Clear();
listView1.BeginUpdate();
foreach (var realm in status.Realms)
{
listView1.Items.Add(new ListViewItem(realm.ToStringArray()));
}
listView1.EndUpdate();
}
}
internal async Task <List <string> > GetRealmListByRegion(Region region)
{
List <string> realmsNames = new List <string>();
string regionCoreAdress = string.Empty;
try
{
if (APIConf.BlizzadAPIAddressWrapper.TryGetValue(region, out regionCoreAdress) == false)
{
throw new KeyNotFoundException($"Cannot find region in {APIConf.BlizzadAPIAddressWrapper.GetType().Name} dictionary");
}
var requestLocalization = new RequestLocalization()
{
CoreRegionUrlAddress = regionCoreAdress,
};
RealmsRequests realmsRequests = new RealmsRequests(_comparerDatabaseContext);
var parameters = new List <KeyValuePair <string, string> >();
Uri uriAddress = RequestLinkFormater.GenerateAPIRequestLink(BlizzardAPIProfiles.Realm, requestLocalization, parameters, "status"); //TODO replace string
var realmResponse = await new APIDataRequestManager(_comparerDatabaseContext).GetDataByHttpRequest <BlizzardAPIResponse>(uriAddress);
RealmStatus realmStatus = JsonProcessing.DeserializeJsonData <RealmStatus>(realmResponse.Data);
foreach (Realm realmsData in realmStatus.Realms)
{
realmsNames.Add(realmsData.Name);
}
}
catch (Exception)
{
realmsNames = new List <string>();
}
return(realmsNames);
}
public void UpdateWorldServer(string name, Uri location, RealmFlags flags, RealmCategory category, RealmType type, RealmStatus status,
int characterCount, int characterCapacity, Version clientVersion)
{
Contract.Requires(!string.IsNullOrEmpty(name));
Contract.Requires(location != null);
Contract.Requires(characterCount >= 0);
Contract.Requires(characterCapacity >= 0);
Contract.Requires(clientVersion != null);
}
public void RegisterRealmServer(string realmName, string addr, int port, int chrCount, int capacity, RealmServerType serverType,
RealmFlags flags, RealmCategory serverCategory, RealmStatus serverStatus, ClientVersion version)
{
try
{
Channel.RegisterRealmServer(realmName, addr, port, chrCount, capacity, serverType, flags, serverCategory,
serverStatus, version);
}
catch (Exception e)
{
OnError(e);
}
}
public void UpdateWorldServer(string name, Uri location, RealmFlags flags, RealmCategory category, RealmType type, RealmStatus status,
int characterCount, int characterCapacity, Version clientVersion)
{
var id = OperationContext.Current.SessionId;
Contract.Assume(!string.IsNullOrEmpty(id));
Realm realm = null;
RealmManager.Instance.PostWait(mgr => realm = mgr.GetRealm(id)).Wait();
if (realm == null)
{
throw new InvalidOperationException("A realm has not registered before updating itself.");
}
RealmManager.Instance.PostAsync(() =>
{
realm.Name = name;
realm.Location = location;
realm.Flags = flags;
realm.Category = category;
realm.Type = type;
realm.Status = status;
realm.Population = characterCount;
realm.Capacity = characterCapacity;
realm.ClientVersion = clientVersion;
});
}
public void RegisterWorldServer(string name, Uri location, RealmFlags flags, RealmCategory category, RealmType type, RealmStatus status,
int characterCount, int characterCapacity, Version clientVersion)
{
var id = OperationContext.Current.SessionId;
Contract.Assume(!string.IsNullOrEmpty(id));
RealmManager.Instance.PostAsync(mgr => mgr.AddRealm(new Realm(id, name, location, clientVersion)
{
Flags = flags,
Category = category,
Type = type,
Status = status,
Population = characterCount,
Capacity = characterCapacity,
}));
}
/// <summary>
/// Updates this Realm's status at the AuthServer.
/// </summary>
/// <param name="serverName"></param>
/// <param name="serverType"></param>
/// <param name="flags"></param>
/// <param name="serverCategory"></param>
/// <param name="serverStatus"></param>
/// <returns></returns>
public bool UpdateRealmServer(string serverName, int chrCount, int capacity, RealmServerType serverType,
RealmFlags flags, RealmCategory serverCategory, RealmStatus serverStatus)
{
try
{
return(Channel.UpdateRealmServer(serverName, chrCount, capacity, serverType, flags, serverCategory,
serverStatus));
}
catch (Exception e) {
OnError(e);
return(false);
}
}
/// <summary>
/// Updates a realm server's entry in the realm list
/// </summary>
/// <param name="serverName">the name of the server</param>
/// <param name="serverType">the type of the server</param>
/// <param name="flags">the up/down status of the serer (green/red)</param>
/// <param name="serverCategory">the timezone the server is in</param>
/// <param name="serverStatus">the status of the server (locked or not)</param>
public bool UpdateRealmServer(string serverName, int chrCount, int capacity, RealmServerType serverType,
RealmFlags flags, RealmCategory serverCategory, RealmStatus serverStatus)
{
var realm = GetCurrentRealm();
if (realm == null)
{
return(false);
}
realm.Name = serverName;
realm.Flags = flags;
realm.Status = serverStatus;
realm.ServerType = serverType;
realm.Category = serverCategory;
realm.CharCount = chrCount;
realm.CharCapacity = capacity;
realm.LastUpdate = DateTime.Now;
//log.Debug(Resources.RealmUpdated, realm.Name);
return(true);
}
/// <summary>
/// Registers a realm server with the authentication server
/// </summary>
/// <param name="serverName">the name of the server</param>
/// <param name="serverType">the type of the server</param>
/// <param name="flags">the up/down status of the serer (green/red)</param>
/// <param name="serverCategory">the timezone the server is in</param>
/// <param name="serverStatus">the status of the server (locked or not)</param>
public void RegisterRealmServer(string serverName, string addr, int port, int chrCount, int capacity,
RealmServerType serverType, RealmFlags flags, RealmCategory serverCategory,
RealmStatus serverStatus, ClientVersion clientVersion)
{
var context = OperationContext.Current;
if (context == null)
{
return;
}
var channel = context.Channel;
if (channel == null)
{
return;
}
var id = GetCurrentId();
var realm = AuthenticationServer.GetRealmById(id);
var ep = GetCurrentEndPoint();
// find out whether this server is just re-registering (came back online)
var isNew = realm == null;
if (isNew)
{
realm = AuthenticationServer.GetRealmByName(serverName);
if (isNew = (realm == null))
{
if (!AuthServerConfiguration.RealmIPs.Contains(ep.Address))
{
// Ignore unknown realms
log.Warn("Unallowed Realm (\"{0}\") tried to register from: {1}", serverName, ep.Address);
var chan = OperationContext.Current.Channel;
if (chan != null)
{
try
{
chan.Close();
}
catch (Exception) {}
}
return;
}
realm = new RealmEntry();
}
realm.ChannelId = id;
}
if (string.IsNullOrEmpty(addr))
{
// no host given
addr = ep.Address;
}
realm.Name = serverName;
realm.Address = addr;
realm.Port = port;
realm.Flags = flags;
realm.Status = serverStatus;
realm.ServerType = serverType;
realm.Category = serverCategory;
realm.CharCount = chrCount;
realm.CharCapacity = capacity;
realm.ClientVersion = clientVersion;
realm.Channel = channel;
realm.ChannelAddress = ep.Address;
realm.ChannelPort = ep.Port;
if (isNew)
{
// register after setting all infos
lock (AuthenticationServer.Realms)
{
realm.ChannelId = id;
AuthenticationServer.Realms.Add(id, realm);
}
}
log.Info(Resources.RealmRegistered, realm); //realm.ChannelAddress);
}
/// <summary>
/// Registers a realm server with the authentication server
/// </summary>
/// <param name="realmName">the name of the server</param>
/// <param name="serverType">the type of the server</param>
/// <param name="flags">the up/down status of the serer (green/red)</param>
/// <param name="serverCategory">the timezone the server is in</param>
/// <param name="serverStatus">the status of the server (locked or not)</param>
public void RegisterRealmServer(string realmName, string addr, int port, int chrCount, int capacity,
RealmServerType serverType, RealmFlags flags, RealmCategory serverCategory,
RealmStatus serverStatus, ClientVersion clientVersion)
{
var context = OperationContext.Current;
if (context == null)
{
return;
}
var channel = context.Channel;
if (channel == null)
{
return;
}
var id = GetCurrentId();
var realm = AuthenticationServer.GetRealmById(id);
var ep = GetCurrentEndPoint();
string epAddress = "";
if(ep == null)
{
epAddress = channel.RemoteAddress.Uri.Host;
log.Warn("IPC::RegisterRealmServer Endpoint is null, falling back to: {0}", channel.RemoteAddress.Uri.Host);
}
else
{
epAddress = ep.Address;
log.Info("IPC::RegisterRealmServer Endpoint address is: {0}", ep.Address);
}
// find out whether this server is just re-registering (came back online)
var isNew = realm == null;
if (isNew)
{
realm = AuthenticationServer.GetRealmByName(realmName);
if (realm == null)
{
if (!AuthServerConfiguration.RealmIPs.Contains(epAddress))
{
// Ignore unknown realms
log.Warn("Unallowed Realm (\"{0}\") tried to register from: {1} (For more info, see the <RealmIPs> entry in your configuration)",
realmName, epAddress, AuthServerConfiguration.Instance.FilePath);
var chan = OperationContext.Current.Channel;
if (chan != null)
{
try
{
chan.Close();
}
catch (Exception) {}
}
return;
}
realm = new RealmEntry();
}
else
{
lock (AuthenticationServer.Realms)
{
AuthenticationServer.RemoveRealmByName(realmName);
}
}
}
if (string.IsNullOrEmpty(addr))
{
// no host given
addr = epAddress;
}
realm.ChannelId = id;
realm.Name = realmName;
realm.Address = addr;
realm.Port = port;
realm.Flags = flags;
realm.Status = serverStatus;
realm.ServerType = serverType;
realm.Category = serverCategory;
realm.CharCount = chrCount;
realm.CharCapacity = capacity;
realm.ClientVersion = clientVersion;
realm.Channel = channel;
realm.ChannelAddress = epAddress;
realm.ChannelPort = ep == null ? channel.RemoteAddress.Uri.Port : ep.Port;
if (isNew)
{
// register after setting all infos
lock (AuthenticationServer.Realms)
{
AuthenticationServer.AddRealm(realm);
}
}
log.Info(resources.RealmRegistered, realm); //realm.ChannelAddress);
}
private void OnStatusNameChange(RealmStatus status)
{
UpdateImportantChannels();
}
/// <summary>
/// Updates a realm server's entry in the realm list
/// </summary>
/// <param name="serverName">the name of the server</param>
/// <param name="serverType">the type of the server</param>
/// <param name="flags">the up/down status of the serer (green/red)</param>
/// <param name="serverCategory">the timezone the server is in</param>
/// <param name="serverStatus">the status of the server (locked or not)</param>
public bool UpdateRealmServer(string serverName, int chrCount, int capacity, RealmServerType serverType,
RealmFlags flags, RealmCategory serverCategory, RealmStatus serverStatus)
{
var realm = GetCurrentRealm();
if (realm == null)
{
return false;
}
realm.Name = serverName;
realm.Flags = flags;
realm.Status = serverStatus;
realm.ServerType = serverType;
realm.Category = serverCategory;
realm.CharCount = chrCount;
realm.CharCapacity = capacity;
realm.LastUpdate = DateTime.Now;
//log.Debug(Resources.RealmUpdated, realm.Name);
return true;
}
/// <summary>
/// Registers a realm server with the authentication server
/// </summary>
/// <param name="realmName">the name of the server</param>
/// <param name="serverType">the type of the server</param>
/// <param name="flags">the up/down status of the serer (green/red)</param>
/// <param name="serverCategory">the timezone the server is in</param>
/// <param name="serverStatus">the status of the server (locked or not)</param>
public void RegisterRealmServer(string realmName, string addr, int port, int chrCount, int capacity,
RealmServerType serverType, RealmFlags flags, RealmCategory serverCategory,
RealmStatus serverStatus, ClientVersion clientVersion)
{
var context = OperationContext.Current;
if (context == null)
{
return;
}
var channel = context.Channel;
if (channel == null)
{
return;
}
var id = GetCurrentId();
var realm = AuthenticationServer.GetRealmById(id);
var ep = GetCurrentEndPoint();
// find out whether this server is just re-registering (came back online)
var isNew = realm == null;
if (isNew)
{
realm = AuthenticationServer.GetRealmByName(realmName);
if (realm == null)
{
if (!AuthServerConfiguration.RealmIPs.Contains(ep.Address))
{
// Ignore unknown realms
log.Warn("Unallowed Realm (\"{0}\") tried to register from: {1} (For more info, see the <RealmIPs> entry in your configuration)",
realmName, ep.Address, AuthServerConfiguration.Instance.FilePath);
var chan = OperationContext.Current.Channel;
if (chan != null)
{
try
{
chan.Close();
}
catch (Exception) {}
}
return;
}
realm = new RealmEntry();
}
else
{
lock (AuthenticationServer.Realms)
{
AuthenticationServer.RemoveRealmByName(realmName);
}
}
}
if (string.IsNullOrEmpty(addr))
{
// no host given
addr = ep.Address;
}
realm.ChannelId = id;
realm.Name = realmName;
realm.Address = addr;
realm.Port = port;
realm.Flags = flags;
realm.Status = serverStatus;
realm.ServerType = serverType;
realm.Category = serverCategory;
realm.CharCount = chrCount;
realm.CharCapacity = capacity;
realm.ClientVersion = clientVersion;
realm.Channel = channel;
realm.ChannelAddress = ep.Address;
realm.ChannelPort = ep.Port;
if (isNew)
{
// register after setting all infos
lock (AuthenticationServer.Realms)
{
AuthenticationServer.AddRealm(realm);
}
}
log.Info(resources.RealmRegistered, realm); //realm.ChannelAddress);
}
