Welcome to my website
\\n \\n \\n\")])]),_c('p',[_vm._v(\"This is HTML. HTML means Hypertext Markup Language. It’s not a programming language but a \"),_c('strong',[_vm._v(\"markup\")]),_vm._v(\" language.\")]),_c('p',[_vm._v(\"With HTML, you can annotate a document to warn the web browser to apply a specific format to your content.\")]),_c('div',{staticClass:\"anchor\",attrs:{\"id\":\"html-basics\"}}),_c('BuyCopyInvite'),_c('h1',{attrs:{\"data-number\":\"4\"}},[_c('span',{staticClass:\"header-section-number\"},[_vm._v(\"4\")]),_vm._v(\" HTML basics \"),_c('a',{attrs:{\"href\":\"#html-basics\"}},[_c('b-icon-link45deg',{staticClass:\"heading-link-icon\",attrs:{\"font-scale\":\"0.7\"}})],1)]),_c('p',[_vm._v(\"Let’s detail the code of the first example :\")]),_c('pre',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\"}},[_vm._v(\"\\n\\n\\n\")])]),_c('ul',[_c('li',[_c('p',[_vm._v(\"First, you can note that the document begins by \"),_c('span',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\",\"style\":\"display: inline\"}},[_vm._v(\"\")])]),_vm._v(\". This line tells the web browser that what follows is written using HTML.\")])]),_c('li',[_c('p',[_vm._v(\"The document is composed of elements. Each element begins with a \"),_c('strong',[_vm._v(\"start tag\")]),_vm._v(\" and ends with an \"),_c('strong',[_vm._v(\"end tag\")]),_vm._v(\".\")])]),_c('li',[_c('p',[_vm._v(\"Elements can be nested. I can put one element inside another element.\")])]),_c('li',[_c('p',[_vm._v(\"The first element begins with the start tag \"),_c('span',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\",\"style\":\"display: inline\"}},[_vm._v(\"\")])]),_vm._v(\" and ends with the end tag \"),_c('span',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\",\"style\":\"display: inline\"}},[_vm._v(\"\")])]),_vm._v(\". It says between the start and the end tag; we will have other HTML elements.\")])]),_c('li',[_c('p',[_vm._v(\"Inside this first element, we have another element :\")])])]),_c('pre',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\"}},[_vm._v(\"\\nWelcome to my website
\\n \\n\")])]),_c('ul',[_c('li',[_c('p',[_vm._v(\"In the body, we have two elements and one comment\")]),_c('ul',[_c('li',[_c('p',[_vm._v(\"The first element is a heading of level 1: \"),_c('span',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\",\"style\":\"display: inline\"}},[_vm._v(\"Welcome to my website
\")])]),_vm._v(\".\")])]),_c('li',[_c('p',[_vm._v(\"A comment \"),_c('span',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\",\"style\":\"display: inline\"}},[_vm._v(\"\")])])])])])]),_c('li',[_c('p',[_vm._v(\"On the rendered web page, you will not see the tags. The web browser uses tags to render the page.\")])])]),_c('div',{staticClass:\"anchor\",attrs:{\"id\":\"summary\"}}),_c('h4',{attrs:{\"data-number\":\"4.0.0.1\"}},[_c('span',{staticClass:\"header-section-number\"},[_vm._v(\"4.0.0.1\")]),_vm._v(\" Summary : \"),_c('a',{attrs:{\"href\":\"#summary\"}},[_c('b-icon-link45deg',{staticClass:\"heading-link-icon\",attrs:{\"font-scale\":\"0.7\"}})],1)]),_c('ul',[_c('li',[_c('p',[_vm._v(\"With HTML, you can build web pages.\")])]),_c('li',[_c('p',[_vm._v(\"Elements begin with a start tag and an end tag.\")])]),_c('li',[_c('p',[_vm._v(\"Tags denote elements and are interpreted by the browser.\")])]),_c('li',[_c('p',[_vm._v(\"Elements can be nested.\")])]),_c('li',[_c('p',[_vm._v(\"Here is the skeleton of a simple web page :\")])])]),_c('pre',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\"}},[_vm._v(\"\\n\\n \\nThe Golang Hotel is a relaxing place !
\\nWe offer 20% discount if you call this number : 1234567891
\\n\\n\")])]),_c('p',[_vm._v(\"And the design \"),_c('strong',[_vm._v(\"B\")]),_vm._v(\" :\")]),_c('pre',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\"}},[_vm._v(\"\\n\\nThe Golang Hotel is a relaxing place !
We offer 20% discount if you call this number : 1234567891
\\\")\\n\\n // load design B\\n designB := []byte(\\\"The Golang Hotel is a relaxing place !
We offer 20% discount if you call this number : 1234567891
\\\")\\n\\n designB := []byte(\\\"The Golang Hotel is a relaxing place !
We offer 20% discount if you call this number : 1234567891
\\\")\\n\\n designB := []byte(\\\"What is an HTTP Server?
What is an HTTP Client?
What is HTML, and how to create an HTML file?
What are HTTP and IP?
How an HTTP request is formed
How an HTTP response is formed
How to build a basic webserver.
HTTP
HTML
Request, response
Client, Server
DNS
Handler
Interface implementation
On figure 1 you can see a very simple web page.
\nWhat is behind that? The web browser will load source code. This source code is then transformed into what you see on the screen. Here is the source code that generates the page in figure 1:
\n<!DOCTYPE html>\n<html>\n <head>\n <title>Title of page</title>\n </head>\n <body>\n <h1>Title</h1>\n <p>Welcome to my website</p>\n <!-- comment, ignored by the browser -->\n </body>\n</html>This is HTML. HTML means Hypertext Markup Language. It’s not a programming language but a markup language.
\nWith HTML, you can annotate a document to warn the web browser to apply a specific format to your content.
\n\nLet’s detail the code of the first example :
\n<!DOCTYPE html>\n<html>\n\n</html>First, you can note that the document begins by <!DOCTYPE html>. This line tells the web browser that what follows is written using HTML.
The document is composed of elements. Each element begins with a start tag and ends with an end tag.
Elements can be nested. I can put one element inside another element.
The first element begins with the start tag <html> and ends with the end tag </html>. It says between the start and the end tag; we will have other HTML elements.
Inside this first element, we have another element :
<head>\n <title>Title of page</title>\n</head>Start tag is <head> and end tag is </head>. This is the head section. Inside it, we will find metadata about the document. Metadata is information related to the document.
The next element is the body. It is the contents of the document: what will be displayed on the browser!
<body>\n <h1>Title</h1>\n <p>Welcome to my website</p>\n <!-- comment, ignored by the browser -->\n</body>In the body, we have two elements and one comment
\nThe first element is a heading of level 1: <h1>Title</h1>.
A paragraph: <p>Welcome to my website</p>.
A comment <!-- comment, ignored by the browser -->
On the rendered web page, you will not see the tags. The web browser uses tags to render the page.
With HTML, you can build web pages.
Elements begin with a start tag and an end tag.
Tags denote elements and are interpreted by the browser.
Elements can be nested.
Here is the skeleton of a simple web page :
<!DOCTYPE html>\n<html>\n <head>\n <title>Title of page</title>\n </head>\n <body>\n <!-- Your content here -->\n </body>\n</html>HTTP means Hypertext Transfer Protocol. HTTP is a communication protocol. It is a set of specifications that describe how two parties can communicate.
\nIn our everyday life, we use communication protocols: when you have a conversation with another human, there are some implied rules to follow. When you meet, you greet each other. Then the conversation starts. The conversation is sequential. The first interlocutor speaks, then the other one speaks. The end of the dialog is often punctuated with a “Goodbye” or “See you”.
\nHTTP is a protocol designed to make machines exchange information over a network. HTTP exists in 2 main versions HTTP/1.1 and HTTP/2. The two specifications are dense. We will focus on some key elements that you must know in the next sections :
\n\nWhen you type in an URL inside your web browser and type enter an HTTP request is sent on the network.
\nAn HTTP request is a message sent by a sender (the client) to a recipient (the server).
\nServers are identified on the network by a unique name. This is the domain name. You can also send a request to a server by providing an IP address. When you make an HTTP request, you need to provide an IP address or a domain name for the network to route your request to the correct server.
\nLet’s define some important terms :
\nIP : Internet Protocol. This a communication protocol between computers on a network and between different networks. You use this protocol when you browse the web.
An IP address is a string composed of numbers separated by points (.) or colons (:). It is attributed to each device connected to a network that uses the Internet Protocol for communication.1.127.0.0.1 is an IP address. ::1 is also an IP address. Note the difference between those two examples. The first one is an IPv4 address the second one is an IPv6 address.
A domain name is a string that identifies a server (or several servers) on the network. Domain names are managed by a complex but clever system named the Domain Name System (DNS).
An HTTP server is a computer connected to the network thanks to the Internet Protocol. This computer runs a program that will handle HTTP requests sent to it by clients. Servers are rarely turned off. We will build a server!
\n\nHere is an HTTP request (version 1.1 of the protocol). An HTTP request is a succession of lines sent on the network.
\nGET /pub/WWW/TheProject.html HTTP/1.1\nHost: www.w3.org\nUser-Agent: curl/7.54.0\nAccept: */*On figure 3 you can see a detailed schema of a request :
\nThe request is composed of three blocks :
\nThe request line
The headers
The message body
URI : Unified Ressource Identifier. Here : /pub/WWW/TheProject.html
URL means “Uniform Ressource Locator”. Here it’s http://www.w3.org/pub/WWW/TheProject.html
It identifies the resource
And indicates how the resource can be retrieved (make an HTTP request to the host www.w3.org)
Each HTTP request has a method. Possible standard values are : OPTIONS, GET, HEAD, POST, PUT, DELETE, TRACE, CONNECT.
GET request when a new page is loadedThe client may add headers to the requests. Headers are a way for “the client to pass to the server information abou t the request and about itself.”2.
\nEx : Host: www.w3.org : this header indicates the network location of the requested resource.
Ex : Accept: */* : the client says to the client that he can accept any media type: JSON, XML ...
Ex : User-Agent: curl/7.54.0 : information about the program that has issued the request
The message body is the last part of the request. In the previous example, it’s empty. It is used to carry information.
Here is an HTTP response :
\nHTTP/1.1 404 Not Found\nContent-Type: text/plain; charset=utf-8\nDate: Fri, 03 Apr 2020 06:26:25 GMT\nContent-Length: 19\n\n404 page not foundOn figure 4 you can see how the response is structured :
\nThe response is composed of three blocks :
\nThe status line
The headers
The message body
The status line is the first line of the response
\nIt informs about the version of the protocol used
The status of the request indicated by a code and a reason phrase.
Response headers “allow the server to pass additional information about the response which cannot be placed in the Status-Line”3
\nThe header Content-Type informs the client about the media type of the content and eventually the character set
Content-Length : informs the client about the size of the message body
The message body will contain the information requested.
\nFor a website, the message body will contain an HTML page.
If it’s an HTML page, the header Content-Type will be equal to text/html
An HTTP response will be composed of a status code. The status code is an integer number. You need to know the most common ones :
\nStatus Code 200 OK: the request was successfully treated by the server
Status Code 400 Bad Request: the request sent by the client is erroneous (malformed request, syntax error...)
Status Code 404 Not found: the server did not find the resource requested by the client.
Status Code 500 Internal Server Error : “the server encountered an unexpected condition that prevented it from fulfilling the request.”4
Other codes are available. You can find a list here https://tools.ietf.org/html/rfc7231#section-6.1.
\nOne thing to remember is that the first number of the status code indicates the status code class. Five classes exist (see figure) :
\nYou can find all you need to build a web server in the standard library. The functions are available in the net/http package :
\n// basic-http-server/first/main.go\npackage main\n\nimport (\n "log"\n "net/http"\n "time"\n)\n\nfunc main() {\n // create a server\n myServer := &http.Server{\n // set the server address\n Addr: "127.0.0.1:8080",\n // define some specific configuration\n ReadTimeout: 10 * time.Second,\n WriteTimeout: 10 * time.Second,\n }\n // launch the server\n log.Fatal(myServer.ListenAndServe())\n}We first begin by creating a variable myServer which is a pointer to a new http.Server struct.The struct http.Server allow you to define a specific configuration for your server : Addr : the address on which the server will listen for requests. In my example, I set it to 127.0.0.1:8080. This means that clients can send requests to the address 127.0.0.1:8080.
Note that the address is composed of two parts : 127.0.0.1 and 8080 separated by a colon. The first part is the IP address (IPv4) the second is a port number.
127.0.0.1:8081, 127.0.0.1:8083, 127.0.0.1:8084)ReadTimeout : the maximum amount of time given to the web server to read the client’s request.
WriteTimeout : this is the maximum duration allowed to the server handlers to write the response. The last line of the program needs some explanations :
log.Fatal(myServer.ListenAndServe())myServer.ListenAndServe() is a method call that will launch the server. This method would return an error if something went wrong. For example, you will receive an error if the port number is already in use. This function will run as long as the server run. When the server does not run anymore, the method returns an error, which is passed to log.Fatal.
Let’s build and run our brand new server :
\n$ go build main.go\n$ ./mainThe program will run till an error occurred. Servers may run for months and even years without the need to be restarted.
\nLet’s test our server. We have two options :
\nWith a web browser (Chrome)
With the command-line tool cURL
The first option is easy. Open your browser and type 127.0.0.1:8080.
Our server answered “404 page not found” ! It answered something!
\nYou have the ability with Chrome to inspect the request that was sent to your server. To do that, open the developer panel (see figure 5)
\nA window will appear (see figure 6). You then need to click on the “Network” tab.
\nThe network pane will record any network usage. For the moment, it’s empty because there is no network activity. Reload the page, and you will see the request made by Chrome (see figure7)
\nYou can see :
\nThe name of the request
The method (HTTP method)
The request and the response header.
The status (here: 404 Not Found)
It’s type, the initiator, its size, and the time.
You can get more information about the request and the response of our server by clicking on the request :
\nThe tab “Headers” (see figure 8) contains the request and the response headers.
\nThe tab “Response” print the server response. This is the raw response received from the server.
\n\ncURL is a software written in C released in 1997. This software is composed of two distinct elements: a library (libcurl) and a command-line interface (curl). We can use the library in a C program or in any other programs that provide bindings for it.
\nWe will use the command-line tool to test our server.
\nThe following command will make an HTTP GET request to the server addresshttp://127.0.0.1:8080 :
$ curl http://127.0.0.1:8080 --verboseOn figure 10 you can see an example output of the command line. I have added the verbose flag intentionally to get more information about the request and the response. We can see :
\nThe connection to the server
The request that has been sent
The response received from the server
The final status of the connexion
The first server that we built does nothing: it receives an HTTP Response with a status code 404 (Not Found) for every HTTP request. We will send an HTML document in the message body of the response.
\n\nOur objective is to send this HTML document to the client :
\n<html>\n <head></head>\n <body>Hello</hello>\n</html>We need to be able to send this HTTP request with our server :
\nHTTP/1.1 200 OK\nContent-Type: text/html; charset=utf-8\nDate: Fri, 03 Apr 2020 06:26:25 GMT\nContent-Length: 45\n\n<html>\n <head></head>\n <body>Hello</hello>\n</html>The Server struct from the package http has a field named Handler. Here is an extract of the file net/http/server.go from the standard library.
package http\n//..\ntype Server struct {\n Addr string // TCP address to listen on, ":http" if empty\n Handler Handler // handler to invoke, http.DefaultServeMux if nil\n //...\n}Handler (from package http) is an interface :
package http\n//...\ntype Handler interface {\n ServeHTTP(ResponseWriter, *Request)\n}We should create our own type that implements this interface to define an HTTP handler :
\ntype myHandler struct {\n}\n\nfunc (h *myHandler)ServeHTTP(w http.ResponseWriter, r *http.Request) {\n // TODO\n}Here I created a type struct named myHandler. On this type, I defined a method named ServeHTTP. This method takes two parameters named w and r. w is of type http.ResponseWriter and r is of type *http.Request.
What are those types? Let’s jump to the documentation.
\n\n“An HTTP handler uses a ResponseWriter interface to construct an HTTP response.” We can see that’s a type interface :
\npackage http\n//...\ntype ResponseWriter interface {\n // Header returns the header map that will be sent by\n // WriteHeader. The Header map also is the mechanism with which\n // Handlers can set HTTP trailers.\n //...\n Header() Header\n\n // Write writes the data to the connection as part of an HTTP reply.\n //...\n Write([]byte) (int, error)\n\n // WriteHeader sends an HTTP response header with the provided\n // status code.\n //...\n WriteHeader(statusCode int)\n}When the server receives a request, it will pass to our function an implementation of this interface. It means that we will have the ability to use three methods :
\nHeaderhttp.Header which is a map of headers.WriteWriteHeaderhttp.Request is a type struct that lists all the elements of the received request. This type struct has 10+ exported fields. Later, we will see that this struct is also used for building HTTP clients! The three more important are :
URL which is in the case of a server the URI.
Body : which contains the message body.
Header : a map containing headers
Here is our handler :
\ntype myHandler struct {\n}\n\nfunc (h *myHandler)ServeHTTP(w http.ResponseWriter, r *http.Request) {\n // TODO\n}The method ServeHTTP “should write reply headers and data to the ResponseWriter and then return. Returning signals that the request is finished5”.
\nWe will call w.Write to write to the response body our HTML Page. The function Write has the following signature :
Write([]byte) (int, error)It accepts a slice of bytes and returns an integer or an error. The integer returned is the number of bytes written to the response body.
\nLet’s see how we will do that :
\nfunc (h *myHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {\n toSend := []byte("<html><head></head><body>Hello</hello></html>")\n _, err := w.Write(toSend)\n if err != nil {\n log.Printf("error while writing on the body %s", err)\n }\n}We create a initialize a variable toSend. It is a slice of bytes containing our HTML document. Note that we have deleted the line breaks. The web browser ignores the line breaks; it’s just there to help the developer write the HTML document.
Then we pass this variable to w.Write
We ignore the number of bytes written (with _)
A new variable err is created that will hold the error.
Usually, when we have an error, we should test if it’s not nil.
If the error is not nil, we log the error
When the function returns, the request is finished.
\n\nWe need to register the Handler :
\nmyServer := &http.Server{\n // set the server address\n Addr: "127.0.0.1:8080",\n // define some specific configuration\n ReadTimeout: 10 * time.Second,\n WriteTimeout: 10 * time.Second,\n Handler: &myHandler{},\n}Our server will now launch myHandler.ServeHTTP for each request received!
// basic-http-server/serve-html/main.go\npackage main\n\nimport (\n "log"\n "net/http"\n "time"\n)\n\nfunc main() {\n // create a server\n myServer := &http.Server{\n // set the server address\n Addr: "127.0.0.1:8080",\n // define some specific configuration\n ReadTimeout: 10 * time.Second,\n WriteTimeout: 10 * time.Second,\n // register our handler\n Handler: &myHandler{},\n }\n\n // launch the server\n log.Fatal(myServer.ListenAndServe())\n}\n\ntype myHandler struct {\n}\n\n// function executed for each HTTP request received\nfunc (h *myHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {\n toSend := []byte("<html><head></head><body>Hello</hello></html>")\n _, err := w.Write(toSend)\n if err != nil {\n log.Printf("error while writing on the body %s", err)\n }\n}Now let’s build it, and run it!
\n$ go build main.go\n$ ./main$ curl 127.0.0.1:8080 --verbose\n* Rebuilt URL to: 127.0.0.1:8080/\n* Trying 127.0.0.1...\n* TCP_NODELAY set\n* Connected to 127.0.0.1 (127.0.0.1) port 8080 (#0)\n> GET / HTTP/1.1\n> Host: 127.0.0.1:8080\n> User-Agent: curl/7.54.0\n> Accept: */*\n>\n< HTTP/1.1 200 OK\n< Date: Sat, 04 Apr 2020 19:07:55 GMT\n< Content-Length: 45\n< Content-Type: text/html; charset=utf-8\n<\n* Connection #0 to host 127.0.0.1 left intact\n<html><head></head><body>Hello</hello></html>Hooray!
\n\nWhen you try to launch your web server, you might have this error. It means that another program already uses the port you have chosen. To solve it check that you have not forgotten to stop another server running on your machine.
\n\nYou can check which program is listening on port 8084 with this command :
\n$ sudo lsof -i 8084On figure 11 you can see the output of the command.
\nlsof means “list open files”.
The column COMMAND allow you to identify the command name
PID is the process id (10206)
USER : is the user that launched the program (here me)
TYPE : inform you about the type of the open file. (here IPv4)
From the command line, you can directly kill the process with the following command :
\n$ kill 10206The OS will terminate the program.
\n\nThe following command will give you the process id of the program listening on port 8084:
\n$ netstat -ano | find "8084"\nTCP 0.0.0.0:8084 0.0.0.0:0 LISTENING 1020610206 is the process id of the program listening on 0.0.0.0:8084.
\nTo kill this process, you can use the following command :
\n$ taskkill /F /PID 10206What are “open files” ? There are two main types of open files :
\nFiles that are opened and read or write by a system user.
Open sockets: an open TCP connection, for example.
Any OS can handle a limited number of open files.
\nWe will see some commands to get this number on your system :
\n\n$ lsof | wc -lWe call lsof to get the list of open files
Then we count the lines returned by this command (wc -l)
The tool Process Explorer program is a good starting point to see the list of process runnings and open files on your system. Here is a link to download it:
\nhttps://docs.microsoft.com/sysinternals/downloads/process-explorer.
\n\nWhen you open a file, you should not forget to close it when you don’t need it. Here is an example http handler to demonstrate it :
\nfunc (h *myHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {\n _, err := os.Open("/tmp/test")\n if err != nil {\n log.Println("error file open ", err)\n } else {\n log.Println("file opened")\n }\n}For each HTTP request, we will open the file /tmp/test. Files will not close automatically when the response is sent!
Let’s test this handler with a standard server :
\nfunc main() {\n // create a server\n myServer := &http.Server{\n // set the server address\n Addr: "127.0.0.1:8084",\n // define some specific configuration\n ReadTimeout: 10 * time.Second,\n WriteTimeout: 10 * time.Second,\n Handler: &myHandler{},\n }\n\n // launch the server\n log.Fatal(myServer.ListenAndServe())\n}Then, we build it and launch it :
\n$ go build -o myProg main.go\n$ ./myBuggyServerLet’s see now how many files were opened by this program. We first have to get its process id :
\n$ lsof -i :8084\nmyProg 12138 maximilienandile 3u IPv4 0x1f9c2813af8142d1 0t0 TCP localhost:8084 (LISTEN)The process id is 12138. Let’s count the number of files opened :
\n$ lsof -p 12458 | wc -l\n10Ten files opened! Now let’s launch four requests to the server (with the cURL command line) :
\n$ curl 127.0.0.1:8084\n$ curl 127.0.0.1:8084\n$ curl 127.0.0.1:8084\n$ curl 127.0.0.1:8084Let’s check now how many open files the process has (the process id has not changed)
\n$ lsof -p 12458 | wc -l\n14The server will use too many resources. The garbage collector will close those open files for you. It’s still dangerous because your Go script might overflow the limit of your system’s open files before the garbage collection.
\n\nYour client has two design ideas (A and B) for the hotel website’s homepage. He cannot choose between the two designs. He asks you if it’s possible to test the two design versions.
\nThe winning design is the one that will generate more phone calls.
\nYour mission: build an http server that :
\nlisten on : IP 127.0.0.1 / Port 9899
For each HTTP request received, send either design A or design B :
\nWhen the current number of minutes is odd, serve A
Else serve B
Here is the design A :
\n<html>\n<head>\n <title>The Golang Hotel</title>\n</head>\n<body>\n <p>The Golang Hotel is a relaxing place !</p>\n <p>We offer 20% discount if you call this number : <strong>1234567891</strong></p>\n</body>\n</html>And the design B :
\n<html>\n<head>\n <title>The Golang Hotel</title>\n</head>\n<body>\n <h2>The Golang Hotel is a relaxing place !</h2>\n <h5>We offer 20% discount if you call this number : <strong>1234567892</strong></h5>\n</body>\n</html>The first step is to initialize a project with a go.mod file :
\nmodule maximilien-andile.com/webserver/application1\n\ngo 1.13You can also generate this file with the command go mod init
$ go mod init maximilien-andile.com/webserver/application1\ngo: creating new go.mod: module maximilien-andile.com/webserver/application1Then we need to create a new http.Server :
\nabTestingServer := &http.Server{\n Addr: "127.0.0.1:9899",\n ReadTimeout: 10 * time.Second,\n WriteTimeout: 10 * time.Second,\n}abTestingServer is a pointer to this struct.
We create a struct type that will implement the http.Handler interface. For memory, this is the http.Handler interface :
type Handler interface {\n ServeHTTP(ResponseWriter, *Request)\n}We must implement the ServerHTTP method. Here is our http.Handler implementation :
type AbHandler struct {\n}\n\nfunc (h *AbHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {\n}We can then set the Handler field in abTestingServer :
abTestingServer := &http.Server{\n Addr: "127.0.0.1:8084",\n ReadTimeout: 10 * time.Second,\n WriteTimeout: 10 * time.Second,\n Handler:&AbHandler{},\n}What is &AbHandler{} ? Let’s decompose it : AbHandler{} will create a variable of type AbHandler
& we will take the address of this variable.AbHandler{} is of type *AbHandler
The first thing to do is to load our two designs :
\nfunc (h *AbHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {\n // load design A\n designA := []byte("<html><head><title>The Golang Hotel</title></head><body><p>The Golang Hotel is a relaxing place !</p><p>We offer 20% discount if you call this number : <strong>1234567891</strong></p></body></html>")\n\n // load design B\n designB := []byte("<html><head><title>The Golang Hotel</title></head><body><h2>The Golang Hotel is a relaxing place !</h2><h5>We offer 20% discount if you call this number : <strong>1234567892</strong></h5></body></html>")\n}We have created two variables : designA and designB. They are slices of bytes. Note that the HTML content has been minified: new lines and useless spaces have been removed. The HTML version of each design.
Now in the handler, we can implement the response logic.
\nfunc (h *AbHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {\n\n designA := []byte("<html><head><title>The Golang Hotel</title></head><body><p>The Golang Hotel is a relaxing place !</p><p>We offer 20% discount if you call this number : <strong>1234567891</strong></p></body></html>")\n\n designB := []byte("<html><head><title>The Golang Hotel</title></head><body><h2>The Golang Hotel is a relaxing place !</h2><h5>We offer 20% discount if you call this number : <strong>1234567892</strong></h5></body></html>")\n\n minutes := time.Now().Minute()\n\n if minutes%2 == 0 {\n // even\n log.Println("serving B")\n _, err := w.Write(designB)\n if err != nil {\n log.Print("impossible to serve design A", err)\n }\n } else {\n // odd\n log.Println("serving A")\n _, err := w.Write(designA)\n if err != nil {\n log.Print("impossible to serve design B", err)\n }\n }\n}For each request, we will get the current minute with time.Now().Minute()
If this number is even (minutes % 2 == 0), then we will write the design B on the response writer
Else, design A is sent
One thing is missing: we need to start the server :
\nlog.Fatal(abTestingServer.ListenAndServe())// basic-http-server/ab-testing/main.go\npackage main\n\nimport (\n "log"\n "net/http"\n "time"\n)\n\nfunc main() {\n // create a server\n abTestingServer := &http.Server{\n // set the server address\n Addr: "127.0.0.1:9899",\n // define some specific configuration\n ReadTimeout: 10 * time.Second,\n WriteTimeout: 10 * time.Second,\n Handler: &AbHandler{},\n }\n log.Fatal(abTestingServer.ListenAndServe())\n}\n\ntype AbHandler struct {\n}\n\nfunc (h *AbHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {\n\n designA := []byte("<html><head><title>The Golang Hotel</title></head><body><p>The Golang Hotel is a relaxing place !</p><p>We offer 20% discount if you call this number : <strong>1234567891</strong></p></body></html>")\n\n designB := []byte("<html><head><title>The Golang Hotel</title></head><body><h2>The Golang Hotel is a relaxing place !</h2><h5>We offer 20% discount if you call this number : <strong>1234567892</strong></h5></body></html>")\n\n minutes := time.Now().Minute()\n\n if minutes%2 == 0 {\n // even\n log.Println("serving B")\n _, err := w.Write(designB)\n if err != nil {\n log.Print("impossible to serve design A", err)\n }\n } else {\n // odd\n log.Println("serving A")\n _, err := w.Write(designA)\n if err != nil {\n log.Print("impossible to serve design B", err)\n }\n }\n}To test the server, we first need to compile and run our application :
\n$ go build -o abServer main.go\n$ ./abServerOpen a web browser and type http://localhost:9899/ in the address bar.
We create two slices of bytes for each request to store the design. This is useless.
\nWhat if we want to store the two HTML on files? If we want to change one design (add some colors, add an image), we have to recompile the Go program. If files are stored into files, we can easily change the design without recompiling the server.
In the program, each URI will return the same two HTML pages. What if we want to define a specific path for this page. For instance : /special-offer-summer.
Which package from the standard library can you use to build an HTTP web server?
True or False. An HTTP request is sent from the server to the client.
How to create an HTTP web server?
Inside a handler method (ServeHTTP(w http.ResponseWriter, r *http.Request)) can you get the value of a request header? How?
Can you give the signification of the HTTP status code 200, 500, and 400?
Which package from the standard library can you use to build an HTTP web server?
\nnet/httpTrue or False. An HTTP request is sent from the server to the client.
\nFalse
The client sends the request to the server
The server will answer with an HTTP response
How to create an http web server?
\nCreate a variable of type *http.Server
Set the listening address
Set the read and write timeout (to avoid defaults)
myServer := &http.Server{\n // set the server address\n Addr: "127.0.0.1:8080",\n // define some specific configuration\n ReadTimeout: 10 * time.Second,\n WriteTimeout: 10 * time.Second,\n}Create a type MyHandler that implements the http.Handler interface.
ServeHTTP(http.ResponseWriter, *http.Request)Set the field Handler of myServer to a pointer to &MyHandler{}
Start the server by calling the method ListenAndServe()
Inside a handler method (ServeHTTP(w http.ResponseWriter, r *http.Request)) can you get the value of a request header? How?
r.Header.Get(\"Name-Of-The-Header\")Can you give the signification of the HTTP status code 200, 500, and 400?
\n200 = “OK”
500 = “Internal Server Error” the server had an unexpected error
400 = “Bad Request” the request you have sent is malformed.
An HTTP Server is a program that will handle HTTP requests sent by clients
Clients can be web browsers (but not only, they can be other programs)
HTTP is a communication protocol
We can send an HTTP request to a server identified by an IP.
We can also send an HTTP request to a domain name that is mapped to one or several servers by the Domain Name System (DNS)
HTTP responses are composed of a status code (an unsigned integer) generated by the server to inform the client about its request status.
\n200 = “OK”
500 = “Internal Server Error” the server had an unexpected error
400 = “Bad Request” the request you have sent is malformed.
You can build an HTTP server with the standard package net/http
// basic-http-server/sample/main.go\npackage main\n\nimport (\n "log"\n "net/http"\n "time"\n)\n\nfunc main() {\n // create a server\n abTestingServer := http.Server{\n // set the server address\n Addr: "127.0.0.1:9899",\n // define some specific configuration\n ReadTimeout: 10 * time.Second,\n WriteTimeout: 10 * time.Second,\n Handler: &MyHandler{},\n }\n log.Fatal(abTestingServer.ListenAndServe())\n}\n\ntype MyHandler struct {\n}\n\nfunc (m *MyHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {\n // TODO\n}the parameter w allow you to write the response
the parameter r allow you to access the request
Previous
\n\t\t\t\t\t\t\t\t\tJSON and XML
\n\t\t\t\t\t\t\t\tNext
\n\t\t\t\t\t\t\t\t\tEnum, Iota & Bitmask
\n\t\t\t\t\t\t\t\t