public void Add_Duplicate()
{
var manager = new ConnectionManager();
var peer = new Peer {
Id = aId
};
var a = new PeerConnection {
RemotePeer = peer, Stream = Stream.Null
};
var b = new PeerConnection {
RemotePeer = peer, Stream = Stream.Null
};
Assert.AreSame(a, manager.Add(a));
Assert.IsTrue(manager.IsConnected(peer));
Assert.AreEqual(1, manager.Connections.Count());
Assert.IsNotNull(a.Stream);
Assert.AreSame(b, manager.Add(b));
Assert.IsTrue(manager.IsConnected(peer));
Assert.AreEqual(2, manager.Connections.Count());
Assert.IsNotNull(a.Stream);
Assert.IsNotNull(b.Stream);
manager.Clear();
Assert.AreEqual(0, manager.Connections.Count());
Assert.IsNull(a.Stream);
Assert.IsNull(b.Stream);
}
public void Add_Duplicate_ExistingIsDead()
{
var address = "/ip6/::1/tcp/4007";
var manager = new ConnectionManager();
var peer = new Peer {
Id = aId, ConnectedAddress = address
};
var a = new PeerConnection {
RemotePeer = peer, RemoteAddress = address, Stream = Stream.Null
};
var b = new PeerConnection {
RemotePeer = peer, RemoteAddress = address, Stream = Stream.Null
};
Assert.AreSame(a, manager.Add(a));
Assert.IsTrue(manager.IsConnected(peer));
Assert.AreEqual(1, manager.Connections.Count());
Assert.IsNotNull(a.Stream);
Assert.AreEqual(address, peer.ConnectedAddress);
a.Stream = null;
Assert.AreSame(b, manager.Add(b));
Assert.IsTrue(manager.IsConnected(peer));
Assert.AreEqual(1, manager.Connections.Count());
Assert.IsNull(a.Stream);
Assert.IsNotNull(b.Stream);
Assert.AreEqual(address, peer.ConnectedAddress);
}
public void TestMultipleConnectionOpenAsyncByCancellationToken()
{
var cm = ConnectionManager.Add(_conn, "um");
Assert.IsTrue(cm.State == ConnectionState.Closed);
var counter = 0;
var n = 100000;
var ct = new CancellationToken();
Parallel.For(0, n, async i =>
{
//counter += i;
Interlocked.Add(ref counter, i);
await cm.OpenAsync(ct);
Assert.IsTrue(cm.State == ConnectionState.Open);
cm.Close();
Assert.IsTrue(cm.State == ConnectionState.Closed);
});
var sum = n * (n - 1) / 2;
Assert.AreEqual(counter, sum, string.Format("Counter:{0} , Sum:{1}", counter, sum));
}
public void Add()
{
ConnectionManager.Add("mysql", ConstantUtil.PGSQL_CONNECTION, false);
ConnectionManager.Add("mysql", ConstantUtil.PGSQL_CONNECTION, true);
Assert.Equal(1, ConnectionManager.dict.Keys.Count);
Assert.Equal(2, ConnectionManager.dict["mysql"].Count);
}
public void ShouldNotDuplicateKeys()
{
var manager = new ConnectionManager();
var userKey = Guid.NewGuid().ToString();
var connectionId = Guid.NewGuid().ToString();
var username = "******";
manager.Add(userKey, connectionId, username);
var isNewKey = manager.Add(userKey, connectionId, username);
Assert.IsFalse(isNewKey);
Assert.AreEqual(manager.KeyCount, 1);
var connectionCount = manager.GetConnections(userKey).Count();
Assert.AreEqual(connectionCount, 1);
}
public void Maintains_PeerConnectedAddress()
{
var address1 = "/ip4/127.0.0.1/tcp/4007";
var address2 = "/ip4/127.0.0.2/tcp/4007";
var manager = new ConnectionManager();
var peer = new Peer {
Id = aId
};
var a = new PeerConnection {
RemotePeer = peer, RemoteAddress = address1, Stream = Stream.Null
};
var b = new PeerConnection {
RemotePeer = peer, RemoteAddress = address2, Stream = Stream.Null
};
Assert.AreSame(a, manager.Add(a));
Assert.IsTrue(manager.IsConnected(peer));
Assert.AreEqual(1, manager.Connections.Count());
Assert.IsNotNull(a.Stream);
Assert.AreEqual(address1, peer.ConnectedAddress);
Assert.AreSame(b, manager.Add(b));
Assert.IsTrue(manager.IsConnected(peer));
Assert.AreEqual(2, manager.Connections.Count());
Assert.IsNotNull(a.Stream);
Assert.IsNotNull(b.Stream);
Assert.AreEqual(address1, peer.ConnectedAddress);
Assert.IsTrue(manager.Remove(a));
Assert.IsTrue(manager.IsConnected(peer));
Assert.AreEqual(1, manager.Connections.Count());
Assert.IsNull(a.Stream);
Assert.IsNotNull(b.Stream);
Assert.AreEqual(address2, peer.ConnectedAddress);
Assert.IsTrue(manager.Remove(b));
Assert.IsFalse(manager.IsConnected(peer));
Assert.AreEqual(0, manager.Connections.Count());
Assert.IsNull(a.Stream);
Assert.IsNull(b.Stream);
Assert.IsNull(peer.ConnectedAddress);
}
public static Site NewConnection([Localizable(false)][NotNull] string hostName, [NotNull] string userName, [CanBeNull] ConnectionFolderTreeViewItem parent)
{
Assert.ArgumentNotNull(hostName, nameof(hostName));
Assert.ArgumentNotNull(userName, nameof(userName));
var connection = new Connection
{
UserName = userName,
Password = @"b",
HostName = hostName
};
var site = new Site(connection);
var dialog = new SiteEditor();
dialog.Load(site);
if (AppHost.Shell.ShowDialog(dialog) != true)
{
return(null);
}
var oldSite = FindSite(site.HostName, site.UserName);
if (oldSite != null)
{
AppHost.Sites.Disconnect(oldSite);
}
if (parent != null)
{
connection.FileName = ConnectionManager.GetFileName(connection, parent.Folder);
}
Add(site);
ConnectionManager.Add(site.Connection);
ConnectionManager.Save();
CreateSiteTreeViewItem(site, parent);
Notifications.RaiseSiteAdded(site, site);
var editor = dialog.DataServiceEditor as WebServiceSiteEditor;
if (editor != null)
{
if (editor.AutomaticUpdate.IsChecked == true)
{
UpdateServerComponentsDialog.AutomaticUpdate(site.DataService, site.Name, site.WebRootPath, site);
}
}
return(site);
}
public void Refresh(string name, string master, params string[] slaves)
{
NpgsqlConnection.ClearAllPools();
ConnectionManager.Remove(name);
ConnectionManager.Add(name, master, false);
if (slaves?.Length > 0)
{
foreach (var conn in slaves)
{
ConnectionManager.Add(name, conn, true);
}
}
}
public void IsConnected()
{
var manager = new ConnectionManager();
var peer = new Peer {
Id = aId
};
var connection = new PeerConnection {
RemotePeer = peer, Stream = Stream.Null
};
Assert.IsFalse(manager.IsConnected(peer));
manager.Add(connection);
Assert.IsTrue(manager.IsConnected(peer));
}
private void SaveButton_Click(object sender, EventArgs e)
{
ArduinoConnection conn = new ArduinoConnection()
{
FriendlyName = nameField.Text,
IpAddress = IPField.Text,
Port = (int)PortField.Value,
Password = PasswordField.Text,
ConnectionClass = ThrusterLayout.TL2
};
connectionManager.Add(conn);
Close();
}
private static void UpgradeFromRegistry()
{
var n = 0;
var blowFish = new BlowFish(BlowFish.CipherKey);
while (n < 99)
{
var siteName = AppHost.Settings.Get(StorageKey, "site" + n, null) as string;
if (string.IsNullOrEmpty(siteName))
{
break;
}
var server = AppHost.Settings.Get(StorageKey, "server" + n, string.Empty) as string ?? string.Empty;
var folder = AppHost.Settings.Get(StorageKey, "folder" + n, string.Empty) as string ?? string.Empty;
var userName = AppHost.Settings.Get(StorageKey, "userName" + n, string.Empty) as string ?? string.Empty;
var useWindowsAuth = AppHost.Settings.GetBool(StorageKey, "useWindowsAuth" + n, false);
var password = AppHost.Settings.Get(StorageKey, "encryptedpassword" + n, string.Empty) as string ?? string.Empty;
var dataServiceName = AppHost.Settings.Get(StorageKey, "dataservicename" + n, string.Empty) as string ?? string.Empty;
if (!string.IsNullOrEmpty(password))
{
password = blowFish.Decrypt_ECB(password);
}
else
{
password = AppHost.Settings.Get(StorageKey, "password" + n, string.Empty) as string ?? string.Empty;
}
var connection = new Connection
{
UserName = userName,
Password = password,
HostName = server,
DataServiceName = dataServiceName,
WebRootPath = folder,
Description = siteName,
UseWindowsAuth = useWindowsAuth
};
ConnectionManager.Add(connection);
n++;
}
ConnectionManager.Save();
ConnectionManager.Clear();
FavoriteManager.Clear();
Storage.Delete(StorageKey);
}
private void btnSave_Click(object sender, EventArgs e)
{
ConnectionManager.Add(currentConnection, currentConnection.Name);
ConnectionManager.SetToDefaultConnection(currentConnection.Name);
Task.Run(async() =>
{
await WriteTextToDiskAsync(ConfigPath, currentConnection.ToString(true));
await ConnectionManager.GetDefaultConnection().CheckDbConnectionAsync();
});
this.DialogResult = DialogResult.OK;
this.Close();
}
public void TestAddFind()
{
//
// Test Add and Find
//
var c1 = ConnectionManager.Add(_conn, "um");
var c2 = ConnectionManager.Find("um");
Assert.AreEqual(c1.ConnectionString, c2.ConnectionString);
//
// Test Search Connection by Ignore Case Name
//
Assert.IsNotNull(ConnectionManager.Find("UM"));
Assert.IsNotNull(ConnectionManager.Find("um"));
Assert.IsNotNull(ConnectionManager.Find("uM"));
Assert.IsNotNull(ConnectionManager.Find("Um"));
}
public void LoadConfigFile()
{
Task.Run(async() =>
{
if (File.Exists(DatabaseConfigurationForm.ConfigPath))
{
var config = await DatabaseConfigurationForm.ReadTextAsync(DatabaseConfigurationForm.ConfigPath);
var conn = Connection.Parse(config);
txtConnStr.Text = conn.ConnectionString;
ConnectionManager.Add(conn, conn.Name);
ConnectionManager.SetToDefaultConnection(conn.Name);
await ConnectionManager.GetDefaultConnection().CheckDbConnectionAsync();
}
});
}
public void PeerDisconnectedEvent_ConnectionClose()
{
var gotEvent = 0;
var manager = new ConnectionManager();
manager.PeerDisconnected += (s, e) => gotEvent += 1;
var peerA = new Peer {
Id = aId
};
var a = new PeerConnection {
RemotePeer = peerA, Stream = Stream.Null
};
manager.Add(a);
a.Dispose();
Assert.AreEqual(1, gotEvent);
}
public void ShouldRemoveLastConnectionAndKey()
{
var manager = new ConnectionManager();
var userKey = Guid.NewGuid().ToString();
var connectionId = Guid.NewGuid().ToString();
var username = "******";
manager.Add(userKey, connectionId, username);
var keyRemoved = manager.Remove(userKey, connectionId);
Assert.IsTrue(keyRemoved);
var connectionExist = manager.GetConnections(userKey).Contains(connectionId);
Assert.IsFalse(connectionExist);
}
public void ShouldAddNewKeyAndConnection()
{
var manager = new ConnectionManager();
var userKey = Guid.NewGuid().ToString();
var connectionId = Guid.NewGuid().ToString();
var username = "******";
var isNewUser = manager.Add(userKey, connectionId, username);
Assert.IsTrue(isNewUser);
Assert.IsTrue(manager.Exist(userKey));
var user = manager.GetUser(userKey);
Assert.AreEqual(user.Id, userKey);
Assert.IsTrue(user.Connections.Contains(connectionId));
Assert.AreEqual(user.Username, username);
}
public void PeerDisconnectedEvent_RemovingPeer()
{
var gotEvent = false;
var manager = new ConnectionManager();
manager.PeerDisconnected += (s, e) => gotEvent = true;
var peerA = new Peer {
Id = aId
};
var a = new PeerConnection {
RemotePeer = peerA, Stream = Stream.Null
};
manager.Add(a);
manager.Remove(peerA.Id);
Assert.IsTrue(gotEvent);
}
public static async void Start(Connection conn)
{
ConnectionManager.Add(conn, "ErrorControlSystemConnection");
ConnectionManager.SetToDefaultConnection("ErrorControlSystemConnection");
await ServerTransmitter.InitialTransmitterAsync();
if (ErrorHandlingOption.EnableNetworkSending && ConnectionManager.GetDefaultConnection().IsReady)
{
var publicSetting = await ServerTransmitter.SqlServerManager.GetErrorHandlingOptionsAsync();
if (publicSetting != 0)
{
ErrorHandlingOption.SetSetting(publicSetting);
}
await CacheController.CheckStateAsync();
}
}
public async Task <Player> CreatePlayer(
string name,
PlayerType type,
string connectionId,
bool playVsComputer,
ComputerLevel computerLevel)
{
if (_connectionManager.Count > 1)
{
throw new SetupException("Maximum number of players already in the game!");
}
var player = new Player(name, type);
_connectionManager.Add(player.Id, connectionId);
_playerManager.AddPlayerToGame(player);
switch (playVsComputer, _connectionManager.Count)
{
public void Remove_PeerId()
{
var manager = new ConnectionManager();
var peer = new Peer {
Id = aId
};
var a = new PeerConnection {
RemotePeer = peer, Stream = Stream.Null
};
manager.Add(a);
Assert.IsTrue(manager.IsConnected(peer));
Assert.AreEqual(1, manager.Connections.Count());
Assert.IsNotNull(a.Stream);
Assert.IsTrue(manager.Remove(peer.Id));
Assert.IsFalse(manager.IsConnected(peer));
Assert.AreEqual(0, manager.Connections.Count());
Assert.IsNull(a.Stream);
}
public void IsConnected_NotActive()
{
var manager = new ConnectionManager();
var peer = new Peer {
Id = aId
};
var connection = new PeerConnection {
RemotePeer = peer, Stream = Stream.Null
};
Assert.IsFalse(manager.IsConnected(peer));
manager.Add(connection);
Assert.IsTrue(manager.IsConnected(peer));
Assert.AreEqual(1, manager.Connections.Count());
connection.Stream = null;
Assert.IsFalse(manager.IsConnected(peer));
Assert.AreEqual(0, manager.Connections.Count());
}
public void AddURL(string url, bool isActive = false)
{
if (url.Length == 0)
{
return;
}
var isSupport = false;
var plugins = pluginManager.Parent.Where(x => x is IPluginSender).ToArray();
foreach (var plugin in plugins)
{
var @interface = pluginManager.CreateInstance(plugin) as IPluginSender;
@interface.PluginLoad();
if (@interface.IsSupport(url) && pluginManager.FirstOrDefault(x => x is IPluginSender sender && sender.StreamKey.Equals(@interface.StreamKey)) is null)
{
var info = new ConnectionData()
{
Plugin = @interface,
IsActive = new(false),
StreamKey = @interface.StreamKey,
URL = url
};
connectionManager.Add(info);
OnLogged(this, new(LogLevel.Info, $"URLを追加しました。[{url}]"));
if (isActive)
{
Activate(info);
}
pluginManager.Add(@interface);
isSupport = true;
break;
}
public void TestXml()
{
//
// Convert connections to XML
//
ConnectionManager.Add(_conn, "um");
ConnectionManager.Add(_connJustTrueServer, "test");
var xmlConnections = ConnectionManager.SaveToXml();
var xmlConnectionsEncrypted = ConnectionManager.SaveToXml(true);
ConnectionManager.ClearAll();;
Assert.IsTrue(ConnectionManager.Count == 0);
ConnectionManager.LoadFromXml(xmlConnections);
Assert.IsTrue(ConnectionManager.Count == 2);
ConnectionManager.ClearAll();
Assert.IsTrue(ConnectionManager.Count == 0);
ConnectionManager.LoadFromXml(xmlConnectionsEncrypted);
Assert.IsTrue(ConnectionManager.Count == 2);
}
public static Site CreateSite([NotNull] string hostName, [NotNull] string userName, [NotNull] string password, [NotNull] string dataServiceName, [NotNull] string webRootPath)
{
Assert.ArgumentNotNull(hostName, nameof(hostName));
Assert.ArgumentNotNull(userName, nameof(userName));
Assert.ArgumentNotNull(password, nameof(password));
Assert.ArgumentNotNull(dataServiceName, nameof(dataServiceName));
Assert.ArgumentNotNull(webRootPath, nameof(webRootPath));
var site = FindSite(hostName, userName);
if (site != null)
{
return(site);
}
var connection = new Connection
{
UserName = userName,
Password = password,
HostName = hostName,
DataServiceName = dataServiceName,
WebRootPath = webRootPath,
};
connection.FileName = ConnectionManager.GetFileName(connection);
ConnectionManager.Add(connection);
ConnectionManager.Save();
site = new Site(connection);
Add(site);
CreateSiteTreeViewItem(site, null);
Notifications.RaiseSiteAdded(site, site);
return(site);
}
private static async Task RequestReceived(HttpContext ctx)
{
string header = _Header + ctx.Request.SourceIp + ":" + ctx.Request.SourcePort + " ";
DateTime startTime = DateTime.Now;
Stopwatch sw = new Stopwatch();
sw.Start();
RequestMetadata md = new RequestMetadata();
md.Http = ctx;
md.User = null;
md.Key = null;
md.Perm = null;
try
{
if (Common.IsTrue(_Settings.Debug.HttpRequest))
{
_Logging.Debug(header + "RequestReceived request received: " + Environment.NewLine + md.Http.ToString());
}
if (ctx.Request.Method == HttpMethod.OPTIONS)
{
await OptionsHandler(ctx);
return;
}
if (ctx.Request.RawUrlEntries != null && ctx.Request.RawUrlEntries.Count > 0)
{
if (ctx.Request.RawUrlWithoutQuery.Equals("/favicon.ico"))
{
ctx.Response.StatusCode = 200;
await ctx.Response.Send();
return;
}
if (ctx.Request.RawUrlWithoutQuery.Equals("/robots.txt"))
{
ctx.Response.StatusCode = 200;
ctx.Response.ContentType = "text/plain";
await ctx.Response.Send("User-Agent: *\r\nDisallow:\r\n");
return;
}
}
if (ctx.Request.RawUrlEntries == null || ctx.Request.RawUrlEntries.Count == 0)
{
ctx.Response.StatusCode = 200;
ctx.Response.ContentType = "text/html";
await ctx.Response.Send(DefaultPage("http://github.com/kvpbase"));
return;
}
_ConnMgr.Add(Thread.CurrentThread.ManagedThreadId, ctx);
string apiKeyVal = ctx.Request.RetrieveHeaderValue(_Settings.Server.HeaderApiKey);
UserMaster user = null;
ApiKey apiKey = null;
AuthResult authResult = AuthResult.None;
Permission effectivePermissions = null;
if (!String.IsNullOrEmpty(apiKeyVal))
{
if (!_AuthMgr.Authenticate(apiKeyVal, out user, out apiKey, out effectivePermissions, out authResult))
{
_Logging.Warn("RequestReceived unable to verify API key " + apiKeyVal + ": " + authResult);
ctx.Response.StatusCode = 401;
ctx.Response.ContentType = "application/json";
await ctx.Response.Send(Common.SerializeJson(new ErrorResponse(3, 401, null, null), true));
return;
}
}
md.User = user;
md.Key = apiKey;
md.Perm = effectivePermissions;
md.Params = RequestMetadata.Parameters.FromHttpRequest(ctx.Request);
if (md.User != null)
{
md.Params.UserGuid = md.User.GUID;
}
_ConnMgr.Update(Thread.CurrentThread.ManagedThreadId, md.User);
await UserApiHandler(md);
return;
}
catch (Exception e)
{
_Logging.Exception("StorageServer", "RequestReceived", e);
ctx.Response.StatusCode = 500;
ctx.Response.ContentType = "application/json";
await ctx.Response.Send(Common.SerializeJson(new ErrorResponse(1, 500, "Outer exception.", null), true));
return;
}
finally
{
sw.Stop();
_ConnMgr.Close(Thread.CurrentThread.ManagedThreadId);
string msg =
header +
ctx.Request.Method + " " + ctx.Request.RawUrlWithoutQuery + " " +
ctx.Response.StatusCode + " " +
"[" + sw.ElapsedMilliseconds + "ms]";
_Logging.Debug(msg);
}
}
static HttpResponse RequestHandler(HttpRequest req)
{
DateTime startTime = DateTime.Now;
HttpResponse resp = null;
Host currHost = null;
Node currNode = null;
string hostKey = null;
bool connAdded = false;
try
{
#region Unauthenticated-APIs
switch (req.Method)
{
case HttpMethod.GET:
if (WatsonCommon.UrlEqual(req.RawUrlWithoutQuery, "/_loadbalancer/loopback", false))
{
resp = new HttpResponse(req, true, 200, null, "application/json", "Hello from LoadBalancer!", false);
return(resp);
}
break;
case HttpMethod.PUT:
case HttpMethod.POST:
case HttpMethod.DELETE:
default:
break;
}
#endregion
#region Add-to-Connection-List
_Connections.Add(Thread.CurrentThread.ManagedThreadId, req);
connAdded = true;
#endregion
#region Authenticate-and-Admin-APIs
if (!String.IsNullOrEmpty(req.RetrieveHeaderValue(_Settings.Auth.AdminApiKeyHeader)))
{
if (req.RetrieveHeaderValue(_Settings.Auth.AdminApiKeyHeader).Equals(_Settings.Auth.AdminApiKey))
{
#region Admin-APIs
_Logging.Log(LoggingModule.Severity.Info, "RequestHandler use of admin API key detected for: " + req.RawUrlWithoutQuery);
switch (req.Method)
{
case HttpMethod.GET:
if (WatsonCommon.UrlEqual(req.RawUrlWithoutQuery, "/_loadbalancer/connections", false))
{
resp = new HttpResponse(req, true, 200, null, "application/json", _Connections.GetActiveConnections(), false);
return(resp);
}
if (WatsonCommon.UrlEqual(req.RawUrlWithoutQuery, "/_loadbalancer/config", false))
{
resp = new HttpResponse(req, true, 200, null, "application/json", _Settings, false);
return(resp);
}
if (WatsonCommon.UrlEqual(req.RawUrlWithoutQuery, "/_loadbalancer/hosts", false))
{
resp = new HttpResponse(req, true, 200, null, "application/json", _Hosts.Get(), false);
return(resp);
}
break;
case HttpMethod.PUT:
case HttpMethod.POST:
case HttpMethod.DELETE:
default:
break;
}
_Logging.Log(LoggingModule.Severity.Warn, "RequestHandler unknown admin API endpoint: " + req.RawUrlWithoutQuery);
resp = new HttpResponse(req, false, 400, null, "application/json", "Unknown API endpoint or verb", false);
return(resp);
#endregion
}
else
{
#region Failed-Auth
_Logging.Log(LoggingModule.Severity.Warn, "RequestHandler invalid admin API key supplied: " + req.RetrieveHeaderValue(_Settings.Auth.AdminApiKeyHeader));
resp = new HttpResponse(req, false, 401, null, "application/json", "Authentication failed", false);
return(resp);
#endregion
}
}
#endregion
#region Find-Host-and-Node
if (req.Headers.ContainsKey("Host"))
{
hostKey = req.RetrieveHeaderValue("Host");
}
if (String.IsNullOrEmpty(hostKey))
{
_Logging.Log(LoggingModule.Severity.Warn, "RequestHandler no host header supplied for " + req.SourceIp + ":" + req.SourceIp + " " + req.Method + " " + req.RawUrlWithoutQuery);
resp = new HttpResponse(req, false, 400, null, "application/json", "No host header supplied", false);
return(resp);
}
if (!_Hosts.SelectNodeForHost(hostKey, out currHost, out currNode))
{
_Logging.Log(LoggingModule.Severity.Warn, "RequestHandler host or node not found for " + req.SourceIp + ":" + req.SourceIp + " " + req.Method + " " + req.RawUrlWithoutQuery);
resp = new HttpResponse(req, false, 400, null, "application/json", "Host or node not found", false);
return(resp);
}
else
{
if (currHost == null || currHost == default(Host))
{
_Logging.Log(LoggingModule.Severity.Warn, "RequestHandler host not found for " + req.SourceIp + ":" + req.SourceIp + " " + req.Method + " " + req.RawUrlWithoutQuery);
resp = new HttpResponse(req, false, 400, null, "application/json", "Host not found", false);
return(resp);
}
if (currNode == null || currNode == default(Node))
{
_Logging.Log(LoggingModule.Severity.Warn, "RequestHandler node not found for " + req.SourceIp + ":" + req.SourceIp + " " + req.Method + " " + req.RawUrlWithoutQuery);
resp = new HttpResponse(req, false, 400, null, "application/json", "No node found for host", false);
return(resp);
}
_Connections.Update(Thread.CurrentThread.ManagedThreadId, hostKey, currHost.Name, currNode.Hostname);
}
#endregion
#region Process-Connection
if (currHost.HandlingMode == HandlingMode.Redirect)
{
#region Redirect
string redirectUrl = BuildProxyUrl(currNode, req);
// add host header
Dictionary <string, string> requestHeaders = new Dictionary <string, string>();
// add other headers
if (req.Headers != null && req.Headers.Count > 0)
{
List <string> matchHeaders = new List <string> {
"host", "connection", "user-agent"
};
foreach (KeyValuePair <string, string> currHeader in req.Headers)
{
if (matchHeaders.Contains(currHeader.Key.ToLower().Trim()))
{
continue;
}
else
{
requestHeaders.Add(currHeader.Key, currHeader.Value);
}
}
}
// process REST request
RestResponse restResp = RestRequest.SendRequestSafe(
redirectUrl,
req.ContentType,
req.Method.ToString(),
null, null, false,
Common.IsTrue(currHost.AcceptInvalidCerts),
requestHeaders,
req.Data);
if (restResp == null)
{
_Logging.Log(LoggingModule.Severity.Warn, "RequestHandler null proxy response from " + redirectUrl);
resp = new HttpResponse(req, false, 500, null, "application/json", "Unable to contact node", false);
return(resp);
}
else
{
resp = new HttpResponse(req, true, restResp.StatusCode, restResp.Headers, restResp.ContentType, restResp.Data, true);
return(resp);
}
#endregion
}
else if (currHost.HandlingMode == HandlingMode.Proxy)
{
#region Proxy
string redirectUrl = BuildProxyUrl(currNode, req);
Dictionary <string, string> redirectHeaders = new Dictionary <string, string>();
redirectHeaders.Add("location", redirectUrl);
resp = new HttpResponse(req, true, _Settings.RedirectStatusCode, redirectHeaders, "text/plain", _Settings.RedirectStatusString, true);
return(resp);
#endregion
}
else
{
#region Unknown-Handling-Mode
_Logging.Log(LoggingModule.Severity.Warn, "RequestHandler invalid handling mode " + currHost.HandlingMode + " for host " + currHost.Name);
resp = new HttpResponse(req, false, 500, null, "application/json", "Invalid handling mode '" + currHost.HandlingMode + "'", false);
return(resp);
#endregion
}
#endregion
}
catch (Exception e)
{
_Logging.LogException("LoadBalancer", "RequestHandler", e);
resp = new HttpResponse(req, false, 500, null, "application/json", "Internal server error", false);
return(resp);
}
finally
{
if (resp != null)
{
string message = "RequestHandler " + req.SourceIp + ":" + req.SourcePort + " " + req.Method + " " + req.RawUrlWithoutQuery;
if (currNode != null)
{
message += " " + hostKey + " to " + currNode.Hostname + ":" + currNode.Port + " " + currHost.HandlingMode;
}
message += " " + resp.StatusCode + " " + Common.TotalMsFrom(startTime) + "ms";
_Logging.Log(LoggingModule.Severity.Debug, message);
}
if (connAdded)
{
_Connections.Close(Thread.CurrentThread.ManagedThreadId);
}
}
}
static HttpResponse RequestHandler(HttpRequest req)
{
DateTime startTime = DateTime.Now;
HttpResponse resp = null;
bool connAdded = false;
try
{
#region Unauthenticated-APIs
switch (req.Method)
{
case HttpMethod.GET:
if (WatsonCommon.UrlEqual(req.RawUrlWithoutQuery, "/loopback", false))
{
resp = new HttpResponse(req, true, 200, null, "application/json", "Hello from CryptoServer!", false);
return(resp);
}
break;
case HttpMethod.PUT:
case HttpMethod.POST:
case HttpMethod.DELETE:
default:
break;
}
#endregion
#region Add-to-Connection-List
_Connections.Add(Thread.CurrentThread.ManagedThreadId, req);
connAdded = true;
#endregion
#region APIs
if (!String.IsNullOrEmpty(req.RetrieveHeaderValue(_Settings.Auth.ApiKeyHeader)))
{
if (req.RetrieveHeaderValue(_Settings.Auth.ApiKeyHeader).Equals(_Settings.Auth.AdminApiKey))
{
#region Admin-API-Key
_Logging.Log(LoggingModule.Severity.Info, "RequestHandler use of admin API key detected for: " + req.RawUrlWithoutQuery);
switch (req.Method)
{
case HttpMethod.GET:
if (WatsonCommon.UrlEqual(req.RawUrlWithoutQuery, "/_cryptoserver/connections", false))
{
resp = new HttpResponse(req, true, 200, null, "application/json", _Connections.GetActiveConnections(), false);
return(resp);
}
if (WatsonCommon.UrlEqual(req.RawUrlWithoutQuery, "/_cryptoserver/config", false))
{
resp = new HttpResponse(req, true, 200, null, "application/json", _Settings, false);
return(resp);
}
break;
case HttpMethod.PUT:
case HttpMethod.POST:
case HttpMethod.DELETE:
default:
break;
}
_Logging.Log(LoggingModule.Severity.Warn, "RequestHandler unknown admin API endpoint: " + req.RawUrlWithoutQuery);
resp = new HttpResponse(req, false, 400, null, "application/json", "Unknown API endpoint or verb", false);
return(resp);
#endregion
}
else if (req.RetrieveHeaderValue(_Settings.Auth.ApiKeyHeader).Equals(_Settings.Auth.CryptoApiKey))
{
#region Crypto-API-Key
string failureReason;
byte[] responseData;
Obj responseObj;
switch (req.Method)
{
case HttpMethod.POST:
if (WatsonCommon.UrlEqual(req.RawUrlWithoutQuery, "/decrypt", false))
{
Obj reqObj = Common.DeserializeJson <Obj>(req.Data);
if (!_Crypto.Decrypt(reqObj, out responseData, out failureReason))
{
_Logging.Log(LoggingModule.Severity.Warn, "RequestHandler unable to decrypt: " + failureReason);
resp = new HttpResponse(req, false, 500, null, "application/json", failureReason, false);
return(resp);
}
else
{
_Logging.Log(LoggingModule.Severity.Debug, "RequestHandler encrypt returning " + responseData.Length + " bytes");
resp = new HttpResponse(req, true, 200, null, "application/octet-stream", responseData, true);
return(resp);
}
}
if (WatsonCommon.UrlEqual(req.RawUrlWithoutQuery, "/encrypt", false))
{
if (!_Crypto.Encrypt(req.Data, out responseObj, out failureReason))
{
_Logging.Log(LoggingModule.Severity.Warn, "RequestHandler unable to encrypt: " + failureReason);
resp = new HttpResponse(req, false, 500, null, "application/json", failureReason, false);
return(resp);
}
else
{
resp = new HttpResponse(req, true, 200, null, "application/json", Common.SerializeJson(responseObj), true);
return(resp);
}
}
break;
case HttpMethod.GET:
case HttpMethod.PUT:
case HttpMethod.DELETE:
default:
break;
}
_Logging.Log(LoggingModule.Severity.Warn, "RequestHandler unknown crypto API endpoint: " + req.RawUrlWithoutQuery);
resp = new HttpResponse(req, false, 400, null, "application/json", "Unknown API endpoint or verb", false);
return(resp);
#endregion
}
else
{
#region Invalid-Auth-Material
_Logging.Log(LoggingModule.Severity.Warn, "RequestHandler invalid API key supplied: " + req.RetrieveHeaderValue(_Settings.Auth.ApiKeyHeader));
resp = new HttpResponse(req, false, 401, null, "application/json", "Invalid API key", false);
return(resp);
#endregion
}
}
resp = new HttpResponse(req, false, 401, null, "application/json", "No authentication material", false);
return(resp);
#endregion
}
catch (Exception e)
{
_Logging.LogException("CryptoServer", "RequestHandler", e);
resp = new HttpResponse(req, false, 500, null, "application/json", "Internal server error", false);
return(resp);
}
finally
{
if (resp != null)
{
string message = "RequestHandler " + req.SourceIp + ":" + req.SourcePort + " " + req.Method + " " + req.RawUrlWithoutQuery;
message += " " + resp.StatusCode + " " + Common.TotalMsFrom(startTime) + "ms";
_Logging.Log(LoggingModule.Severity.Debug, message);
}
if (connAdded)
{
_Connections.Close(Thread.CurrentThread.ManagedThreadId);
}
}
}
public int AddConnection(ConnectionEntity connectionEntity)
{
ConnectionManager mgr = new ConnectionManager();
return(mgr.Add(connectionEntity));
}
