ofrobots/server.go Secret

## server.go
package main

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

func handler(w http.ResponseWriter, r *http.Request) {
	time.Sleep(601 * 1000 * time.Millisecond)
	fmt.Fprintf(w, "Hi there, I love %s!", r.URL.Path[1:])
}

func main() {
	http.HandleFunc("/", handler)
	log.Fatal(http.ListenAndServe(":8080", nil))
}

## server.js

const http = require('http');

const server = http.createServer((req, res) => {
  setTimeout(() => {
    res.end('hello world');
  }, 601 * 1000);
});

server.listen(8080);


## server.py
import time
from http.server import BaseHTTPRequestHandler, HTTPServer

HOST_NAME = 'localhost'
PORT_NUMBER = 8080


class MyHandler(BaseHTTPRequestHandler):
    def do_HEAD(self):
        self.send_response(200)
        self.send_header('Content-type', 'text/html')
        self.end_headers()

    def do_GET(self):
        print('GET %s' % self.path)
        time.sleep(601)
        print('Timeout complete')
        self.respond({'status': 200})

    def handle_http(self, status_code, path):
        self.send_response(status_code)
        self.send_header('Content-type', 'text/html')
        self.end_headers()
        content = '''
        <html><head><title>Title goes here.</title></head>
        <body><p>This is a test.</p>
        <p>You accessed path: {}</p>
        </body></html>
        '''.format(path)
        return bytes(content, 'UTF-8')

    def respond(self, opts):
        response = self.handle_http(opts['status'], self.path)
        self.wfile.write(response)

if __name__ == '__main__':
    server_class = HTTPServer
    httpd = server_class((HOST_NAME, PORT_NUMBER), MyHandler)
    print(time.asctime(), 'Server Starts - %s:%s' % (HOST_NAME, PORT_NUMBER))
    try:
        httpd.serve_forever()
    except KeyboardInterrupt:
        pass
    httpd.server_close()
    print(time.asctime(), 'Server Stops - %s:%s' % (HOST_NAME, PORT_NUMBER))

## server.rb
require 'socket'
server = TCPServer.new 8080

while session = server.accept
  request = session.gets
  puts request

  sleep 601
  session.print "HTTP/1.1 200\r\n" # 1
  session.print "Content-Type: text/html\r\n" # 2
  session.print "\r\n" # 3
  session.print "Hello world! The time is #{Time.now}" #4

  session.close
end

## server.rs
use std::io::prelude::*;
use std::net::TcpStream;
use std::net::TcpListener;
use std::thread;
use std::time;

fn main() {
  let listener = TcpListener::bind("127.0.0.1:8080").unwrap();

  for stream in listener.incoming() {
    let stream = stream.unwrap();

    handle_connection(stream);
  }
}

fn handle_connection(mut stream: TcpStream) {
    let mut buffer = [0; 512];
    stream.read(&mut buffer).unwrap();

    let sec_601 = time::Duration::from_millis(601 * 1000);
    thread::sleep(sec_601);

    let contents = "<h1>Hello world</h1>";
let response = format!("HTTP/1.1 200 OK\r\n\r\n{}", contents);

    stream.write(response.as_bytes()).unwrap();
    stream.flush().unwrap();
}
	package main

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

	func handler(w http.ResponseWriter, r *http.Request) {
	time.Sleep(601 * 1000 * time.Millisecond)
	fmt.Fprintf(w, "Hi there, I love %s!", r.URL.Path[1:])
	}

	func main() {
	http.HandleFunc("/", handler)
	log.Fatal(http.ListenAndServe(":8080", nil))
	}

	const http = require('http');

	const server = http.createServer((req, res) => {
	setTimeout(() => {
	res.end('hello world');
	}, 601 * 1000);
	});

	server.listen(8080);
	import time
	from http.server import BaseHTTPRequestHandler, HTTPServer

	HOST_NAME = 'localhost'
	PORT_NUMBER = 8080


	class MyHandler(BaseHTTPRequestHandler):
	def do_HEAD(self):
	self.send_response(200)
	self.send_header('Content-type', 'text/html')
	self.end_headers()

	def do_GET(self):
	print('GET %s' % self.path)
	time.sleep(601)
	print('Timeout complete')
	self.respond({'status': 200})

	def handle_http(self, status_code, path):
	self.send_response(status_code)
	self.send_header('Content-type', 'text/html')
	self.end_headers()
	content = '''
	<html><head><title>Title goes here.</title></head>
	<body><p>This is a test.</p>
	<p>You accessed path: {}</p>
	</body></html>
	'''.format(path)
	return bytes(content, 'UTF-8')

	def respond(self, opts):
	response = self.handle_http(opts['status'], self.path)
	self.wfile.write(response)

	if __name__ == '__main__':
	server_class = HTTPServer
	httpd = server_class((HOST_NAME, PORT_NUMBER), MyHandler)
	print(time.asctime(), 'Server Starts - %s:%s' % (HOST_NAME, PORT_NUMBER))
	try:
	httpd.serve_forever()
	except KeyboardInterrupt:
	pass
	httpd.server_close()
	print(time.asctime(), 'Server Stops - %s:%s' % (HOST_NAME, PORT_NUMBER))
	require 'socket'
	server = TCPServer.new 8080

	while session = server.accept
	request = session.gets
	puts request

	sleep 601
	session.print "HTTP/1.1 200\r\n" # 1
	session.print "Content-Type: text/html\r\n" # 2
	session.print "\r\n" # 3
	session.print "Hello world! The time is #{Time.now}" #4

	session.close
	end
	use std::io::prelude::*;
	use std::net::TcpStream;
	use std::net::TcpListener;
	use std::thread;
	use std::time;

	fn main() {
	let listener = TcpListener::bind("127.0.0.1:8080").unwrap();

	for stream in listener.incoming() {
	let stream = stream.unwrap();

	handle_connection(stream);
	}
	}

	fn handle_connection(mut stream: TcpStream) {
	let mut buffer = [0; 512];
	stream.read(&mut buffer).unwrap();

	let sec_601 = time::Duration::from_millis(601 * 1000);
	thread::sleep(sec_601);

	let contents = "<h1>Hello world</h1>";
	let response = format!("HTTP/1.1 200 OK\r\n\r\n{}", contents);

	stream.write(response.as_bytes()).unwrap();
	stream.flush().unwrap();
	}