4. Command-Line Tools to Find Domain Names
by Mat Ryer, Mario Castro Contreras, Vladimir Vivien
Go: Design Patterns for Real-World Projects
- Go: Design Patterns for Real-World Projects
- Go: Design Patterns for Real-World Projects
- Credits
- Preface
- 1. Module 1
- 1. A First Step in Go
- 2. Go Language Essentials
- 3. Go Control Flow
- 4. Data Types
- 5. Functions in Go
- 6. Go Packages and Programs
- 7. Composite Types
- 8. Methods, Interfaces, and Objects
- 9. Concurrency
- 10. Data IO in Go
- 11. Writing Networked Services
- 12. Code Testing
- 2. Module 2
- 1. Ready... Steady... Go!
- A little bit of history
- Installing Go
- Starting with Hello World
- Integrated Development Environment - IDE
- Types
- Variables and constants
- Operators
- Flow control
- Functions
- Arrays, slices, and maps
- Visibility
- Zero-initialization
- Pointers and structures
- Interfaces
- Testing and TDD
- Libraries
- The Go get tool
- Managing JSON data
- Go tools
- Contributing to Go open source projects in GitHub
- Summary
- 2. Creational Patterns - Singleton, Builder, Factory, Prototype, and Abstract Factory Design Patterns
- Singleton design pattern - having a unique instance of a type in the entire program
- Builder design pattern - reusing an algorithm to create many implementations of an interface
- Factory method - delegating the creation of different types of payments
- Abstract Factory - a factory of factories
- Prototype design pattern
- Summary
- 3. Structural Patterns - Composite, Adapter, and Bridge Design Patterns
- 4. Structural Patterns - Proxy, Facade, Decorator, and Flyweight Design Patterns
- 5. Behavioral Patterns - Strategy, Chain of Responsibility, and Command Design Patterns
- 6. Behavioral Patterns - Template, Memento, and Interpreter Design Patterns
- Template design pattern
- Description
- Objectives
- Example - a simple algorithm with a deferred step
- Requirements and acceptance criteria
- Unit tests for the simple algorithm
- Implementing the Template pattern
- Anonymous functions
- How to avoid modifications on the interface
- Looking for the Template pattern in Go's source code
- Summarizing the Template design pattern
- Memento design pattern
- Interpreter design pattern
- Summary
- Template design pattern
- 7. Behavioral Patterns - Visitor, State, Mediator, and Observer Design Patterns
- 8. Introduction to Gos Concurrency
- 9. Concurrency Patterns - Barrier, Future, and Pipeline Design Patterns
- 10. Concurrency Patterns - Workers Pool and Publish/Subscriber Design Patterns
- 1. Ready... Steady... Go!
- 3. Module 3
- 1. Chat Application with Web Sockets
- 2. Adding User Accounts
- 3. Three Ways to Implement Profile Pictures
- 4. Command-Line Tools to Find Domain Names
- 5. Building Distributed Systems and Working with Flexible Data
- 6. Exposing Data and Functionality through a RESTful Data Web Service API
- 7. Random Recommendations Web Service
- 8. Filesystem Backup
- 9. Building a Q&A Application for Google App Engine
- The Google App Engine SDK for Go
- Google Cloud Datastore
- Entities and data access
- Google App Engine users
- Transactions in Google Cloud Datastore
- Querying in Google Cloud Datastore
- Votes
- Casting a vote
- Exposing data operations over HTTP
- Running apps with multiple modules
- Deploying apps with multiple modules
- Summary
- 10. Micro-services in Go with the Go kit Framework
- 11. Deploying Go Applications Using Docker
- Appendix. Good Practices for a Stable Go Environment
- Bibliography
The chat application we've built so far is ready to take the world by storm but not before we give it a home on the Internet. Before we invite our friends to join the conversation, we need to pick a valid, catchy, and available domain name, which we can point to the server running our Go code. Instead of sitting in front of our favorite domain name provider for hours on end trying different names, we are going to develop a few command-line tools that will help us find the right one. As we do so, we will see how the Go standard library allows us to interface with the terminal and other executing applications; we'll also explore some patterns and practices to build command-line programs.
In this chapter, you will learn:
- How to build complete command-line applications with as little as a single code file
- How to ensure that the tools we build can be composed with other tools using standard streams
- How to interact with a simple third-party JSON RESTful API
- How to utilize the standard in and out pipes in Go code
- How to read from a streaming source, one line at a time
- How to build a WHOIS client to look up domain information
- How to store and use sensitive or deployment-specific information in environment variables
We are going to build a series of command-line tools that use the standard streams (stdin and stdout) to communicate with the user and with other tools. Each tool will take an input line by line via the standard input pipe, process it in some way, and then print the output line by line to the standard out pipe for the next tool or user.
By default, the standard input is connected to the user's keyboard, and the standard output is printed to the terminal from where the command was run; however, both can be redirected using redirection metacharacters. It's possible to throw the output away by redirecting it to NUL on Windows or /dev/null on Unix machines, or redirecting it to a file that will cause the output to be saved to a disk. Alternatively, you can pipe (using the | pipe character) the output of one program to the input of another; it is this feature that we will make use of in order to connect our various tools together. For example, you could pipe the output from one program to the input of another program in a terminal using this code:
echo -n "Hello" | md5
The output of the echo command will be the string Hello (without the quotes), which is then piped to the md5 command; this command will in turn calculate the MD5 hash of Hello:
8b1a9953c4611296a827abf8c47804d7
Our tools will work with lines of strings where each line (separated by a linefeed character) represents one string. When run without any pipe redirection, we will be able to interact directly with the programs using the default in and out, which will be useful when testing and debugging our code.
-
No Comment