Network Programming with Go: Essential Skills for Using and Securing Networks 1st Edition Jan Newmarch instant download
Network Programming with Go: Essential Skills for Using and Securing Networks 1st Edition Jan Newmarch instant download
https://textbookfull.com/product/network-programming-with-go-
essential-skills-for-using-and-securing-networks-1st-edition-jan-
newmarch/
https://textbookfull.com/product/network-programming-with-go-
learn-to-code-secure-and-reliable-network-services-from-
scratch-1st-edition-adam-woodbeck/
https://textbookfull.com/product/network-oriented-modeling-for-
adaptive-networks-designing-higher-order-adaptive-biological-
mental-and-social-network-models-jan-treur/
https://textbookfull.com/product/full-stack-web-development-with-
go-build-your-web-applications-quickly-using-the-go-programming-
language-and-vue-js-1st-edition-nanik-tolaram/
https://textbookfull.com/product/mastering-go-create-golang-
production-applications-using-network-libraries-concurrency-and-
advanced-go-data-structures-1st-edition-mihalis-tsoukalos/
Mastering Go create Golang production applications
using network libraries concurrency and advanced Go
data structures Second Edition Tsoukalos
https://textbookfull.com/product/mastering-go-create-golang-
production-applications-using-network-libraries-concurrency-and-
advanced-go-data-structures-second-edition-tsoukalos/
https://textbookfull.com/product/black-hat-go-go-programming-for-
hackers-and-pentesters-1st-edition-tom-steele/
https://textbookfull.com/product/network-programming-with-
rust-1st-edition-abhishek-chanda/
https://textbookfull.com/product/black-hat-go-go-programming-for-
hackers-and-pentesters-tom-steele/
https://textbookfull.com/product/programming-kotlin-enhance-your-
skills-for-android-development-using-kotlin-2nd-edition-
alexander-aronowitz/
Network
Programming
with Go
Essential Skills for Using and
Securing Networks
—
Jan Newmarch
Network Programming
with Go
Essential Skills for Using and
Securing Networks
Jan Newmarch
Network Programming with Go: Essential Skills for Using and Securing Networks
Jan Newmarch
Oakleigh, Victoria
Australia
ISBN-13 (pbk): 978-1-4842-2691-9 ISBN-13 (electronic): 978-1-4842-2692-6
DOI 10.1007/978-1-4842-2692-6
Library of Congress Control Number: 2017941517
Copyright © 2017 by Jan Newmarch
This work is subject to copyright. All rights are reserved by the Publisher, whether the whole or part of the
material is concerned, specifically the rights of translation, reprinting, reuse of illustrations, recitation,
broadcasting, reproduction on microfilms or in any other physical way, and transmission or information
storage and retrieval, electronic adaptation, computer software, or by similar or dissimilar methodology now
known or hereafter developed.
Trademarked names, logos, and images may appear in this book. Rather than use a trademark symbol
with every occurrence of a trademarked name, logo, or image we use the names, logos, and images only
in an editorial fashion and to the benefit of the trademark owner, with no intention of infringement of the
trademark.
The use in this publication of trade names, trademarks, service marks, and similar terms, even if they are
not identified as such, is not to be taken as an expression of opinion as to whether or not they are subject to
proprietary rights.
While the advice and information in this book are believed to be true and accurate at the date of publication,
neither the authors nor the editors nor the publisher can accept any legal responsibility for any errors or
omissions that may be made. The publisher makes no warranty, express or implied, with respect to the
material contained herein.
Managing Director: Welmoed Spahr
Editorial Director: Todd Green
Acquisitions Editor: Steve Anglin
Development Editor: Matthew Moodie
Technical Reviewer: Ronald Petty
Coordinating Editor: Mark Powers
Copy Editor: Kezia Endsley
Compositor: SPi Global
Indexer: SPi Global
Artist: SPi Global
Cover image designed by Freepik
Distributed to the book trade worldwide by Springer Science+Business Media New York,
233 Spring Street, 6th Floor, New York, NY 10013. Phone 1-800-SPRINGER, fax (201) 348-4505, e-mail
[email protected], or visit www.springeronline.com. Apress Media, LLC is a California LLC
and the sole member (owner) is Springer Science + Business Media Finance Inc (SSBM Finance Inc). SSBM
Finance Inc is a Delaware corporation.
For information on translations, please e-mail [email protected], or visit http://www.apress.com/
rights-permissions.
Apress titles may be purchased in bulk for academic, corporate, or promotional use. eBook versions and
licenses are also available for most titles. For more information, reference our Print and eBook Bulk Sales
web page at http://www.apress.com/bulk-sales.
Any source code or other supplementary material referenced by the author in this book is available to
readers on GitHub via the book's product page, located at www.apress.com/9781484226919. For more
detailed information, please visit http://www.apress.com/source-code.
Printed on acid-free paper
Contents at a Glance
■
■Chapter 1: Architecture����������������������������������������������������������������������������������������� 1
■
■Chapter 2: Overview of the Go Language������������������������������������������������������������ 21
■
■Chapter 3: Socket-Level Programming���������������������������������������������������������������� 29
■
■Chapter 4: Data Serialization������������������������������������������������������������������������������� 57
■
■Chapter 5: Application-Level Protocols��������������������������������������������������������������� 87
■
■Chapter 6: Managing Character Sets and Encodings���������������������������������������� 107
■
■Chapter 7: Security�������������������������������������������������������������������������������������������� 121
■
■Chapter 8: HTTP������������������������������������������������������������������������������������������������� 137
■
■Chapter 9: Templates����������������������������������������������������������������������������������������� 161
■
■Chapter 10: A Complete Web Server������������������������������������������������������������������ 175
■
■Chapter 11: HTML���������������������������������������������������������������������������������������������� 193
■
■Chapter 12: XML������������������������������������������������������������������������������������������������ 199
■
■Chapter 13: Remote Procedure Call������������������������������������������������������������������ 209
■
■Chapter 14: REST����������������������������������������������������������������������������������������������� 221
■
■Chapter 15: WebSockets������������������������������������������������������������������������������������ 247
Afterword�������������������������������������������������������������������������������������������������������������� 267
Index��������������������������������������������������������������������������������������������������������������������� 269
iii
Contents
■
■Chapter 1: Architecture����������������������������������������������������������������������������������������� 1
Protocol Layers����������������������������������������������������������������������������������������������������������������� 1
ISO OSI Protocol�������������������������������������������������������������������������������������������������������������������������������������� 2
OSI Layers����������������������������������������������������������������������������������������������������������������������������������������������� 2
TCP/IP Protocol��������������������������������������������������������������������������������������������������������������������������������������� 3
Some Alternative Protocols�������������������������������������������������������������������������������������������������������������������� 3
Networking����������������������������������������������������������������������������������������������������������������������� 3
Gateways�������������������������������������������������������������������������������������������������������������������������� 4
Packet Encapsulation������������������������������������������������������������������������������������������������������� 4
Connection Models����������������������������������������������������������������������������������������������������������� 5
Connection Oriented������������������������������������������������������������������������������������������������������������������������������� 5
Connectionless��������������������������������������������������������������������������������������������������������������������������������������� 5
Communications Models�������������������������������������������������������������������������������������������������� 5
Message Passing������������������������������������������������������������������������������������������������������������������������������������ 5
Remote Procedure Call��������������������������������������������������������������������������������������������������������������������������� 6
v
■ Contents
Communication Flows������������������������������������������������������������������������������������������������������ 9
Synchronous Communication��������������������������������������������������������������������������������������������������������������� 10
Asynchronous Communication������������������������������������������������������������������������������������������������������������� 10
Streaming Communication������������������������������������������������������������������������������������������������������������������� 10
Publish/Subscribe��������������������������������������������������������������������������������������������������������������������������������� 10
Component Distribution�������������������������������������������������������������������������������������������������� 10
Gartner Classification��������������������������������������������������������������������������������������������������������������������������� 11
Three-Tier Models�������������������������������������������������������������������������������������������������������������������������������� 13
Fat versus Thin������������������������������������������������������������������������������������������������������������������������������������� 14
Middleware Model���������������������������������������������������������������������������������������������������������� 14
Middleware Examples�������������������������������������������������������������������������������������������������������������������������� 14
Middleware Functions�������������������������������������������������������������������������������������������������������������������������� 15
Continuum of Processing����������������������������������������������������������������������������������������������� 15
Points of Failure������������������������������������������������������������������������������������������������������������� 16
Acceptance Factors�������������������������������������������������������������������������������������������������������� 16
Transparency������������������������������������������������������������������������������������������������������������������ 17
Access Transparency���������������������������������������������������������������������������������������������������������������������������� 17
Location Transparency�������������������������������������������������������������������������������������������������������������������������� 17
Migration Transparency������������������������������������������������������������������������������������������������������������������������ 17
Replication Transparency���������������������������������������������������������������������������������������������������������������������� 17
Concurrency Transparency������������������������������������������������������������������������������������������������������������������� 17
Scalability Transparency����������������������������������������������������������������������������������������������������������������������� 17
Performance Transparency������������������������������������������������������������������������������������������������������������������� 18
Failure Transparency���������������������������������������������������������������������������������������������������������������������������� 18
vi
■ Contents
Conclusion���������������������������������������������������������������������������������������������������������������������� 20
■
■Chapter 2: Overview of the Go Language������������������������������������������������������������ 21
Types������������������������������������������������������������������������������������������������������������������������������ 22
Slices and Arrays���������������������������������������������������������������������������������������������������������������������������������� 22
Structures��������������������������������������������������������������������������������������������������������������������������������������������� 22
Pointers������������������������������������������������������������������������������������������������������������������������������������������������ 23
Functions���������������������������������������������������������������������������������������������������������������������������������������������� 23
Maps����������������������������������������������������������������������������������������������������������������������������������������������������� 24
Methods������������������������������������������������������������������������������������������������������������������������������������������������ 24
Multi-Threading�������������������������������������������������������������������������������������������������������������� 25
Packages������������������������������������������������������������������������������������������������������������������������ 25
Type Conversion������������������������������������������������������������������������������������������������������������� 25
Statements��������������������������������������������������������������������������������������������������������������������� 25
GOPATH��������������������������������������������������������������������������������������������������������������������������� 25
Running Go Programs���������������������������������������������������������������������������������������������������� 26
Standard Libraries���������������������������������������������������������������������������������������������������������� 26
Error Values�������������������������������������������������������������������������������������������������������������������� 26
Conclusion���������������������������������������������������������������������������������������������������������������������� 27
■
■Chapter 3: Socket-Level Programming���������������������������������������������������������������� 29
The TCP/IP Stack������������������������������������������������������������������������������������������������������������ 29
IP Datagrams���������������������������������������������������������������������������������������������������������������������������������������� 30
UDP������������������������������������������������������������������������������������������������������������������������������������������������������� 30
TCP������������������������������������������������������������������������������������������������������������������������������������������������������� 30
Internet Addresses��������������������������������������������������������������������������������������������������������� 30
IPv4 Addresses������������������������������������������������������������������������������������������������������������������������������������� 31
IPv6 Addresses������������������������������������������������������������������������������������������������������������������������������������� 31
vii
■ Contents
IP Address Type�������������������������������������������������������������������������������������������������������������� 32
The IPMask Type����������������������������������������������������������������������������������������������������������������������������������� 33
The IPAddr Type������������������������������������������������������������������������������������������������������������������������������������ 36
Host Lookup������������������������������������������������������������������������������������������������������������������������������������������ 37
Services������������������������������������������������������������������������������������������������������������������������� 38
Ports����������������������������������������������������������������������������������������������������������������������������������������������������� 38
The TCPAddr Type��������������������������������������������������������������������������������������������������������������������������������� 39
TCP Sockets������������������������������������������������������������������������������������������������������������������� 40
TCP Client��������������������������������������������������������������������������������������������������������������������������������������������� 40
A Daytime Server���������������������������������������������������������������������������������������������������������������������������������� 42
Multi-Threaded Server������������������������������������������������������������������������������������������������������������������������� 44
UDP Datagrams�������������������������������������������������������������������������������������������������������������� 47
Server Listening on Multiple Sockets����������������������������������������������������������������������������� 49
The Conn, PacketConn, and Listener Types�������������������������������������������������������������������� 49
Raw Sockets and the IPConn Type��������������������������������������������������������������������������������� 52
Conclusion���������������������������������������������������������������������������������������������������������������������� 55
■
■Chapter 4: Data Serialization������������������������������������������������������������������������������� 57
Structured Data�������������������������������������������������������������������������������������������������������������� 57
Mutual Agreement���������������������������������������������������������������������������������������������������������� 59
Self-Describing Data������������������������������������������������������������������������������������������������������ 59
ASN.1������������������������������������������������������������������������������������������������������������������������������ 60
ASN.1 Daytime Client and Server��������������������������������������������������������������������������������������������������������� 66
JSON������������������������������������������������������������������������������������������������������������������������������ 68
A Client and Server������������������������������������������������������������������������������������������������������������������������������� 72
viii
■ Contents
Conclusion���������������������������������������������������������������������������������������������������������������������� 86
■
■Chapter 5: Application-Level Protocols��������������������������������������������������������������� 87
Protocol Design�������������������������������������������������������������������������������������������������������������� 87
Why Should You Worry?�������������������������������������������������������������������������������������������������� 88
Version Control��������������������������������������������������������������������������������������������������������������� 88
The Web������������������������������������������������������������������������������������������������������������������������������������������������ 89
Message Format������������������������������������������������������������������������������������������������������������ 90
Data Format������������������������������������������������������������������������������������������������������������������� 91
Byte Format������������������������������������������������������������������������������������������������������������������������������������������ 91
Character Format���������������������������������������������������������������������������������������������������������������������������������� 92
A Simple Example���������������������������������������������������������������������������������������������������������� 92
A Standalone Application���������������������������������������������������������������������������������������������������������������������� 93
The Client-Server Application��������������������������������������������������������������������������������������������������������������� 94
The Client Side�������������������������������������������������������������������������������������������������������������������������������������� 94
Alternative Presentation Aspects���������������������������������������������������������������������������������������������������������� 95
The Server Side������������������������������������������������������������������������������������������������������������������������������������ 95
Protocol: Informal��������������������������������������������������������������������������������������������������������������������������������� 95
Text Protocol����������������������������������������������������������������������������������������������������������������������������������������� 96
Server Code������������������������������������������������������������������������������������������������������������������������������������������ 97
Client Code������������������������������������������������������������������������������������������������������������������������������������������� 99
Textproto Package������������������������������������������������������������������������������������������������������������������������������ 101
ix
■ Contents
Conclusion�������������������������������������������������������������������������������������������������������������������� 106
■
■Chapter 6: Managing Character Sets and Encodings���������������������������������������� 107
Definitions�������������������������������������������������������������������������������������������������������������������� 108
Character�������������������������������������������������������������������������������������������������������������������������������������������� 108
Character Repertoire/Character Set��������������������������������������������������������������������������������������������������� 108
Character Code����������������������������������������������������������������������������������������������������������������������������������� 108
Character Encoding���������������������������������������������������������������������������������������������������������������������������� 108
Transport Encoding����������������������������������������������������������������������������������������������������������������������������� 109
ASCII����������������������������������������������������������������������������������������������������������������������������� 109
ISO 8859����������������������������������������������������������������������������������������������������������������������� 111
Unicode������������������������������������������������������������������������������������������������������������������������ 111
UTF-8, Go, and Runes��������������������������������������������������������������������������������������������������� 112
UTF-8 Client and Server��������������������������������������������������������������������������������������������������������������������� 112
ASCII Client and Server����������������������������������������������������������������������������������������������������������������������� 113
Conclusion�������������������������������������������������������������������������������������������������������������������� 136
■
■Chapter 8: HTTP������������������������������������������������������������������������������������������������� 137
URLs and Resources���������������������������������������������������������������������������������������������������� 137
I18n����������������������������������������������������������������������������������������������������������������������������������������������������� 137
HTTP Characteristics�������������������������������������������������������������������������������������������������������������������������� 138
Versions���������������������������������������������������������������������������������������������������������������������������������������������� 138
HTTP 0.9��������������������������������������������������������������������������������������������������������������������������������������������� 138
HTTP 1.0��������������������������������������������������������������������������������������������������������������������������������������������� 139
HTTP 1.1��������������������������������������������������������������������������������������������������������������������������������������������� 140
HTTP/2������������������������������������������������������������������������������������������������������������������������������������������������ 141
HTTPS��������������������������������������������������������������������������������������������������������������������������� 159
Conclusion�������������������������������������������������������������������������������������������������������������������� 160
xi
■ Contents
■
■Chapter 9: Templates����������������������������������������������������������������������������������������� 161
Inserting Object Values������������������������������������������������������������������������������������������������� 161
Using Templates��������������������������������������������������������������������������������������������������������������������������������� 162
Pipelines����������������������������������������������������������������������������������������������������������������������� 164
Defining Functions������������������������������������������������������������������������������������������������������� 165
Variables����������������������������������������������������������������������������������������������������������������������� 167
Conditional Statements������������������������������������������������������������������������������������������������ 168
The HTML / Template Package�������������������������������������������������������������������������������������� 173
Conclusion�������������������������������������������������������������������������������������������������������������������� 173
■
■Chapter 10: A Complete Web Server������������������������������������������������������������������ 175
Browser Site Diagram�������������������������������������������������������������������������������������������������� 175
Browser Files��������������������������������������������������������������������������������������������������������������� 177
Basic Server����������������������������������������������������������������������������������������������������������������� 177
The listFlashCards Function����������������������������������������������������������������������������������������� 179
The manageFlashCards Function��������������������������������������������������������������������������������� 181
The Chinese Dictionary������������������������������������������������������������������������������������������������ 181
The Dictionary Type ��������������������������������������������������������������������������������������������������������������������������� 182
xii
■ Contents
JSON���������������������������������������������������������������������������������������������������������������������������� 198
Conclusion�������������������������������������������������������������������������������������������������������������������� 198
■
■Chapter 12: XML������������������������������������������������������������������������������������������������ 199
Parsing XML����������������������������������������������������������������������������������������������������������������� 200
The StartElement Type������������������������������������������������������������������������������������������������������������������������ 200
The EndElement Type������������������������������������������������������������������������������������������������������������������������� 200
The CharData Type������������������������������������������������������������������������������������������������������������������������������ 200
The Comment Type����������������������������������������������������������������������������������������������������������������������������� 200
The ProcInst Type������������������������������������������������������������������������������������������������������������������������������� 201
The Directive Type������������������������������������������������������������������������������������������������������������������������������ 201
JSON���������������������������������������������������������������������������������������������������������������������������� 217
JSON RPC Server�������������������������������������������������������������������������������������������������������������������������������� 218
JSON RPC Client��������������������������������������������������������������������������������������������������������������������������������� 219
Conclusion�������������������������������������������������������������������������������������������������������������������� 220
■
■Chapter 14: REST����������������������������������������������������������������������������������������������� 221
URIs and Resources����������������������������������������������������������������������������������������������������� 221
Representations����������������������������������������������������������������������������������������������������������� 222
xiii
■ Contents
xiv
■ Contents
Conclusion�������������������������������������������������������������������������������������������������������������������� 266
Afterword�������������������������������������������������������������������������������������������������������������� 267
Index��������������������������������������������������������������������������������������������������������������������� 269
xv
About the Author
Jan Newmarch is head of ICT (higher education) at Box Hill Institute, adjunct
professor at Canberra University, and adjunct lecturer in the School of
Information Technology, Computing and Mathematics at Charles Sturt
University. He is interested in more aspects of computing than he has time to
pursue, but the major thrust over the last few years has developed from user
interfaces under UNIX into Java, the Web, and then into general distributed
systems. Jan developed a number of publicly available software systems in
these areas. For the last few years, he has been looking at sound for Linux
systems and programming the Raspberry Pi’s GPU. He is now exploring
aspects of the IoT. He lives in Melbourne, Australia and enjoys the food and
culture there, but is not so impressed by the weather.
xvii
About the Technical Reviewer
xix
Preface
It’s always fun to learn a new programming language, especially when it turns out to be a major one. Prior
to the release of Go in 2009, I was teaching a Master’s level subject in network programming at Monash
University. It’s good to have a goal when learning a new language, but this time, instead of building yet
another wine cellar program, I decided to orient my lecture notes around Go instead of my (then) standard
delivery vehicle of Java.
The experiment worked well: apart from the richness of the Java libraries that Go was yet to match, all
the programming examples transferred remarkably well, and in many cases were more elegant than the
original Java programs.
This book is the result. I have updated it as Go has evolved and as new technologies such as HTTP/2
have arisen. But if it reads like a textbook, well, that is because it is one. There is a large body of theoretical
and practical concepts involved in network programming and this book covers some of these as well as the
practicalities of building systems in Go.
In terms of language popularity, Go is clearly rising. It has climbed to 16th in the TIOBE index, is 18th
in the PYPL (Popularity of Programming Language), and is 15th in the RedMonk Programming Language
rankings. It is generally rated as one of the fastest growing languages.
There is a growing community of developers both of the core language and libraries and of the
independent projects. I have tried to limit the scope of this book to the standard libraries only and to the
“sub-repositories” of the Go tree. While this eliminates many excellent projects that no doubt make many
programming tasks easier, restricting the book to the official Go libraries provides a clear bound.
This book assumes a basic knowledge of Go. The focus is on using Go to build network applications,
not on the basics of the language. Network applications are different than command-line applications,
are different than applications with a graphical user interface, and so on. So the first chapter discusses
architectural aspects of network programs. The second chapter is an overview of the features of Go that we
use in this book. The third chapter on sockets covers the Go version of the basics underlying all
TCP/IP systems. Chapters 4, 5, and 6 are more unusual in network programming books. They cover the
topics of what representations of data will be used, how a network interaction will proceed, and for text,
which language formats are used. Then in Chapter 7, we look at the increasingly important topic of security.
In Chapter 8, we look at one of the most common application layer protocols in use, HTTP. The next four
chapters are about topics related to HTTP and common data formats carried above HTTP—HTML and
XML. In Chapter 13, we look at an alternative approach to network programming, remote procedure calls.
Chapters 14 and 15 consider further aspects of network programming using HTTP.
xxi
CHAPTER 1
Architecture
This chapter covers the major architectural features of distributed systems. You can’t build a system without
some idea of what you want to build. And you can’t build it if you don't know the environment in which it
will work. GUI programs are different than batch processing programs; games programs are different than
business programs; and distributed programs are different than standalone programs. They each have their
approaches, their common patterns, the problems that typically arise, and the solutions that are often used.
This chapter covers the high-level architectural aspects of distributed systems. There are many ways of
looking at such systems, and many of these are dealt with.
Protocol Layers
Distributed systems are hard. There are multiple computers involved, which have to be connected in some
way. Programs have to be written to run on each computer in the system and they all have to cooperate to
get a distributed task done.
The common way to deal with complexity is to break it down into smaller and simpler parts. These
parts have their own structure, but they also have defined means of communicating with other related parts.
In distributed systems, the parts are called protocol layers and they have clearly defined functions. They
form a stack, with each layer communicating with the layer above and the layer below. The communication
between layers is defined by protocols.
Network communications requires protocols to cover high-level application communication all the way
down to wire communication and the complexity handled by encapsulation in protocol layers.
Application Application
Presentation Presentation
Session Session
Transport Transport
Network Network
Data Link Data Link
Physical Physical
OSI Layers
The function of each layer from bottom to top is as follows:
• The Physical layer conveys the bit stream using electrical, optical, or radio
technologies.
• The Data link layer puts the information packets into network frames for
transmission across the physical layer, and back into information packets.
• The Network layer provides switching and routing technologies.
• The Transport layer provides transparent transfer of data between end systems and
is responsible for end-to-end error recovery and flow control.
• The Session layer establishes, manages, and terminates connections between
applications.
• The Presentation layer provides independence from differences in data
representation (e.g., encryption).
• The Application layer supports application and end-user processes.
2
Chapter 1 ■ Architecture
TCP/IP Protocol
While the OSI model was being argued, debated, partly implemented, and fought over, the DARPA Internet
research project was busy building the TCP/IP protocols. These have been immensely successful and have
led to The Internet (with capitals). This is a much simpler stack, as shown in Figure 1-2.
IP OSI 3
Networking
A network is a communications system for connecting end systems called hosts. The mechanisms of
connection might be copper wire, Ethernet, fiber optic, or wireless, but that won’t concern us here. A local
area network (LAN) connects computers that are close together, typically belonging to a home, small
organization, or part of a larger organization.
A Wide Area Network (WAN) connects computers across a larger physical area, such as between cities.
There are other types as well, such as MANs (Metropolitan Area Network), PANs (Personal Area Networks),
and even BANs (Body Area Network).
An internet is a connection of two or more distinct networks, typically LANs or WANs. An intranet is an
internet with all networks belonging to a single organization.
There are significant differences between an internet and an intranet. Typically, an intranet will be
under a single administrative control, which will impose a single set of coherent policies. An internet, on the
other hand, will not be under the control of a single body, and the controls exercised over different parts may
not even be compatible.
3
Chapter 1 ■ Architecture
A trivial example of such differences is that an intranet will often be restricted to computers by a small
number of vendors running a standardized version of a particular operating system. On the other hand, an
internet will often have a smorgasbord of different computers and operating systems.
The techniques of this book are applicable to internets. They are also valid with intranets, but there you
will also find specialized, non-portable systems.
And then there is the “mother” of all internets: The Internet. This is just a very, very large internet that
connects us to Google, my computer to your computer, and so on.
Gateways
A gateway is a generic term for an entity used to connect two or more networks. A repeater operates at
the physical level and copies information from one subnet to another. A bridge operates at the data link
layer level and copies frames between networks. A router operates at the network level and not only moves
information between networks but also decides on the route.
Packet Encapsulation
The communication between layers in either the OSI or the TCP/IP stacks is done by sending packets of
data from one layer to the next, and then eventually across the network. Each layer has administrative
information that it has to keep about its own layer. It does this by adding header information to the packet it
receives from the layer above, as the packet passes down. On the receiving side, these headers are removed
as the packet moves up.
For example, the TFTP (Trivial File Transfer Protocol) moves files from one computer to another. It uses
the UDP protocol on top of the IP protocol, which may be sent over Ethernet. This looks like the diagram
shown in Figure 1-3.
data
TFTP
data
header
UDP TFTP
data
header header
IP UDP TFTP
data
header header header
4
Chapter 1 ■ Architecture
Connection Models
In order for two computers to communicate, they must set up a path whereby they can send at least one
message in a session. There are two major models for this:
• Connection oriented
• Connectionless
Connection Oriented
A single connection is established for the session. Two-way communications flow along the connection. When
the session is over, the connection is broken. The analogy is to a phone conversation. An example is TCP.
Connectionless
In a connectionless system, messages are sent independent of each other. Ordinary mail is the analogy.
Connectionless messages may arrive out of order. An example is the IP protocol. UDP is a connectionless
protocol above IP and is often used as an alternative to TCP, as it is much lighter weight.
Connection-oriented transports may be established on top of connectionless ones—TCP over IP.
Connectionless transports may be established on top of connection-oriented ones—HTTP over TCP.
There can be variations on these. For example, a session might enforce messages arriving, but might not
guarantee that they arrive in the order sent. However, these two are the most common.
Communications Models
In a distributed system there will be many components running that have to communicate with each other.
There are two primary models for this, message passing and remote procedure calls.
Message Passing
Some non-procedural languages are built on the principle of message passing. Concurrent languages often
use such a mechanism, and the most well known example is probably the UNIX pipeline. The UNIX pipeline
is a pipeline of bytes, but this is not an inherent limitation: Microsoft’s PowerShell can send objects along
its pipelines, and concurrent languages such as Parlog can send arbitrary logic data structures in messages
between concurrent processes.
Message passing is a primitive mechanism for distributed systems. Set up a connection and pump some
data down it. At the other end, figure out what the message was and respond to it, possibly sending messages
back. This is illustrated in Figure 1-4.
5
Chapter 1 ■ Architecture
Requestor Responder
Send(Msg, Responder)
Receive(Msg, Requestor)
Send(Reply, Requestor)
Receive(Reply, Responder)
Event-driven systems act in a similar manner. At a low level, node.js runs an event loop waiting for I/O
events, dispatching handlers for these events and responding. At a higher level, most user interface systems
use an event loop waiting for user input, while in the networking world, Ajax uses the XMLHttpRequest to
send and receive requests.
6
Chapter 1 ■ Architecture
Client Process
main()
{
rpc(a, b, c)
Server Process
}
receive(x, y)
send(z)
There are many examples of this: some based on particular programming languages such as the Go
rpc package (discussed in Chapter 13) or RPC systems covering multiple languages such as SOAP and
Google’s grpc.
client-server A B
peer-to-peer A A’
7
Chapter 1 ■ Architecture
Client-Server System
Another view of a client-server system is shown in Figure 1-7.
hardware hardware
This view may be held by a developer who needs to know the components of a system. It is also the view
that may be held by a user: a user of a browser knows it is running on her system but is communicating with
servers elsewhere.
Client-Server Application
Some applications may be seamlessly distributed, with the user unaware that it is distributed. Users will see
their view of the system, as shown in Figure 1-8.
Client Server
Client Application
process Process
System System
hardware hardware
8
Chapter 1 ■ Architecture
Server Distribution
A client-server system need not be simple. The basic model is a single client, single server system, as shown
in Figure 1-9.
Client Server
However, you can also have multiple clients, single server, as illustrated in Figure 1-10.
Slave Slave
In this system, the master receives requests and instead of handling them one at a time itself, it passes
them to other servers to handle. This is a common model when concurrent clients are possible.
There are also single client, multiple servers, as shown in Figure 1-11.
This type of system occurs frequently when a server needs to act as a client to other servers, such as
a business logic server getting information from a database server. And of course, there could be multiple
clients with multiple servers.
Communication Flows
The previous diagrams have shown the connection views between high-level components of a system. Data
will flow between these components and it can do so in multiple ways, discussed in the following sections.
9
Chapter 1 ■ Architecture
Synchronous Communication
In a synchronous communication, one party will send a message and block, waiting for a reply. This is often
the simplest model to implement and is just relies on blocking I/O. However, there may need to be a timeout
mechanism in case some error means that no reply will ever be sent.
Asynchronous Communication
In asynchronous communication, one party sends a message and instead of waiting for a reply carries
on with other work. When a reply eventually comes, it is handled. This may be in another thread or by
interrupting the current thread. Such applications are harder to build but are much more flexible to use.
Streaming Communication
In streaming communication, one party sends a continuous stream of messages. Online video is a good
example. The streaming may need to be handled in real time, may or may not tolerate losses, and can be
one-way or allow reverse communication as in control messages.
Publish/Subscribe
In pub/sub systems, parties subscribe to topics and others post to them. This can be on a small or massive
scale, as demonstrated by Twitter.
Component Distribution
A simple but effective way of decomposing many applications is to consider them as made up of three parts:
• Presentation component
• Application logic
• Data access
The presentation component is responsible for interactions with the user, both displaying data and
gathering input. It may be a modern GUI interface with buttons, lists, menus, etc., or an older command-line
style interface, asking questions and getting answers. It could also encompass wider interaction styles, such
as the interaction with physical devices such as a cash register, ATM, etc. It could also cover the interaction
with a non-human user, as in a machine-to-machine system. The details are not important at this level.
The application logic is responsible for interpreting the users’ responses, for applying business rules, for
preparing queries, and for managing responses from the third component.
The data access component is responsible for storing and retrieving data. This will often be through a
database, but not necessarily.
10
Chapter 1 ■ Architecture
Gartner Classification
Based on this threefold decomposition of applications, Gartner considered how the components might be
distributed in a client-server system. They came up with five models, shown in Figure 1-12.
presentation
logic
data
data
Modern mobile phones make good examples of this. Due to limited memory, they may store a small
part of a database locally so that they can usually respond quickly. However, if data is required that is not
held locally, then a request may be made to a remote database for that additional data.
Google maps is another good example. All of the maps reside on Google’s servers. When one is
requested by a user, the “nearby” maps are also downloaded into a small database in the browser. When the
user moves the map a little bit, the extra bits required are already in the local store for quick response.
11
Exploring the Variety of Random
Documents with Different Content
Chaplin, Charlie, 43
Chatham Islands, 26
Chidley, 149
Chicago, 184
Chosen People, 21
Compasses, 25
Confucius, 6
Consumption, 120
Coral reefs, 37
Cradle of Mankind, 21
Culture, 27
Customs, 23
Dante, 89
Davuilevu, 61, 62
Easter Islands, 25
Eden, 17, 23
Elephantiasis, 94, 95
Emerson, 108
English, 19, 20
Europeans: 18;
effect of famine on, 27, 52
Fan-tan, 141
Fiji: 11, 12, 13, 18, 21, 32;
relation of, to the Pacific, 52 et seq., 81, 105, 356
Fijians: 14;
characteristics of, 19, 20, 21;
study of, 52-78;
personal appearance of, 59, 60;
characteristics of, 64 et seq.;
dances of, 67;
women, 70 et seq.;
tastes of, 71 et seq.;
music and dances of, 71, 72;
schools for, 76, 84, 85, 86;
jail of the, 73;
submersion of, 223 et seq.
Fire-walkers of Mbenga, 13
Food, 27
Formosa, 298
France, 100
Frenchmen, 20
Haleakala, 48
Halemaumau, 51
Hauraki Gulf, 13
Heasley, Inspector, 97
Heinie's, 39
Heliolithic man, 18
Hilo, 48
Hindus, 78
Himalaya Mountains, 22
Honolulu: 7, 9;
our frontier in the Pacific, 30-51;
the spirit, 37 et seq., 235.
See also Hawaii
Huang-Hsu, 365
Indians, 77
Infanticide, 216
Inouye, Count: quoted on Japanese merchants in Korea, 309
Izanagi, 21
Izanami, 21
Japan: 4, 5, 7, 9;
awakening of, 28, 29, 132, 135, 282;
in relation to the Pacific problem, 297 et seq.;
foreign policies of, 299 et seq.;
race-pride of, 302;
government of, 303;
Democracy in, 305;
attitude of, toward commercialization, 306;
American trade with, 308;
in Siberia, 308;
Buddhism in, 324;
relations of, 326 et seq.;
and alien labor, 331;
foreign population statistics of, 334;
naturalization in, 337 et seq.;
science in, 341 et seq.;
in America, 342 et seq.;
birth-rate, 343;
attitude of, toward financiering China, 373, 374;
attitude of the Orient toward, 376;
and the Pacific problem, 379;
and Manchurian railways, 380
Java, 4, 22
Joan of Arc, 51
Kapiolani, 51
Katori-maru, 192
Keats, quoted, 3
Kiao-chau, 368
Kilauea, 8, 50
Kinglake, 24
Kipling, 116
Korea: 4, 298;
Japan's actions in, 309;
the case of, 317, 324, 391
Kyoto, 7
Labor: conditions in New Zealand, 6;
in Fiji, 13 et seq.;
legislation in New Zealand, 116;
indentured, 222
Language, 22, 23
Lao-Tsze, 269
Laupepa, 395
Levuka, 75, 85
London, Charmian, 38
London, Jack, 10
Los Angeles, 30
Lurline, 7, 9
Luzon, 158
Magellan, 4, 9, 18
Malays, 308
Mangoes, 105
Manono, 87
Maoriland, 17
Marquesas, 5, 26, 52
Martin, Alonso, 4
Mataafa, 396;
letter, 395, 396
Melanesian-Fijians, 20, 21
Melville, 10, 24
Migrations, 20
Mindoro, 158
Missionaries: 19;
Fijian, 65 et seq., 68, 69, 73, 121, 231, 236
Moa, 28
Moji, 191
Mongolia, 373
Monterey, 103
Mormon missionaries, 23
Morocco, 390
Mua Peak, 87
Mulinuu, 91
Mummy-apples, 20, 59
Nagasaki, 376
Napoleon: 20;
in relation to Fijian legend, 21
Negros, 158
New South Wales, 146
New Zealand: labor conditions in, 6, 13, 14, 17, 20, 23, 26, 72,
84, 105;
study of, 108-127;
home life in, 111;
the bush of, 111;
farmers, 112 et seq.;
newspapers, 113;
population, 113;
characteristics, 114, 115;
girls, 115;
progressiveness, 116;
development, 117 et seq.;
Parliament, in relation to the Draft Act, 123, 133, 145;
and the class system, 286 et seq.;
policy toward England, 353
Niagara, the, 9, 10, 11, 16, 53, 62, 79, 86, 111
Night-blooming cereus, 33
Niuafoou, 12, 13
Oahu: 40;
College, 63
Origins of races, 22
Paleolithic life, 16
Panama-Pacific Exposition, 79
Panay, 158
Papuans, 53
Pasig River, 161
Pavlova, 46
Persia, 390
Pescadores, 357
Pharaohs, 25
Pilgrims, 17
Pleistonic period, 20
Polyandry, 220
Polynesians: 19;
origin of the, 20, 23, 24, 25, 28, 52;
dances of the, 72, 88, 206;
character of the ancient, 215;
and the problem of intermarriage, 237 et seq.
Portuguese, 4, 30
Poverty Bay, 28
Race-blending, 28 et seq.
Rarotanga, 93
Rolland, 108
Samoans: 14;
dances of the, 72;
study of the, 79 et seq.;
songs of the, 80;
dances of the, 83;
hospitality of the, 93 et seq., 208
Samurai, 305
Savii, 26, 87
Scientific, 236
Scientists, 231
Seattle, 193
Shantung: 297;
rape of, 324
Shaw, 108
Shibusawa, 375
Shimonoseki, 376
Shintoism: 299;
defined, 304, 305
Siberia, 344
Sikhs, 231
Solomon Islands, 65
Spanish, 10
Sponges, 37
St. Helena, 20
Stevenson, R. L.: 10, 88, 100;
pilgrimage to tomb of, 100-105;
home of, 103, 387, 395
Stone Age, 89
Sulus, 65
Superstition, 25
Suva, Fiji, 11, 13, 20, 55, 56, 57, 58, 61, 73, 75, 76, 84, 105
Tagalog, 165
Tagore: 116;
experiences of in Japan, 311
Talume, 12
Tamasese, 395
Tasman, 9, 10
Tattooings of Time, 17
Te Noroto, 124
Thoreau, 95
Tokyo, 349
Tolstoy, 269
Tongans, 19, 77
Townsville, 137
Tradition, 22
Tulane, 13
Turks, 20
Typee, 5
Typhoons, 141
Uchida, Viscount: quoted on Consortium, 379, 384
Upolu, 87
Vancouver, George, 5, 7, 18
Victoria, 146
Vikings, 25
Virginia, 151
Vladivostok, 308
Waikato, 124
Waikiki, 39
Waitemata Harbor, 13
Waterhouse, Mr., 69
Waterspouts, 140
Wimmera, 131
Yokohama, 192
Y. M. C. A., 38
Updated editions will replace the previous one—the old editions will
be renamed.
1.D. The copyright laws of the place where you are located also
govern what you can do with this work. Copyright laws in most
countries are in a constant state of change. If you are outside the
United States, check the laws of your country in addition to the
terms of this agreement before downloading, copying, displaying,
performing, distributing or creating derivative works based on this
work or any other Project Gutenberg™ work. The Foundation makes
no representations concerning the copyright status of any work in
any country other than the United States.
1.E.6. You may convert to and distribute this work in any binary,
compressed, marked up, nonproprietary or proprietary form,
including any word processing or hypertext form. However, if you
provide access to or distribute copies of a Project Gutenberg™ work
in a format other than “Plain Vanilla ASCII” or other format used in
the official version posted on the official Project Gutenberg™ website
(www.gutenberg.org), you must, at no additional cost, fee or
expense to the user, provide a copy, a means of exporting a copy, or
a means of obtaining a copy upon request, of the work in its original
“Plain Vanilla ASCII” or other form. Any alternate format must
include the full Project Gutenberg™ License as specified in
paragraph 1.E.1.
• You pay a royalty fee of 20% of the gross profits you derive
from the use of Project Gutenberg™ works calculated using the
method you already use to calculate your applicable taxes. The
fee is owed to the owner of the Project Gutenberg™ trademark,
but he has agreed to donate royalties under this paragraph to
the Project Gutenberg Literary Archive Foundation. Royalty
payments must be paid within 60 days following each date on
which you prepare (or are legally required to prepare) your
periodic tax returns. Royalty payments should be clearly marked
as such and sent to the Project Gutenberg Literary Archive
Foundation at the address specified in Section 4, “Information
about donations to the Project Gutenberg Literary Archive
Foundation.”
• You comply with all other terms of this agreement for free
distribution of Project Gutenberg™ works.
1.F.
1.F.4. Except for the limited right of replacement or refund set forth
in paragraph 1.F.3, this work is provided to you ‘AS-IS’, WITH NO
OTHER WARRANTIES OF ANY KIND, EXPRESS OR IMPLIED,
INCLUDING BUT NOT LIMITED TO WARRANTIES OF
MERCHANTABILITY OR FITNESS FOR ANY PURPOSE.
Please check the Project Gutenberg web pages for current donation
methods and addresses. Donations are accepted in a number of
other ways including checks, online payments and credit card
donations. To donate, please visit: www.gutenberg.org/donate.
Most people start at our website which has the main PG search
facility: www.gutenberg.org.
Our website is not just a platform for buying books, but a bridge
connecting readers to the timeless values of culture and wisdom. With
an elegant, user-friendly interface and an intelligent search system,
we are committed to providing a quick and convenient shopping
experience. Additionally, our special promotions and home delivery
services ensure that you save time and fully enjoy the joy of reading.
textbookfull.com