Chat server: Difference between revisions

People should be able to connect via ‘telnet’, sign on with a nickname, and type messages which will then be seen by all other connected users. Arrivals and departures of chat members should generate appropriate notification messages.

<br><br>

=={{header|Ada}}==

{{libheader|AdaSockets}}

 

with Ada.Command_Line; use Ada.Command_Line;

with Ada.Exceptions; use Ada.Exceptions;

Dummy.Start (Incoming_Socket);

end loop;

 

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|Common Lisp}}==

{{libheader|usocket}}

*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 uses the Go idiom of [http://blog.golang.org/share-memory-by-communicating ''Do not communicate by sharing memory; instead, share memory by communicating'']; there are no explicit locks used, instead Go channels are used to safely synchronize where required.

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}}

/*******************************************************************************

* ChatServer

* Manages connections, users, and chat messages.

******************************************************************************/

 

}

}

/*******************************************************************************

* Chatter

* Represents a single user/connection in the chat server.

******************************************************************************/

 

 

 

};

/*******************************************************************************

* SocketLineBuffer

* whenever a complete line is detected.

******************************************************************************/

 

 

}

};

// 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"))

 

;(print "\n# " (timestamp) ": new request from " (syscall 51 fd))

(fork (on-accept (syscall 51 fd) fd))))

(loop))))

 

(run 8080)

{{Out}}

 

(127.0.0.1 . 55320): see you..

</pre>

=={{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|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

| Connection closed.

| $</pre>

=={{header|Prolog}}==

Works with Swi-Prolog as of Jan 2019.

 

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|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}}==

(formerly Perl 6)

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

{{works with|Rakudo|2016.07}}

my %connections;

}

}

 

Notes:

* It accepts messages encoded in UTF-8.

* It tokenizes the message streams at newline boundaries (using the <tt>Supply.lines</tt> method), which I think makes the most sense for a chat application.

=={{header|Ruby}}==

 

class ChatServer < GServer

#Turn on informational messages

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

 

=={{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|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:

Connection closed by foreign host.

</pre>

{{omit from|AutoHotkey}}

{{omit from|Lilypond}}

{{omit from|Mathematica}}

{{omit from|Maxima}}

{{omit from|PARI/GP|No good way to access network}}

{{omit from|Retro}}