示例#1
0
        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);
        }
示例#2
0
        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);
        }
示例#3
0
        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);
 }
示例#5
0
        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);
        }
示例#6
0
        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);
        }
示例#7
0
        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);
        }
示例#8
0
 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);
         }
     }
 }
示例#9
0
        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));
        }
示例#10
0
        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();
        }
示例#11
0
        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();
        }
示例#13
0
        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"));
        }
示例#14
0
        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();
                }
            });
        }
示例#15
0
        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);
        }
示例#16
0
        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);
        }
示例#17
0
        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);
        }
示例#18
0
        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);
        }
示例#19
0
            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();
                }
            }
示例#20
0
        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)
            {
示例#21
0
        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);
        }
示例#22
0
        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());
        }
示例#23
0
        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;
                }
示例#24
0
        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);
        }
示例#25
0
        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);
        }
示例#26
0
        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);
            }
        }
示例#27
0
        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);
                }
            }
        }
示例#28
0
        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);
                }
            }
        }
示例#29
0
        public int AddConnection(ConnectionEntity connectionEntity)
        {
            ConnectionManager mgr = new ConnectionManager();

            return(mgr.Add(connectionEntity));
        }