Hello world/Web server - Rosetta Code http://rosettacode.org/wiki/Hello_world/Web_server

Hello world/Web server

From Rosetta Code < Hello world

The browser is the new GUI! Hello world/Web The task is to serve our standard text "Goodbye, World!" to server http://localhost:8080/ so that it can be viewed with a web browser. You are The provided solution must start or implement a server that accepts encouraged to multiple client connections and serves text as requested. solve this task according to the task description, Note that starting a web browser or opening a new window with using any language you this URL is not part of the task. Additionally, it is permissible to may know. serve the provided page as a plain text file (there is no requirement to serve properly formatted HTML here). The browser will generally do the right thing with simple text like this.

Contents

1 Ada 2 AWK 3 BBC BASIC 4 C 5 C++ 6 C# 7 D 8 Delphi 9 Dylan.NET 10 Erlang 11 Fantom 12 Go 13 Haskell 14 Io 15 J 16 Java 17 JavaScript 18 Liberty BASIC 19 Modula-2 20 NetRexx 21 Objeck 22 OCaml 23 Opa 24 Perl 25 Perl 6 26 PicoLisp 27 Prolog 28 PureBasic 29 PHP 30 Python

1 sur 18 19/07/2013 19:57 Hello world/Web server - Rosetta Code http://rosettacode.org/wiki/Hello_world/Web_server

31 Racket 32 REALbasic 33 Ruby 34 Run BASIC 35 Salmon 36 Seed7 37 Smalltalk 38 Tcl

Ada

Library: AWS

Uses many defaults, such as 5 max simultaneous connections.

