public async Task <ClientEntry> GetNexClient() { if (_disposedValue) { throw new ObjectDisposedException(nameof(ClientPool)); } ClientEntry entry = null; if (_enablePool) { while (entry == null && !TryDequeue(out entry)) { ////Interlocked.Increment(ref StaticLog.CreatedClients); entry = new ClientEntry(new TcpClient(_endpoint.AddressFamily) { LingerState = new LingerOption(true, 0) }); await entry.Client.ConnectAsync(_endpoint.Address, _endpoint.Port).ConfigureAwait(false); } } else { ////Interlocked.Increment(ref StaticLog.CreatedClients); entry = new ClientEntry(new TcpClient(_endpoint.AddressFamily)); await entry.Client.ConnectAsync(_endpoint.Address, _endpoint.Port).ConfigureAwait(false); } return(entry); }
public void AttachClient(string name) { var client = OperationContext.Current.GetCallbackChannel<IChatClient>(); var clientEntry = new ClientEntry {Name = name, Client = client}; _clients.Add(clientEntry); NotifyUsersChanged(); }
public void Enqueue(ClientEntry entry) { if (_disposedValue) { throw new ObjectDisposedException(nameof(ClientPool)); } if (entry == null) { throw new ArgumentNullException(nameof(entry)); } if (!entry.Client.Client.RemoteEndPoint.Equals(_endpoint)) { throw new ArgumentException("Invalid endpoint."); } // TickCount swap will be fine here as the entry just gets disposed and we'll create a new one starting at 0+ again, totall fine... if (_enablePool && entry.Client.Connected && entry.StartMillis + entry.MaxLiveTime >= (Environment.TickCount & int.MaxValue)) { _clients.Enqueue(entry); } else { // dispose the client and don't keep a reference entry.DisposeClient(); } }
public async Task Put(int id, [FromBody] ClientEntry value) { var entry = await _db.Entries.FindAsync(id); entry = value; await _db.SaveChangesAsync(); }
public async Task <ClientEntry> GetNextClient() { if (disposedValue) { throw new ObjectDisposedException(nameof(ClientPool)); } ClientEntry entry = null; if (_enablePool) { while (entry == null && !TryDequeue(out entry)) { entry = new ClientEntry(new TcpClient(_endpoint.AddressFamily) { LingerState = new LingerOption(true, 0) }, _endpoint); await entry.Client.ConnectAsync(_endpoint.Address, _endpoint.Port).ConfigureAwait(false); } } else { entry = new ClientEntry(new TcpClient(_endpoint.AddressFamily), _endpoint); await entry.Client.ConnectAsync(_endpoint.Address, _endpoint.Port).ConfigureAwait(false); } return(entry); }
public ActionResult DeleteConfirmed(int id) { ClientEntry clientEntry = db.ClientEntry.Find(id); db.ClientEntry.Remove(clientEntry); db.SaveChanges(); return(RedirectToAction("Index")); }
public async Task <string> Post([FromBody] ClientEntry value) { await _db.Entries.AddAsync(value); await _db.SaveChangesAsync(); return(value.ClientName + " - " + value.ClientId); }
public ActionResult Simulation([Bind(Include = "Id,Date,IsGoesInside,IdEntryGate,IdWristband")] ClientEntry clientEntry) { bool activeTicket = false; var entryGate = db.EntryGate.Find(clientEntry.IdEntryGate); var clientTickets = db.ClientTicket.Select(n => n). Where(n => n.IdWristband == clientEntry.IdWristband). Where(n => n.TicketInPriceList.Attraction.Id == entryGate.IdAttraction); foreach (ClientTicket ticket in clientTickets) { if (ticket.ExpirationDate < DateTime.Now) { ticket.IsActive = false; db.Entry(ticket).State = EntityState.Modified; continue; } else if (ticket.EntriesLeft != null) { if (ticket.EntriesLeft <= 0) { ticket.IsActive = false; db.Entry(ticket).State = EntityState.Modified; continue; } ticket.EntriesLeft -= 1; db.Entry(ticket).State = EntityState.Modified; } activeTicket = true; break; } clientEntry.Date = DateTime.Now; if (ModelState.IsValid && activeTicket) { db.ClientEntry.Add(clientEntry); db.SaveChanges(); return(RedirectToAction("Index")); } var entryGates = db.EntryGate.Select(n => new { Id = n.Id, Description = n.Attraction.Name + " " + n.Id, IsActive = n.IsActive }); ViewBag.NoTicketsForAttraction = true; ViewBag.IdEntryGate = new SelectList(entryGates.Where(n => n.IsActive == true), "Id", "Description", clientEntry.IdEntryGate); ViewBag.IdWristband = new SelectList(db.Wristband, "Id", "Id", clientEntry.IdWristband); return(View(clientEntry)); }
private void ClientAcceptHandler(object sender, TcpClient client) { ClientEntry entry = new ClientEntry(client); entry.OnMessageRecieve += MessageRecieved; if (_anons.TryAdd(entry.Ip, entry)) { Console.WriteLine($"{client.Client.LocalEndPoint.ToString()} connected"); } }
public void Init(ClientEntry clientEntry) { this.clientEntry = clientEntry; UIManager.Instance.Init(); LogicModules.Instance.Initialize(); inited = true; GlobalDispatcher.Instance.dispatchEvent(EventName.ShowStartView); }
public ActionResult Edit([Bind(Include = "Id,Date,IsGoesInside,IdEntryGate,IdWristband")] ClientEntry clientEntry) { if (ModelState.IsValid) { db.Entry(clientEntry).State = EntityState.Modified; db.SaveChanges(); return(RedirectToAction("Index")); } ViewBag.IdEntryGate = new SelectList(db.EntryGate, "Id", "Id", clientEntry.IdEntryGate); ViewBag.IdWristband = new SelectList(db.Wristband, "Id", "Id", clientEntry.IdWristband); return(View(clientEntry)); }
public void HandleAuth(object sender, Message msg) { ClientEntry entry = sender as ClientEntry; if (_anons.TryRemove(entry.Ip, out entry)) { if (_users.TryAdd(msg.Id, entry)) { Console.WriteLine($"{msg.Text} entered to chat"); } } }
public ActionResult Details(int?id) { if (id == null) { return(new HttpStatusCodeResult(HttpStatusCode.BadRequest)); } ClientEntry clientEntry = db.ClientEntry.Find(id); if (clientEntry == null) { return(HttpNotFound()); } return(View(clientEntry)); }
/// <summary> /// send data to the client. /// </summary> /// <param name="clientEntry"></param> /// <param name="data">Data as string to send to the client.</param> private void SendResponse(ClientEntry clientEntry, string data) { if (clientEntry.Client != null) { try { clientEntry.Client.GetStream().BeginWrite(System.Text.Encoding.UTF8.GetBytes(data), 0, data.Length, this.OnWriteDoneCallback, clientEntry); } catch (Exception /*e*/) { Output.WriteLine("Server: Exception on writing to network stream."); this.DisconnectClient(clientEntry); } } }
public ActionResult Edit(int?id) { if (id == null) { return(new HttpStatusCodeResult(HttpStatusCode.BadRequest)); } ClientEntry clientEntry = db.ClientEntry.Find(id); if (clientEntry == null) { return(HttpNotFound()); } ViewBag.IdEntryGate = new SelectList(db.EntryGate, "Id", "Id", clientEntry.IdEntryGate); ViewBag.IdWristband = new SelectList(db.Wristband, "Id", "Id", clientEntry.IdWristband); return(View(clientEntry)); }
public void HandleLogOut(object sender, Message msg) { if (_users.Any(user => user.Key == msg.Id)) { ClientEntry user = null; _users.Remove(msg.Id, out user); user.ShutDown(this, null); user.OnMessageRecieve -= HandleMessage; Console.WriteLine($"{msg.Name} logout"); } ClientEntry entry = null; if (_anons.TryRemove((sender as ClientEntry).Ip, out entry)) { entry.ShutDown(this, null); entry.OnMessageRecieve -= HandleMessage; } }
public ActionResult Create([Bind(Include = "Id,Date,IsGoesInside,IdEntryGate,IdWristband")] ClientEntry clientEntry) { clientEntry.Date = DateTime.Now; if (ModelState.IsValid) { db.ClientEntry.Add(clientEntry); db.SaveChanges(); return(RedirectToAction("Index")); } var entryGates = db.EntryGate.Select(n => new { Id = n.Id, Description = n.Attraction.Name + " " + n.Id }); ViewBag.IdEntryGate = new SelectList(entryGates, "Id", "Description", clientEntry.IdEntryGate); ViewBag.IdWristband = new SelectList(db.Wristband, "Id", "Id", clientEntry.IdWristband); return(View(clientEntry)); }
private void lst_SelectedIndexChanged(object sender, System.EventArgs e) { if (lst.SelectedIndices.Count == 1) { ClientEntry current = null; try { current = m_Clients[int.Parse(lst.SelectedItems[0].SubItems[5].Text)] as ClientEntry; } catch {} m_Client = current; } else { m_Client = null; } EnableButtons(); }
/// <summary> /// On TCP client connects to listen socket... /// </summary> /// <param name="result">Operation result is given into this callback</param> private void OnTcpClientConnectingCallback(IAsyncResult result) { if (result != null) { Output.WriteLine("Server: Incoming client."); // accept the client... var clientEntry = new ClientEntry(); this.ConnectedClients.Add(clientEntry); clientEntry.Client = this.TcpListenSocket.EndAcceptTcpClient(result); // continue awaiting new clients on listen socket... this.AwaitIncomingClient(); // say welcome to the client... Output.WriteLine("Server: Welcome client..."); this.SendResponse(clientEntry, "WELCOME"); // start receiving data from the client's network stream... this.ReceiveRequest(clientEntry); } }
/// <summary> /// simple server logics acting on received data. /// </summary> /// <param name="clientEntry"></param> /// <param name="dataString">the request to react on.</param> private void ReactOnRequest(ClientEntry clientEntry, string dataString) { // --------------------------------------------------------------------------- // THIS IS A SIMPLE SERVER LOGICS THAT ACTS ON RECEIVED DATA... // --------------------------------------------------------------------------- // send back "OK" followed by the upper-string if the string can be converted to upper, // else send "NOT CONVERTED". if (dataString.ToUpper() == dataString) { Output.WriteLine("Server: Client data string is not convertible. Send NOT CONVERTED."); this.SendResponse(clientEntry, "NOT CONVERTED"); } else { Output.WriteLine("Server: converting client's data string and send it back..."); this.SendResponse(clientEntry, "OK"); this.SendResponse(clientEntry, dataString.ToUpper()); } // --------------------------------------------------------------------------- // DONE // --------------------------------------------------------------------------- }
/// <summary> /// receive from given client... /// </summary> /// <param name="clientEntry"></param> private void ReceiveRequest(ClientEntry clientEntry) { if (clientEntry.Client.Connected) { Output.WriteLine("Server: Awaiting request..."); Array.Clear(clientEntry.TcpData, 0, clientEntry.TcpData.Length); try { clientEntry.Client.GetStream().BeginRead(clientEntry.TcpData, 0, clientEntry.TcpData.Length, this.OnReadDoneCallback, clientEntry); } catch (Exception /*e*/) { Output.WriteLine("Server: Exception on reading from network stream."); this.DisconnectClient(clientEntry); } } else { Output.WriteLine("Server: Can't receive from client socket due socket is not connected."); this.DisconnectClient(clientEntry); } }
private bool TryDequeue(out ClientEntry entry) { if (_disposedValue) { throw new ObjectDisposedException(nameof(ClientPool)); } bool result; // ReSharper disable once AssignmentInConditionalExpression while (result = _clients.TryDequeue(out entry)) { // validate the client before returning it if (entry.Client.Connected && entry.StartMillis + entry.MaxLiveTime >= (Environment.TickCount & int.MaxValue)) { break; } entry.DisposeClient(); } return(result); }
public bool TryDequeue(out ClientEntry entry) { if (disposedValue) { throw new ObjectDisposedException(nameof(ClientPool)); } bool result; while (result = _clients.TryDequeue(out entry)) { // validate the client before returning it if (entry.Client.Connected && entry.StartMillis + entry.MaxLiveTime >= (Environment.TickCount & int.MaxValue)) { break; } else { entry.DisposeClient(); } } return(result); }
public int Compare(object x, object y) { var X = x as ListViewItem; var Y = y as ListViewItem; if (X == null || Y == null) { return(0); } ClientEntry item1 = null; ClientEntry item2 = null; try { var s1 = int.Parse(X.SubItems[5].Text); var s2 = int.Parse(Y.SubItems[5].Text); item1 = m_Clients[s1] as ClientEntry; item2 = m_Clients[s2] as ClientEntry; } catch { } if (item1 == null || item2 == null) { return(0); } if (!m_Ascending) { var temp = item1; item1 = item2; item2 = temp; } switch (m_Column) { case 0: // Name return(string.Compare(item1.Name, item2.Name)); case 1: // Account return(string.Compare(item1.Account, item2.Account)); case 2: // Map return(item1.Map.CompareTo(item2.Map)); case 3: // Location var cmp = item1.X.CompareTo(item2.Y); if (cmp == 0) { return(item1.Y.CompareTo(item2.Y)); } else { return(cmp); } case 4: // Login time return(DateTime.Compare(item1.LoggedIn, item2.LoggedIn)); case 5: // Serial return(item1.Serial.CompareTo(item2.Serial)); } return(0); }
public void CommandConnect(object sender, CommandEventArgs e) { if (e.Parameters.Length == 0) { e.Reply("I'm connected to the following servers:"); foreach (ClientEntry clientEntry in Bot.Clients) { IrcClient client = clientEntry.Client; switch (client.State) { case IrcClientState.Disconnected: e.Reply(string.Format("{0} - \u00034offline\u000F.", client.NetworkName)); break; case IrcClientState.Connecting: e.Reply(string.Format("{0} - \u00038connecting\u000F.", client.NetworkName)); break; case IrcClientState.SslHandshaking: e.Reply(string.Format("{0} - \u00038establishing TLS connection\u000F.", client.NetworkName)); break; case IrcClientState.SaslAuthenticating: e.Reply(string.Format("{0} - \u00038authenticating\u000F.", client.NetworkName)); break; case IrcClientState.Registering: e.Reply(string.Format("{0} - \u00038logging in\u000F.", client.NetworkName)); break; case IrcClientState.Online: if (client.Channels.Count > 1) { e.Reply(string.Format("{0} - \u00039online\u000F; on channels \u0002{1}\u000F.", client.NetworkName, string.Join("\u000F, \u0002", client.Channels.Select(c => c.Name)))); } else if (client.Channels.Count == 1) { e.Reply(string.Format("{0} - \u00039online\u000F; on channel \u0002{1}\u000F.", client.NetworkName, client.Channels.First().Name)); } else { e.Reply(string.Format("{0} - \u00039online\u000F.", client.NetworkName)); } break; default: e.Reply(string.Format("{0} - {1}.", client.NetworkName, client.State)); break; } } } else { foreach (ClientEntry clientEntry in Bot.Clients) { IrcClient client = clientEntry.Client; if (client.Address.Equals(e.Parameters[0], StringComparison.OrdinalIgnoreCase) || (client.Extensions.NetworkName != null && client.Extensions.NetworkName.Equals(e.Parameters[0], StringComparison.OrdinalIgnoreCase))) { if (client.State != IrcClientState.Disconnected) { e.Reply(string.Format("I'm already connected to \u0002{0}\u000F.", client.Address)); } else { e.Reply(string.Format("Reconnecting to \u0002{0}\u000F.", client.Address)); client.Connect(clientEntry.Address, clientEntry.Port); } return; } } e.Reply(string.Format("Connecting to \u0002{0}\u000F.", e.Parameters[0])); var network = new ClientEntry(e.Parameters[0]) { Address = e.Parameters[0], Port = 6667, Nicknames = new[] { e.Client.Me.Nickname }, Ident = e.Client.Me.Ident, FullName = e.Client.Me.FullName }; Bot.AddNetwork(network); network.Connect(); } }
public async void SendCheck(string message, IrcClient originConnection, IrcMessageTarget origin) { foreach (string channelName in this.Targets) { string[] fields = channelName.Split(new char[] { '/' }, 2); if (fields.Length == 1) { fields = new string[] { "*", fields[0] } } ; IEnumerable <ClientEntry> clients; if (fields[0] == "*") { clients = Bot.Clients; } else { ClientEntry client = Bot.Clients.FirstOrDefault(c => fields[0].Equals(c.Client.Extensions.NetworkName, StringComparison.OrdinalIgnoreCase) || fields[0].Equals(c.Client.Address, StringComparison.OrdinalIgnoreCase)); if (client == default(ClientEntry)) { return; } clients = new ClientEntry[] { client }; } foreach (ClientEntry clientEntry in clients) { IrcClient client = clientEntry.Client; if (fields[1] == "*") { if (client == originConnection) { foreach (IrcChannel channel in client.Channels.Where(_channel => _channel != origin)) { channel.Say(message); } } else { foreach (IrcChannel channel in client.Channels) { channel.Say(message); } } } else if (client.IsChannel(fields[1]) && (client != originConnection || !client.CaseMappingComparer.Equals(fields[1], origin))) { client.Send("PRIVMSG " + fields[1] + " :" + message); } else { IrcUser user; if ((client != originConnection || !client.CaseMappingComparer.Equals(fields[1], origin)) && client.Users.TryGetValue(fields[1], out user) && await Bot.CheckPermissionAsync(user, this.Key + ".receive")) { client.Send("PRIVMSG " + fields[1] + " :" + message); } } } } }
Lock(object[] dataObjects, int timeoutMilliseconds, Action action) { requiredThread = System.Threading.Thread.CurrentThread; syncRoot = 0; if (dataObjects.Length == 0) { succeeded = true; hasLock = true; isWaiting = false; } else { ((IDataObject)dataObjects[0]).GetDataStore().UploadScript(CreateLockScript, CreateLockScriptSha1); ((IDataObject)dataObjects[0]).GetDataStore().UploadScript(DecrementAndDestroyScript, DecrementAndDestroyScriptSha1); foreach (object dataObject in dataObjects) if (!(dataObject is IDataObject)) throw new ArgumentException("All the objects must be IDataObjects created by Doredis"); succeeded = false; hasLock = false; isWaiting = true; signal = new ManualResetEvent(true); Timer timeoutTimer = new Timer(_ => Fail(), null, timeoutMilliseconds, Timeout.Infinite); try { foreach (IDataObject dataObject in dataObjects) { DataStoreShard dataStore = dataObject.GetDataStoreShard(dataObject.GetAbsolutePath()); Action<string> signalHandler = (string dontCare) => { signal.Set(); }; if (!clientEntries.ContainsKey(dataStore)) clientEntries[dataStore] = new ClientEntry(dataStore, signalHandler); clientEntries[dataStore].Add(dataObject); } while (true) { try { lock (syncRoot) { signal.Reset(); if (isWaiting) { hasLock = TryLock(); if (hasLock) { isWaiting = false; } } else break; } if (hasLock) { succeeded = true; action(); break; } } finally { lock (syncRoot) { if (hasLock) { hasLock = false; FreeLock(); } } } //if the server that held the lock goes down, this'll prevent all the others from waiting forever //eventually, the lock will expire signal.WaitOne(keepAliveExpireTime * 1000); } } finally { foreach (var entry in clientEntries) { entry.Value.Dispose(); } timeoutTimer.Dispose(); signal.Dispose(); } } }
/// <summary> /// Disconnect client with given client info /// </summary> /// <param name="clientEntry"></param> private void DisconnectClient(ClientEntry clientEntry) { Output.WriteLine("Server: Closing server side client socket."); clientEntry.Client.Close(); this.ConnectedClients.Remove(clientEntry); }