private void OpenConnection(Connection connection, string data, Action initializeCallback, Action<Exception> errorCallback) { var url = connection.Url + GetReceiveQueryString(connection, data); Action<HttpWebRequest> prepareRequest = PrepareRequest(connection); HttpHelper.GetAsync(url, request => { prepareRequest(request); request.Accept = "text/event-stream"; if (connection.MessageId != null) { request.Headers["Last-Event-ID"] = connection.MessageId.ToString(); } }).ContinueWith(task => { if (task.IsFaulted) { errorCallback(task.Exception); } else { // Get the reseponse stream and read it for messages var stream = task.Result.GetResponseStream(); var reader = new AsyncStreamReader(stream, connection, initializeCallback, errorCallback); reader.StartReading(); // Set the reader for this connection connection.Items[ReaderKey] = reader; } }); }
public async Task SendIssueReportAsync(IssueReport report) { var appId = _propertyProvider.GetProperty("locco.github.appId"); var accessToken = _propertyProvider.GetProperty("locco.github.token"); var repoOwner = _propertyProvider.GetProperty("locco.github.owner"); var repoName = _propertyProvider.GetProperty("locco.github.repository"); // Support default proxy var proxy = WebRequest.DefaultWebProxy; var httpClient = new HttpClientAdapter(() => HttpMessageHandlerFactory.CreateDefault(proxy)); var connection = new Connection(new ProductHeaderValue(appId), httpClient); if (proxy != null) { Log.Info(string.Format("Using proxy server '{0}' to connect to github!", proxy.GetProxy(new Uri("https://api.github.com/")))); } var client = new GitHubClient(connection) { Credentials = new Credentials(accessToken) }; // Creates a new GitHub Issue var newIssue = new NewIssue(report.Title) { Body = MarkdownReportUtil.CompileBodyMarkdown(report, 220000), }; newIssue.Labels.Add("bot"); var issue = await client.Issue.Create(repoOwner, repoName, newIssue); }
/// <summary> /// When session has completed, log any error which occured and dispose resources. This is done asynchronously /// sincew we want to be able to start new session without previous to complete. /// </summary> private void HandleSessionAsynchronously(Task sessionTask, Connection connection, ISession session) { sessionTask.ContinueWith(f => { if (f.IsFaulted) { var exception = f.Exception.InnerException; _log.LogException(new LogEvent() { LogLevel = LogLevel.Error, EventType = LogEventType.Application, Message = exception.Message, RemoteEndpoint = connection.RemoteEndpoint, SessionId = connection.SessionId, Protocol = session.Protocol.ToString() }, exception); } SessionManager.DecreaseSessionCount(session.Protocol); // Session has ended. connection.Dispose(); }); }
public void Timeout() { // Had to pick a routable IP, but one that won't return packets... don't know of a better choice than this var connection = new Connection(new IPEndPoint(IPAddress.Parse("10.230.220.210"), 28015)); connection.ConnectTimeout = TimeSpan.FromSeconds(1); connection.Connect(); }
// Receive incoming initial Connection messages from Clients... public static void AddToConnectionList(PacketHeader header, Connection connection, string Connection) { // Add incoming IP Address to HashSet list... ConnectionsList.Add(connection.ConnectionInfo.RemoteEndPoint.Address.ToString() + "|" + Connection); // Respond to sender that they are succesfully connected. connection.SendObject("Connected", "CONNECTED!"); Console.WriteLine("\n" + connection.ConnectionInfo.RemoteEndPoint.Address.ToString() + " has CONNECTED!"); // Send all active connections to all active connections for Client List. foreach (var item in NetworkComms.GetExistingConnection()) { foreach (var items in ConnectionsList.Distinct()) { item.SendObject("Connection", items); } } /* Old method to create files on hard disk for testing the code... if (!File.Exists(ConnectionFilePath)) { // Create a file to write to. using (StreamWriter sw = File.CreateText(ConnectionFilePath)) { } } using (StreamWriter sw = File.AppendText(ConnectionFilePath)) { sw.WriteLine(connection.ConnectionInfo.RemoteEndPoint.Address.ToString()); } */ }
public async Task RunAsync() { _listener.Start(); while (true) { TcpClient tcpClient = null; try { tcpClient = await _listener.AcceptTcpClientAsync(); } catch (ObjectDisposedException) { // When TcpListener is stopped, outstanding calls to AcceptTcpClientAsync // will throw an ObjectDisposedException. When this happens, it's time to // exit. return; } var connection = new Connection(tcpClient, _cancellationTokenSource.Token); var session = _sessionFactory(); var sessionTask = session.HandleConnection(connection); SessionManager.IncreaseSessionCount(session.Protocol); HandleSessionAsynchronously(sessionTask, connection, session); } }
public RtspTunnel(int rtspPort, int imagePort, Connection<MonoBrick.EV3.Command,MonoBrick.EV3.Reply> ev3Connection){ Running = false; RTSPPort = rtspPort; this.nxtConnection = null; this.ev3Connection = ev3Connection; this.hostImagePort = imagePort; }
public void SetUp() { ConnectionArgs args = new ConnectionArgs("deltabot","irc.sventech.com"); connection = new Connection( args ); RegisterListeners(); AssignLines(); }
protected override void HandleHttpRequest(Connection connection, HttpServerRequest request, HttpServerResponse response) { base.HandleHttpRequest(connection, request, response); if (response.ContentSource != ContentSource.ContentNone) { return; } if (request.Header.RequestType != "GET") { response.SendError(HttpStatusCode.BadRequest, String.Format("Request Type '{0}' not supported.", request.Header.RequestType)); return; } String lPath = RootPath + request.Header.RequestPath.Replace('/', Path.DirectorySeparatorChar); if (lPath.IndexOf("..", StringComparison.Ordinal) != -1) { response.SendError(HttpStatusCode.Forbidden, String.Format("Bad Request: Path '{0}' contains '..' which is invalid.", lPath)); return; } if (!File.Exists(lPath)) { response.SendError(HttpStatusCode.NotFound, String.Format("File '{0}' not found.", lPath)); return; } response.Header.ContentType = "text/html"; response.ContentStream = new FileStream(lPath, FileMode.Open, FileAccess.Read, FileShare.Read); response.CloseStream = true; /* Response will close stream once it's been sent */ }
public GlobalChatBot(string nick) { /*if (!File.Exists("Sharkbite.Thresher.dll")) { Server.UseGlobalChat = false; Server.s.Log("[GlobalChat] The IRC dll was not found!"); return; }*/ server = "irc.geekshed.net"; channel = "#MCForge"; this.nick = nick.Replace(" ", ""); connection = new Connection(new ConnectionArgs(nick, server), false, false); if (Server.UseGlobalChat) { // Regster events for incoming connection.Listener.OnNickError += new NickErrorEventHandler(Listener_OnNickError); connection.Listener.OnRegistered += new RegisteredEventHandler(Listener_OnRegistered); connection.Listener.OnPublic += new PublicMessageEventHandler(Listener_OnPublic); connection.Listener.OnJoin += new JoinEventHandler(Listener_OnJoin); connection.Listener.OnKick += new KickEventHandler(Listener_OnKick); connection.Listener.OnError += new ErrorMessageEventHandler(Listener_OnError); connection.Listener.OnDisconnected += new DisconnectedEventHandler(Listener_OnDisconnected); } }
public User Register([FromBody] User user) { _conn = new Connection(_connectionString); _conn.OpenConnection(); //Calculate MD5 hash MD5 md5 = MD5.Create(); byte[] inputBytes = Encoding.ASCII.GetBytes(user.Username + user.PasswordHash + DateTime.Now); byte[] hash = md5.ComputeHash(inputBytes); StringBuilder tokenString = new StringBuilder(); for (int i = 0; i < hash.Length; i++) { tokenString.Append(hash[i].ToString("X2")); } bool result = _conn.Register(user.Username, user.PasswordHash, tokenString.ToString()); _conn.CloseConnection(); if (result) { user.Token = tokenString.ToString(); return user; } else { throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.Conflict)); } }
public IConnection Get(string clusterName) { if (DefaultSettings.Value == null) throw new ConfigurationErrorsException("No rethinkdb client configuration section located"); foreach (ClusterElement cluster in DefaultSettings.Value.Clusters) { if (cluster.Name == clusterName) { List<EndPoint> endpoints = new List<EndPoint>(); foreach (EndPointElement ep in cluster.EndPoints) { IPAddress ip; if (IPAddress.TryParse(ep.Address, out ip)) endpoints.Add(new IPEndPoint(ip, ep.Port)); else endpoints.Add(new DnsEndPoint(ep.Address, ep.Port)); } var connection = new Connection(endpoints.ToArray()); if (!String.IsNullOrEmpty(cluster.AuthorizationKey)) connection.AuthorizationKey = cluster.AuthorizationKey; return connection; } } throw new ArgumentException("Cluster name could not be found in configuration", "clusterName"); }
public void Update_Should_Update_A_Connection() { _repository .Setup(it => it.Update(It.IsAny<String>(), It.IsAny<String>(), It.IsAny<Boolean>(), It.IsAny<Int32>())) .Callback<String, String, Boolean, Int32>((name, connectionString, isActive, connectionId) => { var tConnection = _repositoryList.Find(x => x.ConnectionId==connectionId); tConnection.Name = name; tConnection.ConnectionString = connectionString; tConnection.IsActive = isActive; }); var tempConnection = _repositoryList.Find(x => x.ConnectionId==connectionId); var testConnection = new Connection { ConnectionId = tempConnection.ConnectionId, Name = tempConnection.Name, ConnectionString = tempConnection.ConnectionString, IsActive = tempConnection.IsActive}; //TODO change something on testConnection //testConnection.oldValue = newValue; _target.Update(testConnection); //Assert.AreEqual(newValue, _repositoryList.Find(x => x.ConnectionId==1).oldValue); //TODO fail until we update the test above Assert.Fail(); }
protected override void InitializeClientHandshake(NetContext context, Connection conn) { var connection = (WebSocketConnection) conn; if (string.IsNullOrEmpty(connection.Host)) throw new InvalidOperationException("Host must be specified"); if (string.IsNullOrEmpty(connection.RequestLine)) throw new InvalidOperationException("RequestLine must be specified"); string key1 = CreateRandomKey(), key2 = CreateRandomKey(); byte[] key3 = new byte[8]; NetContext.GetRandomBytes(key3); StringBuilder req = new StringBuilder(connection.RequestLine).Append("\r\n" + "Upgrade: WebSocket\r\n" + // note casing! "Connection: Upgrade\r\n" + "Sec-WebSocket-Key1: ").Append(key1).Append("\r\n" + "Sec-WebSocket-Key2: ").Append(key2).Append("\r\n" + "Host: ").Append(connection.Host).Append("\r\n"); if (!string.IsNullOrEmpty(connection.Origin)) req.Append("Origin: ").Append(connection.Origin).Append("\r\n"); if (!string.IsNullOrEmpty(connection.Protocol)) req.Append("Sec-WebSocket-Protocol: ").Append(connection.Protocol).Append("\r\n"); req.Append("\r\n"); expectedSecurityResponse = WebSocketsProcessor_Hixie76_00.ComputeKey(key1, key2, key3); EnqueueFrame(context, new StringFrame(req.ToString(), Encoding.ASCII, false)); EnqueueFrame(context, new BinaryFrame(key3)); connection.PromptToSend(context); }
public void OnAsyncAccepted(IAsyncResult result) { Socket nsock = _listener.EndAccept(result); lock (_free_connections) { // Occupy new slot. int pos = _free_connections.Count - 1; if (pos >= 0) { int connection_id = _free_connections[pos]; _free_connections.RemoveAt(pos); Connection c = new Connection(); c.socket = nsock; c.recvbuf = new byte[4096]; c.conn = _handler.OnConnected(connection_id, c); _connections[connection_id] = c; nsock.BeginReceive(c.recvbuf, 0, c.recvbuf.Length, 0, OnAsyncReceive, connection_id); } else { Console.WriteLine("Dropping connection because i am full"); nsock.Close(); } } _listener.BeginAccept(OnAsyncAccepted, _listener); }
internal void Associate(Connection connection) { lock (this.m_ConnectionList) { this.m_ConnectionList.Add(connection); } }
public StreamManager (Connection serverConnection, TcpClient streamClient) { connection = serverConnection; updateThreadObject = new UpdateThread (this, streamClient); updateThread = new Thread (new ThreadStart (updateThreadObject.Main)); updateThread.Start (); }
public RemoteDeploymentManager(string serviceUrl) { serviceUrl = UrlUtility.EnsureTrailingSlash(serviceUrl); _client = HttpClientHelper.Create(serviceUrl); // Raise the event when data comes in _connection = new Connection(serviceUrl + "status"); _connection.Received += data => { if (StatusChanged != null) { var result = JsonConvert.DeserializeObject<DeployResult>(data); StatusChanged(result); } }; _connection.Error += exception => { // If we get a 404 back stop listening for changes WebException webException = exception as WebException; if (webException != null) { var webResponse = (HttpWebResponse)webException.Response; if (webResponse != null && webResponse.StatusCode == HttpStatusCode.NotFound) { _connection.Stop(); } } }; _connection.Closed += () => { Debug.WriteLine("SignalR connection to {0} was closed.", serviceUrl); }; _connection.Start().Wait(); }
static async void server_ClientConnceted(object sender, Connection con) { con.DataReceived += con_DataReceived; StringBuilder sb = new StringBuilder(); var sampleData = File.ReadAllText(@"C:\PersonalProjects\TinyWebSocket\TinyWebSocket.Host\sample.txt", Encoding.UTF8); await con.Send(sampleData); }
public void HandleAn400() { var response = new HttpResponseMessage(HttpStatusCode.BadRequest) { Content = new StringContent("errorMessage") }; response.Content.Headers.ContentType = new MediaTypeHeaderValue("application/json"); var httpClient = Substitute.For<IHttpClient>(); httpClient.SendAsync(Arg.Any<HttpRequestMessage>()).Returns(Task.FromResult(response)); var connection = new Connection(httpClient, DotNetLoggerFactory.Create, "http://test.com"); var generatedException = false; try { connection.Send<string>(HttpMethod.Get, "/thisIsATest").Wait(); } catch (AggregateException e) { var aggregatedException = e.Flatten(); Assert.AreEqual(1, aggregatedException.InnerExceptions.Count); var httpError = aggregatedException.InnerExceptions.FirstOrDefault(); Assert.IsInstanceOf<HttpError>(httpError); // ReSharper disable once PossibleNullReferenceException Assert.AreEqual("Status Code : BadRequest, with content: errorMessage", httpError.Message); generatedException = true; } if (!generatedException) { Assert.Fail("Send should have thrown an HttpError exception"); } }
public void HandleAnResponseWithDifferentContentType() { var response = new HttpResponseMessage(HttpStatusCode.OK) { Content = new StringContent("errorMessage") }; response.Content.Headers.ContentType = new MediaTypeHeaderValue("application/text"); var httpClient = Substitute.For<IHttpClient>(); httpClient.SendAsync(Arg.Any<HttpRequestMessage>()).Returns(Task.FromResult(response)); var connection = new Connection(httpClient, DotNetLoggerFactory.Create, "http://test.com"); var generatedException = false; try { connection.Send<string>(HttpMethod.Get, "/thisIsATest").Wait(); } catch (AggregateException e) { var aggregatedException = e.Flatten(); Assert.AreEqual(1, aggregatedException.InnerExceptions.Count); var badResponseError = aggregatedException.InnerExceptions.FirstOrDefault(); Assert.IsInstanceOf<BadResponseError>(badResponseError); Assert.IsNotNull(badResponseError); Assert.AreEqual("Response format isn't valid it should have been application/json but was application/text", badResponseError.Message); generatedException = true; } if (!generatedException) { Assert.Fail("Send should have thrown an HttpError exception"); } }
protected override void ProcessConnectionDisconnected(Connection<object> connection) { nodeStateQueueSemaphore.Wait(); nodeStateQueue.Enqueue(TestNodeState.Disconnected); nodeStateQueueSemaphore.Release(); nodeStateSemaphore.Release(); }
public GlobalChatBot(string nick) { /*if (!File.Exists("Sharkbite.Thresher.dll")) { Server.UseGlobalChat = false; Server.s.Log("[GlobalChat] The IRC dll was not found!"); return; }*/ try { using (WebClient wc = new WebClient()) { string data = wc.DownloadString("http://server.mcforge.net/gcdata"); server = data.Split('&')[0]; channel = data.Split('&')[1]; } } catch { server = "irc.mcforge.net"; channel = "#GlobalChat"; } this.nick = nick.Replace(" ", ""); connection = new Connection(new ConnectionArgs(nick, server), false, false); if (Server.UseGlobalChat) { // Regster events for incoming connection.Listener.OnNickError += new NickErrorEventHandler(Listener_OnNickError); connection.Listener.OnRegistered += new RegisteredEventHandler(Listener_OnRegistered); connection.Listener.OnPublic += new PublicMessageEventHandler(Listener_OnPublic); connection.Listener.OnJoin += new JoinEventHandler(Listener_OnJoin); connection.Listener.OnKick += new KickEventHandler(Listener_OnKick); connection.Listener.OnError += new ErrorMessageEventHandler(Listener_OnError); connection.Listener.OnDisconnected += new DisconnectedEventHandler(Listener_OnDisconnected); } }
public TwitchChatBot() { XDocument doc = XDocument.Load("twitch.config"); XElement configElement = doc.Element("configuration"); XElement serverElement = configElement.Element("Server"); Credentials.Server = serverElement.Value; XElement channelElement = configElement.Element("Channel"); Credentials.Channel = channelElement.Value; XElement nickElement = configElement.Element("Nick"); Credentials.Nick = nickElement.Value; XElement passwordElement = configElement.Element("Password"); Credentials.Password = passwordElement.Value; XElement commandsElement = configElement.Element("Commands"); foreach(XElement commandElement in commandsElement.Elements()) { commands.Add("!" + commandElement.Name.LocalName.ToLower(), commandElement.Value); } ConnectionArgs cargs = new ConnectionArgs(Credentials.Nick, Credentials.Server); cargs.Port = 6667; cargs.ServerPassword = Credentials.Password; connection = new Connection(cargs, false, false); connection.Listener.OnRegistered += new RegisteredEventHandler(OnRegistered); connection.Listener.OnJoin += new JoinEventHandler(OnJoin); connection.Listener.OnPublic += new PublicMessageEventHandler(OnPublic); //Listen for bot commands sent as private messages connection.Listener.OnPrivate += new PrivateMessageEventHandler(OnPrivate); //Listen for notification that an error has ocurred connection.Listener.OnError += new ErrorMessageEventHandler(OnError); //Listen for notification that we are no longer connected. connection.Listener.OnDisconnected += new DisconnectedEventHandler(OnDisconnected); }
public static void RegisterConnection(Connection conn, Object key) { lock (ConnByReceiver) { ConnByReceiver[key] = conn; Console.WriteLine("Registered connection #{0} as {1}. Count: {2}",conn.ID,key, ConnByReceiver.Count); } }
public static IEnumerable<OutgoingFileTransfer> GetAll(Connection conn) { foreach (Contact contact in conn.Roster.GetAllContacts ()) { DispatchManager dm = contact.DispatchManager; foreach (OutgoingFileTransfer ft in dm.GetAll <OutgoingFileTransfer> (contact)) { yield return ft; } } }
public void ShouldNotConnectToWrongPort() { var connected = true; var connection = new Connection(new IPEndPoint(IPAddress.Loopback, 7777)); connection.Connect((success) => { connected = success; _completion.Set(); }); _completion.WaitOne(); Assert.IsFalse(connected); }
public void ShouldConnectToListener() { var connected = false; var connection = new Connection(new IPEndPoint(IPAddress.Loopback, 9999)); connection.Connect((success) => { connected = success; _completion.Set(); }); _completion.WaitOne(); Assert.IsTrue(connected); }
static void Main(string[] args) { //todo use mono.options https://www.nuget.org/packages/Mono.Options/ if (args.Length < 5) { Console.WriteLine("YouTrack Release helper, marks a version as released and creates version numbers for follow up releases. Works with version numbers up to 3 digits"); Console.WriteLine(""); Console.WriteLine("Usage:"); Console.WriteLine(" YouTrackRelease --server=<server> --username=<username> --password=<password> --project=<project> --version=<version>"); Console.WriteLine(""); Console.WriteLine("Options:"); Console.WriteLine(" --server=<server> Server address, ie http://youtrack.domain.com/youtrack"); Console.WriteLine(" --username=<username> User with admin role"); Console.WriteLine(" --password=<password> "); Console.WriteLine(" --project=<project> ID of project being released"); Console.WriteLine(" --version=<version> The version number to be released (i.e 1.2.3)"); return; } var server = GetArgNotNull(args, "--server"); var username = GetArgNotNull(args, "--username"); var password = GetArgNotNull(args, "--password"); var projectId = GetArgNotNull(args, "--project"); var version = GetArgNotNull(args, "--version"); var uri = new Uri(server); Console.WriteLine("Connecting to server: {0}, {1}, {2}", uri, uri.Port, uri.AbsolutePath); var conn = new Connection(uri.Host, uri.Port, uri.Scheme == "https", uri.AbsolutePath); conn.Authenticate(username, password); var projectManagement = new ProjectManagement(conn); var project = projectManagement.GetProject(projectId); if (project == null) throw new Exception("Project does not exist"); var existingVersions = projectManagement.GetVersions(project).Select((v) => v.Name); if (!existingVersions.Contains(version)) throw new Exception("Version does not exist"); Console.Out.WriteLine("Releasing version: {0}", version); projectManagement.UpdateVersion(project, new ProjectVersion { IsReleased = true, Name = version, ReleaseDate = JavaTimeNow() }); var currentVersion = new VersionNumber(version); var nextVersions = currentVersion.GetNextReleaseVersions().Select((v) => v.ToString()); var missingVersions = nextVersions.Where((v) => !existingVersions.Contains(v)); foreach (var newVersion in missingVersions) { Console.Out.WriteLine("Adding version: {0}", newVersion); projectManagement.AddVersion(project, new ProjectVersion {IsReleased = false, Name = newVersion}); } if (Debugger.IsAttached) Console.ReadLine(); }
protected override bool ProcessIncomingMessageAction(Connection<object> connection, Packet packet) { packetQueueSemaphore.Wait(); this.packetQueue.Enqueue(packet); packetQueueSemaphore.Release(); bufferSemaphore.Release(); return true; }