with AWS; use AWS; with AWS. Response ; with AWS. Server ; with AWS. Status ; with Ada. Text_IO ; use Ada. Text_IO ; procedure HelloHTTP is function CB (Request : Status. Data ) return Response. Data is pragma Unreferenced (Request ); begin return Response. Build ("text/html" , "Hello world!" ); end CB; TheServer : Server. HTTP ; ch : Character; begin Server. Start (TheServer, "Rosettacode" , Callback => CB'Unrestricted_Access, Port => 8080 ); Put_Line ("Press any key to quit." ); Get_Immediate (ch ); Server. Shutdown (TheServer ); end HelloHTTP;

AWK

With GNU AWK (gawk) a simple web server can be implemented. The example is taken from here [1] (http://www.gnu.org/software/gawk/manual/gawkinet/gawkinet.html#Primitive-Service) (Documentation is licensed under GNU Free Documentation License, Version 1.3)

#!/usr/bin/gawk -f BEGIN { RS = ORS = "\r\n" HttpService = "/inet/tcp/8080/0/0" Hello = "" \ "" \ "

Hello, world

" Len = length (Hello ) + length (ORS ) print "HTTP/1.0 200 OK" |& HttpService print "Content-Length: " Len ORS |& HttpService print Hello |& HttpService while ((HttpService |& getline ) > 0) continue ; close (HttpService ) }

BBC BASIC

2 sur 18 19/07/2013 19:57 Hello world/Web server - Rosetta Code http://rosettacode.org/wiki/Hello_world/Web_server

Works with : BBC BASIC for Windows

This explicitly supports multiple concurrent connections.

INSTALL @lib$+"SOCKLIB" PROC_initsockets

maxSess% = 8 DIM sock%(maxSess%-1), rcvd$(maxSess%-1), Buffer% 255

ON ERROR PRINT REPORT$ : PROC_exitsockets : END ON CLOSE PROC_exitsockets : QUIT

port$ = "8080" host$ = FN_gethostname PRINT "Host name is " host$

listen% = FN_tcplisten(host$, port$) PRINT "Listening on port ";port$

REPEAT socket% = FN_check_connection(listen%) IF socket% THEN FOR i% = 0 TO maxSess%-1 IF sock%(i%) = 0 THEN sock%(i%) = socket% rcvd$(i%) = "" PRINT "Connection on socket "; sock%(i%) " opened" EXIT FOR ENDIF NEXT i% listen% = FN_tcplisten(host$, port$) ENDIF

FOR i% = 0 TO maxSess%-1 IF sock%(i%) THEN res% = FN_readsocket(sock%(i%), Buffer%, 256) IF res% >= 0 THEN Buffer%?res% = 0 rcvd$(i%) += $$Buffer% IF LEFT$(rcvd$(i%),4) = "GET " AND ( \ \ RIGHT$(rcvd$(i%),4) = CHR$13+CHR$10+CHR$13+CHR$10 OR \ \ RIGHT$(rcvd$(i%),4) = CHR$10+CHR$13+CHR$10+CHR$13 OR \ \ RIGHT$(rcvd$(i%),2) = CHR$10+CHR$10 ) THEN rcvd$(i%) = "" IF FN_writelinesocket(sock%(i%), "HTTP/1.0 200 OK") IF FN_writelinesocket(sock%(i%), "Content-type: text/html") IF FN_writelinesocket(sock%(i%), "") IF FN_writelinesocket(sock%(i%), "") IF FN_writelinesocket(sock%(i%), "

Hello World!

") IF FN_writelinesocket(sock%(i%), "") PROC_closesocket(sock%(i%)) PRINT "Connection on socket " ; sock%(i%) " closed (local)" sock%(i%) = 0 ENDIF ELSE PROC_closesocket(sock%(i%)) PRINT "Connection on socket " ; sock%(i%) " closed (remote)" sock%(i%) = 0 ENDIF ENDIF NEXT i%

WAIT 0 UNTIL FALSE END

C

This is, um, slightly longer than what other languages would be.

#include #include #include #include

3 sur 18 19/07/2013 19:57 Hello world/Web server - Rosetta Code http://rosettacode.org/wiki/Hello_world/Web_server

#include #include #include #include #include

char response [] = "HTTP/1.1 200 OK\r\n" "Content-Type: text/html; charset=UTF-8\r\n\r\n" "" "" "

Goodbye, world!

\r\n";

int main () { int one = 1, client_fd; struct sockaddr_in svr_addr, cli_addr; socklen_t sin_len = sizeof (cli_addr );

int sock = socket (AF_INET, SOCK_STREAM, 0); if (sock < 0) err (1, "can't open socket" );

setsockopt (sock, SOL_SOCKET, SO_REUSEADDR, &one, sizeof (int ));

int port = 8080 ; svr_addr. sin_family = AF_INET; svr_addr. sin_addr .s_addr = INADDR_ANY; svr_addr. sin_port = htons (port );

if (bind (sock, (struct sockaddr *) &svr_addr, sizeof (svr_addr )) == -1) { close (sock ); err (1, "Can't bind" ); }

listen (sock, 5); while (1) { client_fd = accept (sock, (struct sockaddr *) &cli_addr, &sin_len ); printf ("got connection\n");

if (client_fd == -1) { perror ("Can't accept" ); continue ; }

write (client_fd, response, sizeof (response ) - 1); /*-1:'\0'*/ close (client_fd ); } }

C++

C version compiles as C++ (known for G++ on Linux)

C#

using System.Text; using System.Net.Sockets; using System.Net;

namespace WebServer { class GoodByeWorld { static void Main (string [] args ) { const string msg = "\n\nGoodbye, world!\n\n\n"; const int port = 8080 ; bool serverRunning = true ;

TcpListener tcpListener = new TcpListener (IPAddress.Any , port ); tcpListener.Start ();

4 sur 18 19/07/2013 19:57 Hello world/Web server - Rosetta Code http://rosettacode.org/wiki/Hello_world/Web_server

while (serverRunning ) { Socket socketConnection = tcpListener.AcceptSocket (); byte [] bMsg = Encoding.ASCII .GetBytes (msg.ToCharArray (), 0, (int )msg.Length ); socketConnection.Send (bMsg ); socketConnection.Disconnect (true ); } } } }

D

Using sockets only, also shows use of heredoc syntax, std.array.replace, and casting to bool to satisfy the while conditional.

import std. socket , std. array ;

ushort port = 8080 ;

void main () { Socket listener = new TcpSocket; listener. bind (new InternetAddress (port )); listener. listen (10 );

Socket currSock;

while (cast (bool )(currSock = listener. accept ())) { currSock. sendTo (replace (q"EOF HTTP/1.1 200 OK Content-Type: text/html; charset=UTF-8

Hello, world! EOF" , "\n", "\r\n")); currSock. close (); } }

Delphi

program HelloWorldWebServer;

{$APPTYPE CONSOLE}

uses SysUtils, IdContext, IdCustomHTTPServer, IdHTTPServer;

type TWebServer = class private FHTTPServer: TIdHTTPServer; public constructor Create; destructor Destroy; override ; procedure HTTPServerCommandGet (AContext: TIdContext; ARequestInfo: TIdHTTPRequestInfo; AResponseInfo: TIdHTTPResponseInfo ); end ;

constructor TWebServer.Create ; begin FHTTPServer := TIdHTTPServer.Create (nil ); FHTTPServer.DefaultPort := 8080 ; FHTTPServer.OnCommandGet := HTTPServerCommandGet; FHTTPServer.Active := True ; end ;

5 sur 18 19/07/2013 19:57 Hello world/Web server - Rosetta Code http://rosettacode.org/wiki/Hello_world/Web_server

destructor TWebServer.Destroy ; begin FHTTPServer.Active := False ; FHTTPServer.Free ; inherited Destroy; end ;

procedure TWebServer.HTTPServerCommandGet (AContext: TIdContext; ARequestInfo: TIdHTTPRequestInfo; AResponseInfo: TIdHTTPResponseInfo ); begin AResponseInfo.ContentText := 'Goodbye, World!' ; end ;

var lWebServer: TWebServer; begin lWebServer := TWebServer.Create ; try Writeln ('Delphi Hello world/Web server ' ); Writeln ('Press Enter to quit' ); Readln; finally lWebServer.Free ; end ; end .

Dylan.NET

//compile with dylan.NET 11.2.9.6 or later!! #refstdasm "mscorlib.dll" #refstdasm "System.dll"

import System.Text import System.Net.Sockets import System.Net

assembly helloweb exe ver 1.1.0.0

namespace WebServer

class public auto ansi GoodByeWorld

method public static void main(var args as string[])

var msg as string = c"\n\nGoodbye, world!\n\n\n" var port as integer = 8080 var serverRunning as boolean = true

var tcpListener as TcpListener = new TcpListener(IPAddress::Any, port) tcpListener::Start()

do while serverRunning var socketConnection as Socket = tcpListener::AcceptSocket() var bMsg as byte[] = Encoding::get_ASCII()::GetBytes(msg::ToCharArray (), 0, msg::get_Length()) socketConnection::Send(bMsg) socketConnection::Disconnect(true) end do

end method

end class

end namespace

Erlang

Using builtin HTTP server with call back to do/1. It only lasts 30 seconds (30000 milliseconds), then it is stopped. I fail to see how a longer time will serve any purpose.

6 sur 18 19/07/2013 19:57 Hello world/Web server - Rosetta Code http://rosettacode.org/wiki/Hello_world/Web_server

-module ( hello_world_web_server ).

-export ( [do/1, httpd_start/2, httpd_stop/1, task/0] ).

do ( _Data ) -> {proceed, [{response,{200 ,"Goodbye, World!" }}]}.

httpd_start ( Port, Module ) -> Arguments = [{bind_address, "localhost" }, {port, Port }, {ipfamily, inet }, {modules, [Module ]}, {server_name,erlang :atom_to_list (Module )}, {server_root,"." }, {document_root,"." }], {ok, Pid } = inets :start ( httpd, Arguments, stand_alone ), Pid.

httpd_stop ( Pid ) -> inets :stop ( stand_alone, Pid ).

task () -> Pid = httpd_start ( 8080 , ?MODULE ), time r: sleep ( 30000 ), httpd_stop ( Pid ).

Fantom

using web using wisp

const class HelloMod : WebMod // provides the content { override Void onGet () { res.headers["Content-Type"] = "text/plain; charset=utf-8" res.out.print ("Goodbye, World!") } }

class HelloWeb { Void main () { WispService // creates the web service { port = 8080 root = HelloMod() }.start

while (true) {} // stay running } }

Go

package main

import ( "fmt" "log" "net/http" )

func main() { http.HandleFunc("/" , func (w http.ResponseWriter, req *http. Request ) { fmt.Fprintln(w, "Goodbye, World!" ) }) log.Fatal (http.ListenAndServe (":8080" , nil )) }

Haskell

7 sur 18 19/07/2013 19:57 Hello world/Web server - Rosetta Code http://rosettacode.org/wiki/Hello_world/Web_server

Lightweightly concurrent "hello world" web server using the conduit (http://www.yesodweb.com /book/conduits) stack:

{-# LANGUAGE OverloadedStrings #-}

import Data.ByteString.Char8 () import Data.Conduit ( ($$ ), yield ) import Data.Conduit.Network ( ServerSettings (.. ), runTCPServer )

main :: IO () main = runTCPServer (ServerSettings 8080 "127.0.0.1" ) $ const (yield response $$ ) where response = "HTTP/1.0 200 OK\nContent-Length: 16\n\nGoodbye, World!\n"

Or using only "standard" features (base (http://hackage.haskell.org/package/base) , bytestring (http://hackage.haskell.org/package/bytestring) and network (http://hackage.haskell.org/package /network) from the Haskell Platform (http://hackage.haskell.org/platform/) ):

{-# LANGUAGE OverloadedStrings #-}

import Data.ByteString.Char8 () import Network hiding ( accept ) import Network.Socket ( accept ) import Network.Socket.ByteString ( sendAll ) import Control.Monad ( forever ) import Control.Exception ( bracket, finally ) import Control.Concurrent ( forkIO )

main :: IO () main = bracket (listenOn $ PortNumber 8080 ) sClose loop where loop s = forever $ forkIO . request . fst =<< accept s request c = sendAll c response `finally` sClose c response = "HTTP/1.0 200 OK\nContent-Length: 16\n\nGoodbye, World!\n"

Both works like this:

$ curl http://localhost:8080/ Goodbye, World! # httperf --port=8080 --num-conns=10000 Request rate: 4549.5 req/s (0.2 ms/req) # httperf --port=8080 --num-conns=10000 --num-calls=2 Request rate: 8202.5 req/s (0.1 ms/req) Errors: total 10000 client-timo 0 socket-timo 0 connrefused 0 connreset 10000

Comparing to nginx (http://www.nginx.org/) :

# httperf --num-conns=10000 Request rate: 3613.2 req/s (0.3 ms/req) # httperf --num-conns=10000 --num-calls=10 Request rate: 9952.6 req/s (0.1 ms/req) # httperf --num-conns=10000 --num-calls=100 Request rate: 12341.0 req/s (0.1 ms/req)

which serve without any errors.

Io

WebRequest := Object clone do ( handleSocket := method (aSocket, aSocket streamWrite ("Goodbye, World!" ) aSocket close ) )

8 sur 18 19/07/2013 19:57 Hello world/Web server - Rosetta Code http://rosettacode.org/wiki/Hello_world/Web_server

WebServer := Server clone do ( setPort (8080 ) handleSocket := method (aSocket, WebRequest clone asyncSend (handleSocket (aSocket )) ) )

WebServer start

J

If the desire is to use the browser as a gui, the easiest thing to do would be to download (http://www.jsoftware.com/stable.htm) j7 (http://www.jsoftware.com/docs/help701 /user/relhigh.htm) , edit the jhs script to start on port 8080, start jhs, visit http://127.0.0.1:8080/jijx then enter the text:

'Goodbye, World!'

This will compute the desired result and display it (actually, it will be displayed twice since the original string will also be displayed). This would be even simpler if you could just use the default jhs port (65001)... Alternatively, a jhs form could be used (but this would not have the exact url structure specified).

However, if the desire is to implement the task exactly, any of approaches at j:JWebServer might be used.

For example, here is a web server which ignores the client's request and always returns Goodbye, World:

hello=: verb define 8080 hello y NB. try to use port 8080 by default : port=: x require 'socket' coinsert 'jsocket' sdclose ; sdcheck sdgetsockets '' server=: {. ; sdcheck sdsocket '' sdcheck sdbind server; AF_INET; '' ; port sdcheck sdlisten server, 1 while. 1 do. while. server e. ready=: >{. sdcheck sdselect (sdcheck sdgetsockets '' ),'' ;'' ;< 1e3 do. sdcheck sdaccept server end. for_socket. ready do. request=: ; sdcheck sdrecv socket, 65536 0 sdcheck (socket responseFor request) sdsend socket, 0 sdcheck sdclose socket end. end. )

responseFor=: dyad define 'HTTP/1.0 200 OK' ,CRLF, 'Content-Type: text/plain' ,CRLF,CRLF, 'Goodbye, World!' ,CRLF )

To deploy this server, once it has been defined, run

hello ''

This version works because reasonable http requests fit in a single tcp packet. (And note that the

9 sur 18 19/07/2013 19:57 Hello world/Web server - Rosetta Code http://rosettacode.org/wiki/Hello_world/Web_server

server waits for one tcp packet before responding.) If parsing of the request is desired, one of the more complicated implementations at j:JWebServer should be used instead (but that's not really relevant for this task, except perhaps to require complete headers before responding, with broken browsers which send multiple tcp packets for the request).

Java

Multiple requests will be served in the order that they reach the server, with a queue size limit of 50 waiting requests imposed by default in the ServerSocket class (may be changed by adding a second positive integer argument to the ServerSocket constructor).

import java.io.IOException ; import java.io.PrintWriter ; import java.net.ServerSocket ; import java.net.Socket ;

public class HelloWorld { public static void main (String [] args ) throws IOException { ServerSocket listener = new ServerSocket (8080 ); while (true ){ Socket sock = listener. accept (); new PrintWriter (sock. getOutputStream (), true ). println ("Goodbye, World!" ); sock. close (); } } }

JavaScript

Works with : Node.js

var http = require ('http' );

http. createServer (function (req, res ) { res. writeHead (200 , {'Content-Type' : 'text/plain' }); res. end ('Goodbye, World!\n'); }).listen (8080 , '127.0.0.1' );

It scales:

$ curl http://localhost:8080/ Goodbye, World! # httperf --port=8080 --num-conns=10000 Request rate: 1813.1 req/s (0.6 ms/req) # httperf --port=8080 --num-conns=10000 --num-calls=10 Request rate: 4869.1 req/s (0.2 ms/req) # httperf --port=8080 --num-conns=10000 --num-calls=100 Request rate: 5689.0 req/s (0.2 ms/req)

with no errors.

Liberty BASIC

This is difficult, although possible, in Liberty BASIC, but it's close relative Run BASIC is designed for serving webpages easily. The task becomes simply ..

print "hello world!"

10 sur 18 19/07/2013 19:57 Hello world/Web server - Rosetta Code http://rosettacode.org/wiki/Hello_world/Web_server

Modula-2

This is a CGI executable:

MODULE access;

FROM InOut IMPORT WriteString, WriteLn;

BEGIN WriteString ("Content-Type : text/plain"); WriteLn; WriteLn; WriteString ("Hello web wide world."); WriteLn END access.

NetRexx

Translation of : Java

/* NetRexx */ options replace format comments java crossref symbols binary

class RHelloWorldWebServer public

properties public constant isTrue = boolean (1 == 1) isFalse = boolean (1 \== 1) greeting1 = "Goodbye, World!" greeting2 = '' - || 'HTTP/1.1 200 OK\r\n' - || 'Content-Type: text/html; charset=UTF-8\r\n\r\n' - || '\r\n' - || '\r\n' - || '

\r\n' - || '\r\n' - || '\r\n' - || '

\r\n' - || '\r\n' - || '

' || greeting1 || '

\r\n' - || '\r\n' - || '\r\n' - || ''

properties static inheritable terminate = isFalse -- TODO: provide a less draconian means to terminate the listener loop

method main (args = String []) public static signals IOException listener = ServerSocket (8080 ) loop label listener forever if terminate then leave listener sock = listener.accept () PrintWriter (sock.getOutputStream (), isTrue ).println (greeting2 ) sock.close () end listener return

Objeck

use Net; use Concurrency;

bundle Default { class GoodByeWorld {

11 sur 18 19/07/2013 19:57 Hello world/Web server - Rosetta Code http://rosettacode.org/wiki/Hello_world/Web_server

function : Main (args : String []) ~ Nil { server := TCPSocketServer-> New (8080 ); if (server-> Listen (5)) { while (true ) { client := server-> Accept (); client-> WriteString ("\n\nGoodbye, world!\n\n\n"); client-> Close (); }; }; server-> Close (); } } }

OCaml

This code is derived from this ocaml-unix documentation (http://ocamlunix.forge.ocamlcore.org /sockets.html#htoc54) .

let try_finalise f x finally y = let res = try f x with e -> finally y; raise e in finally y; res

let rec restart_on_EINTR f x = try f x with Unix .Unix_error (Unix .EINTR, _, _ ) -> restart_on_EINTR f x

let double_fork_treatment server service (client_descr, _ as client ) = let treat () = match Unix .fork () with | 0 -> if Unix .fork () <> 0 then exit 0; Unix .close server; service client; exit 0 | k -> ignore (restart_on_EINTR (Unix .waitpid []) k ) in try_finalise treat () Unix .close client_descr

let install_tcp_server_socket addr = let s = Unix .socket Unix .PF_INET Unix .SOCK_STREAM 0 in try Unix .bind s addr; Unix .listen s 10 ; s with e -> Unix .close s; raise e

let tcp_server treat_connection addr = ignore (Sys .signal Sys .sigpipe Sys .Signal_ignore ); let server_sock = install_tcp_server_socket addr in while true do let client = restart_on_EINTR Unix .accept server_sock in treat_connection server_sock client done

let server () = let port = 8080 in let host = (Unix .gethostbyname (Unix .gethostname ())).Unix .h_addr_list.(0) in let addr = Unix .ADDR_INET (host, port ) in let treat sock (client_sock, client_addr as client ) = let service (s, _ ) = let response = "\ HTTP/1.1 200 OK\r\n\ Content-Type: text/html; charset=UTF-8\r\n\r\n\ \ \

Goodbye, world!

\r\n" in Unix .write s response 0 (String .length response ); in double_fork_treatment sock service client in tcp_server treat addr

12 sur 18 19/07/2013 19:57 Hello world/Web server - Rosetta Code http://rosettacode.org/wiki/Hello_world/Web_server

let _ = Unix .handle_unix_error server ()

Opa

From Opa documentation (http://doc.opalang.org/index.html#_a_first_peek_at_opa) :

server = one_page_server ("Hello" , -> <>Goodbye, world )

Compile and run:

opa file.opa --

Perl

use Socket;

my $port = 8080 ; my $protocol = getprotobyname ( "tcp" );

socket ( SOCK, PF_INET, SOCK_STREAM, $protocol ) or die "couldn't open a socket: $!" ; # PF_INET to indicate that this socket will connect to the internet domain # SOCK_STREAM indicates a TCP stream, SOCK_DGRAM would indicate UDP communication

setsockopt ( SOCK, SOL_SOCKET, SO_REUSEADDR, 1 ) or die "couldn't set socket options: $!" ; # SOL_SOCKET to indicate that we are setting an option on the socket instead of the protocol # mark the socket reusable

bind ( SOCK, sockaddr_in ($port, INADDR_ANY ) ) or die "couldn't bind socket to port $port: $!" ; # bind our socket to $port, allowing any IP to connect

listen ( SOCK, SOMAXCONN ) or die "couldn't listen to port $port: $!" ; # start listening for incoming connections

while ( accept (CLIENT, SOCK ) ){ print CLIENT "HTTP/1.1 200 OK\r\n" . "Content-Type: text/html; charset=UTF-8\r\n\r\n" . "Goodbye, world!\r\n " close CLIENT; }

Various modules exist for using sockets, including the popular IO::Socket which provi des a simpler and more friendly OO interface for the socket layer. Here is the solution using this module:

Library: IO::Socket::INETINET

use IO:: Socket :: INET ;

my $sock = new IO:: Socket :: INET ( LocalAddr => "127.0.0.1:8080" , Listen => 1, Reuse => 1, ) or die "Could not create socket: $!" ;

while ( my $client = $sock-> accept () ){ print $client "HTTP/1.1 200 OK\r\n" . "Content-Type: text/html; charset=UTF-8\r\n\r\n" . "Goodbye, world!\r \n close $client; }

Using Perl's glue power, provide a suicide note with visitor counter via netcat:

13 sur 18 19/07/2013 19:57 Hello world/Web server - Rosetta Code http://rosettacode.org/wiki/Hello_world/Web_server

while (++ (our $vn )) { open NC, "|-" , qw (nc -l -p 8080 -q 1); print NC "HTTP/1.0 200 OK\xd\xa" , "Content-type: text/plain; charset=utf-8\xd\xa\xd\xa" , "Goodbye, World! (hello, visitor No. $vn!)\xd\xa" ; }

Here's another solution using Plack (may be found on CPAN):

use Plack:: Runner ; my $app = sub { return [ 200 , [ 'Content-Type' => 'text/html; charset=UTF-8' ], [ 'Goodbye, world!' ] ] }; my $runner = Plack:: Runner -> new ; $runner-> parse_options ('--host' => 'localhost' , '--port' => 8080 ); $runner-> run ($app );

When using plackup, then this may be compressed to one line:

my $app = sub { return [ 200 , [ 'Content-Type' => 'text/html; charset=UTF-8' ], [ 'Goodbye, world!';

for (;; ) { // @ is used to stop PHP from spamming with error messages if there is no connection if ($client = @socket_accept ($socket )) { socket_write ($client, "HTTP/1.1 200 OK\r\n" . "Content-length: " . strlen ($msg ) . "\r\n" . "Content-Type: text/html; charset=UTF-8\r\n\r\n" . $msg ); } else usleep (100000 ); // limits CPU usage by sleeping after doing every request }

15 sur 18 19/07/2013 19:57 Hello world/Web server - Rosetta Code http://rosettacode.org/wiki/Hello_world/Web_server

Python

def app (environ, start_response ): start_response ('200 OK' , []) yield "Goodbye, World!"

if __name__ == '__main__' : from wsgiref. simple_server import make_server server = make_server ('127.0.0.1' , 8080 , app ) server. serve_forever ()

Racket

#lang racket (require web-server/servlet web-server/servlet-env) (define (start req) (response/xexpr "Goodbye, World!")) (serve/servlet start #:port 8080 #:servlet-path "/")

REALbasic

Class HTTPSock Inherits TCPSocket Event Sub DataAvailable() Dim headers As New InternetHeaders headers.AppendHeader( "Content-Length" , Str(LenB( "Goodbye, World!" ))) headers.AppendHeader( "Content-Type" , "text/plain" ) headers.AppendHeader( "Content-Encoding" , "identity" ) headers.AppendHeader( "Connection" , "close" ) Dim data As String = "HTTP/1.1 200 OK" + EndOfLine.Windows + headers.Source + EndOfLine.Windows + EndOfLine.Windows + Me.Write(data) Me. Close End Sub End Class

Class HTTPServ Inherits ServerSocket Event Sub AddSocket() As TCPSocket Return New HTTPSock End Sub End Class

Class App Inherits Application Event Sub Run(Args() As String ) Dim sock As New HTTPServ sock.Port = 8080 sock.Listen() While True App. DoEvents Wend End Sub End Class

Ruby

Using the WEBrick module from Ruby's standard library.

require 'webrick' server = WEBrick::HTTPServer.new (:Port => 8080 ) server. mount_proc ('/' ) {|request, response| response. body = "Goodbye, World!" }

16 sur 18 19/07/2013 19:57 Hello world/Web server - Rosetta Code http://rosettacode.org/wiki/Hello_world/Web_server

trap ("INT" ) {server. shutdown } server. start

Using the sinatra (http://www.sinatrarb.com/) gem:

require 'sinatra' get ("/" ) { "Goodbye, World!" }

Run BASIC

html "Hello World!"

Salmon

use "http.salm" : "http.si";

/* Don't do any logging. */ procedure log(...) { };

simple_http_server(8080, procedure(header, connection) { respond_text(connection, "Goodbye, World!"); });

Seed7

The code below was inspired by the example code for the function openInetListener (http://seed7.sourceforge.net/libraries/listener.htm#openInetListener%28in_integer%29) .

$ include "seed7_05.s7i"; include "listener.s7i";

const proc: main is func local var listener: aListener is listener.value; var file: sock is STD_NULL; begin aListener := openInetListener(8080); listen(aListener, 10); while TRUE do sock := accept(aListener); write(sock, "HTTP/1.1 200 OK\r\n\ \Content-Type: text/html; charset=UTF-8\r\n\ \\r\n\ \Hello, world!\n"); close(sock); end while; end func;

Smalltalk

Works with : Smalltalk/X

starting server:

Smalltalk loadPackage: 'stx:goodies/webServer' . "usually already loaded" |myServer service|

myServer := HTTPServer startServerOnPort:8082. service := HTTPPluggableActionService new.

17 sur 18 19/07/2013 19:57 Hello world/Web server - Rosetta Code http://rosettacode.org/wiki/Hello_world/Web_server

service register: [:request | self halt: 'debugging' . request reply: '

Hello World

' ] as: 'hello' . service linkNames:#('/' ). service registerServiceOn: myServer. myServer start.

Be aware that the above is an ad-hoc minimal scripting example. Normally, a service subclass is used and response handlers are defined as methods of it (not as action blocks). Also, services and HTML generation is usually done using a framework (at least DOM-based, but usually a higher level toolkit). Especially take a look at smalltalk frameworks like Aida, Seaside, VisualWave etc.

Tcl

This version is adapted from the Tcler's Wiki (http://wiki.tcl.tk/28412) .

proc accept {chan addr port } { while {[gets $chan ] ne "" } {} puts $chan "HTTP/1.1 200 OK\nConnection: close\nContent-Type: text/plain\n" puts $chan "Goodbye, World!" close $chan } socket -server accept 8080 vwait forever

Retrieved from "http://rosettacode.org/mw/index.php?title=Hello_world/Web_server& oldid=160111" Categories: Programming Tasks Networking and Web Interaction Ada AWS AWK BBC BASIC C C++ C sharp D Delphi Dylan.NET Erlang Fantom Go Haskell Io J Java JavaScript Liberty BASIC Modula-2 NetRexx Objeck OCaml Opa Perl Perl 6 PicoLisp Prolog PureBasic PHP Python Racket REALbasic Ruby Run BASIC Salmon Seed7 Smalltalk Tcl GUISS/Omit Locomotive Basic/Omit Lotus 123 Macro Scripting/Omit ML/I/Omit ZX Spectrum Basic/Omit Retro/Omit Maxima/Omit

This page was last modified on 4 June 2013, at 06:49. Content is available under GNU Free Documentation License 1.2.

18 sur 18 19/07/2013 19:57