Chat server: Difference between revisions

{{libheader|AdaSockets}}

 

with Ada.Command_Line; use Ada.Command_Line;

with Ada.Exceptions; use Ada.Exceptions;

Dummy.Start (Incoming_Socket);

end loop;

 

=={{header|BaCon}}==

Requires BaCon 4.2 or higher. Clients have to login with an alias and can use the commands 'say' or 'quit'. Notifications are submitted when users enter the chat or leave the chat.

DECLARE connect ASSOC long

OPEN "localhost:51000" FOR SERVER AS mynet

ENDIF

ENDIF

 

=={{header|C}}==

A glitch occurs if a connection is made using the Telnet protocol - user names are preceded by garbled text.

 

#include <stdlib.h>

#include <sys/socket.h>

 

return 0;

 

=={{header|C sharp|C#}}==

using System.Collections.Generic;

using System.Net.Sockets;

}

}

 

=={{header|CoffeeScript}}==

This is ported from the JavaScript version. The tool js2coffee got me a mostly working version, and then I manually converted JS-style classes to CS "classic-style class" syntax.

 

net = require("net")

sys = require("sys")

 

server = new ChatServer()

 

=={{header|D}}==

import std.getopt;

import std.socket;

}

}

 

=={{header|Common Lisp}}==

*USER-MANAGER*, or upon an error occurring.

 

(ql:quickload '(:usocket :simple-actors :bordeaux-threads))

 

 

(make-thread #'accept-connections)

 

=={{header|Erlang}}==

-module(chat).

 

Response -> Response

end.

 

=={{header|Go}}==

This example handles the case of one specific client "falling behind" by relying on the underlying TCP stack to do a reasonable job of buffering. Once that buffer fills, a write to the that client's connection will time out and the connection will dropped. Other minor improvements would include enabling TCP keep alives, handling temporary errors from accept, and better logging. Not ideal, but it should be good enough for this example.

 

 

import (

}

c.server.rem <- c.name

 

=={{header|Groovy}}==

{{trans|Java}}

private int port = 0

private List<Client> clientList = new ArrayList<>()

new ChatServer(port).run()

}

 

=={{header|Haskell}}==

import Network

import System.IO

T.putStrLn "Server started"

newMVar (M.empty) >>= clientLoop server

 

==Icon and {{header|Unicon}}==

 

This is Unicon-specific:

 

procedure main()

critical mlck: nCons -:= 1

}

 

=={{header|Java}}==

I think ideally, NIO would be used to select() sockets available/ready for I/O, to eliminate the possibility of a bad connection disrupting the server, but this increases the complexity.

 

import java.net.*;

import java.util.*;

}

}

 

=={{header|JavaScript}}==

{{works with|Node.js}}

const EventEmitter = require("events").EventEmitter;

// Start the server!

 

=={{header|Julia}}==

Modified to fit the Rosetta Code task from example code for the WebSockets module written by Leah Hanson.

To test, start the code and use a browser to connect to localhost:8000.

using HttpServer

using WebSockets

println("Chat server listening on 8000...")

run(server,8000)

 

=={{header|Kotlin}}==

{{trans|Java}}

import java.io.IOException

import java.io.InputStreamReader

}

}

 

=={{header|Nim}}==

 

type

 

asyncCheck serve()

 

=={{header|Objeck}}==

use System.IO.Net;

use System.Concurrency;

}

}

 

=={{header|Ol}}==

(define (timestamp) (syscall 201 "%c"))

 

 

(run 8080)

{{Out}}

 

=={{header|Perl}}==

{{trans|Python}}

use strict;

use warnings;

 

sleep(0.1);

===Alternate with both read and write queuing===

 

use strict; # http://www.rosettacode.org/wiki/Chat_server

}

}

 

=={{header|Phix}}==

===server===

<span style="color: #000080;font-style:italic;">--

-- demo\rosetta\ChatServer.exw

<span style="color: #7060A8;">IupMainLoop</span><span style="color: #0000FF;">()</span>

<span style="color: #7060A8;">IupClose</span><span style="color: #0000FF;">()</span>

===client===

<span style="color: #000080;font-style:italic;">--

-- demo\rosetta\ChatClient.exw

<span style="color: #7060A8;">IupMainLoop</span><span style="color: #0000FF;">()</span>

<span style="color: #7060A8;">IupClose</span><span style="color: #0000FF;">()</span>

 

=={{header|PicoLisp}}==

 

(de chat Lst

(tell 'chat "--- " *Name " left ---")

(bye) ) ) )

After starting the above script, connect to the chat server from two terminals:

<pre> Terminal 1 | Terminal 2

 

This version will load the server automatically on port 5000, adapt to your needs.

 

chat_server(Port) :-

msg_username_taken('That username is already taken, choose another\n\r').

msg_new_line('\n\r').

 

=={{header|Python}}==

 

import socket

time.sleep(.1)

except (SystemExit, KeyboardInterrupt):

 

=={{header|R}}==

This implementation relies on the new server socket connection type introduced in R 4.0.0.

chat_loop <- function(server, sockets, delay = 0.5) {

repeat {

}

 

 

=={{header|Racket}}==

This is a very basic chat server, but it does everything that is needed for this task.

 

#lang racket

 

(void (thread (λ() (chat-server (tcp-listen 12321)))))

((client (current-input-port) (current-output-port)))

 

=={{header|Raku}}==

<div style="display:inline-block">{{trans|Python}}</div> (or at least started out that way)

{{works with|Rakudo|2016.07}}

my %connections;

}

}

 

Notes:

 

=={{header|Ruby}}==

 

class ChatServer < GServer

#Turn on informational messages

ChatServer.new(7000, '0.0.0.0', 100, $stderr, true).start.join

 

=={{header|Rust}}==

use std::collections::HashMap;

use std::io;

chat_loop(&listener).unwrap();

}

 

=={{header|Tcl}}==

{{works with|Tcl|8.6}}

 

# Write a message to everyone except the sender of the message

socket -server {coroutine c[incr count] chat} 4004

set ::cmap {}; # Dictionary mapping nicks to channels

 

=={{header|Visual Basic .NET}}==

{{trans|C#}}

Imports System.Text

Imports System.Threading

End Sub

 

 

=={{header|Wren}}==

 

As Wren's VM is single threaded we create separate VMs to service each potential client connection (limited to 10) which run in their own thread. As the only way for the VMs to share mutable state is to use global variables within the host, synchronization is needed when accessing such variables.

 

class Clients {

foreign static read(connfd, count)

foreign static close(connfd)

<br>

We now embed this in the following C program, build and run it to start the server. To end the server, just press control-C. For testing purposes, clients can use telnet from separate terminals to connect to the server on port 5000.

 

#include <sys/socket.h>

 

return 0;

 

=={{header|zkl}}==

{{trans|Python}}

On my Linux box, telnet seems to only want to connect to port 23.

var users=Dictionary(); // ( handle:socket, ...)

server:=Network.TCPServerSocket.open(PORT);

println("Listening on %s:%s".fmt(server.hostname,server.port));

{{out}}

Start the server: