OS

• [Doc] TTY
• [Doc] OS (Operating System)
• [Doc] Command Line Options
• [Basic] Load
• [Point] CheckList
• [Basic] Indicators

TTY

“TTY” means “teletype”, a typewriter, and “pty” is “pseudo-teletype”, a pseudo typewriter. In Unix, /dev/tty* refers to any device that acts as a typewriter, such as the terminal.

You can view the currently logged in user through the w command, and you’ll find a new tty every time you login to a window.

$ w
 11:49:43 up 482 days, 19:38,  3 users,  load average: 0.03, 0.08, 0.07
USER     TTY      FROM             LOGIN@   IDLE   JCPU   PCPU WHAT
dev      pts/0    10.0.128.252     10:44    1:01m  0.09s  0.07s -bash
dev      pts/2    10.0.128.252     11:08    2:07   0.17s  0.14s top
root     pts/3    10.0.240.2       11:43    7.00s  0.04s  0.00s w

Using the ps command to see process information, there is also information about tty:

$ ps -x
  PID TTY      STAT   TIME COMMAND
 5530 ?        S      0:00 sshd: dev@pts/3
 5531 pts/3    Ss+    0:00 -bash
11296 ?        S      0:00 sshd: dev@pts/4
11297 pts/4    Ss     0:00 -bash
13318 pts/4    R+     0:00 ps -x
23733 ?        Ssl    2:53 PM2 v1.1.2: God Daemon

The process marked with ? is not depending on TTY, which is called Daemon.

In Node.js, you can use stdio’s isTTY attribute to determine whether the current process is in a TTY (such as terminal) environment.

$ node -p -e "Boolean(process.stdout.isTTY)"
true
$ node -p -e "Boolean(process.stdout.isTTY)" | cat
false

OS

You can get some auxiliary functions to the basic information of the current system through the OS module.

What’s the difference between the line breaks (EOL) of different operating systems?

End of line (EOL) is the same as newline, line ending and line break.

And it’s usually composed of line feed (LF, \n) and carriage return (CR, \r). Here are some common cases:

If you don’t understand the cross-system compatibility of EOL, you might have problems dealing with the line segmentation/row statistics of the file.

OS Constants

• Signal Constants, such as SIGHUP, SIGKILL, etc.
• POSIX Error Constants, such as EACCES, EADDRINUSE, etc.
• Windows Specific Error Constants, such as WSAEACCES, WSAEBADF, etc.
• libuv Constants, only UV_UDP_REUSEADDR.

Path

The built-in path in Node.js is a module for handling path problems, but as we all know, the paths are irreconcilable in different operating systems.

Windows vs. POSIX

After looking at the table, you should realize that when under a certain platform, the path module is actually the method of the corresponding platform. For example, I uses Mac here, so:

const path = require('path');
console.log(path.basename === path.posix.basename); // true

If you are on one of these platforms, but you need to deal with the path of another platform, you need to be aware of this cross platform issue.

path Object

on POSIX:

path.parse('/home/user/dir/file.txt')
// Returns:
// {
//    root : "/",
//    dir : "/home/user/dir",
//    base : "file.txt",
//    ext : ".txt",
//    name : "file"
// }

┌─────────────────────┬────────────┐
│          dir        │    base    │
├──────┬              ├──────┬─────┤
│ root │              │ name │ ext │
"  /    home/user/dir / file  .txt "
└──────┴──────────────┴──────┴─────┘

on Windows:

path.parse('C:\\path\\dir\\file.txt')
// Returns:
// {
//    root : "C:\\",
//    dir : "C:\\path\\dir",
//    base : "file.txt",
//    ext : ".txt",
//    name : "file"
// }

┌─────────────────────┬────────────┐
│          dir        │    base    │
├──────┬              ├──────┬─────┤
│ root │              │ name │ ext │
" C:\      path\dir   \ file  .txt "
└──────┴──────────────┴──────┴─────┘

path.extname(path)

Command Line Options

Command Line Options is some documentation on the use of CLI. There are 4 main ways of using CLI:

• node [options] [v8 options] [script.js | -e “script”] [arguments]
• node debug [script.js | -e “script” | :] …
• node —v8-options
• Starts REPL environment without parameters directly

Options

Environment Variable

Load

Load is an important concept to measure the running state of the server. Through the load situation, we can know whether the server is idle, good, busy or about to crash.

Typically, the load we want to look at is the CPU load, for more information you can read this blog: Understanding Linux CPU Load.

To get the current system load, you can use uptime, top command in terminal or os.loadavg() in Node.js:

load average: 0.09, 0.05, 0.01

Here are the average load on the system of the last 1 minutes, 5 minutes, 15 minutes. When one of the CPU core is working in full load, the value of load will be 1, so the value represents how many CPU cores are in full load.

In Node.js, the CPU load of a single process can be viewed using the pidusage module.

In addition to the CPU load, the server (prefer maintain) needs to know about the network load, disk load, and so on.

CheckList

A police officer sees a drunken man intently searching the ground near a lamppost and asks him the goal of his quest. The inebriate replies that he is looking for his car keys, and the officer helps for a few minutes without success then he asks whether the man is certain that he dropped the keys near the lamppost.
“No,” is the reply, “I lost the keys somewhere across the street.” “Why look here?” asks the surprised and irritated officer. “The light is much better here,” the intoxicated man responds with aplomb.

When it comes to checking server status, many server-side friends only know how to use the top command. In fact, the situation is the same as the jokes above, because top is the brightest street lamp for them.

For server-side programmers, the full server-side checklist is the USE Method described in the second chapter of 《Systems Performance》.

The USE Method provides a strategy for performing a complete check of system health, identifying common bottlenecks and errors. For each system resource, metrics for utilization, saturation and errors are identified and checked. Any issues discovered are then investigated using further strategies.

This is an example USE-based metric list for Linux operating systems (eg, Ubuntu, CentOS, Fedora). This is primarily intended for system administrators of the physical systems, who are using command line tools. Some of these metrics can be found in remote monitoring tools.

Physical Resources

Software Resources

ulimit

ulimit is used to manage user access to system resources.

-a   All current limits are reported
-c   The maximum size of core files created, take block as a unit
-d   <Data segment size> The maximum size of a process's data segment, take KB as a unit
-f   <File size> The maximum size of files written by the shell and its children, take block as a unit
-H   Set a hard limit to the resource, that is the limits set by the administrator
-m   <Memory size> The maximum resident set size, take KB as a unit
-n   <Number of file descriptors> The maximum number of open file descriptors at the same time
-p   <Cache size> The pipe size in 512-byte blocks, take 512-byte as a unit
-s   <Stack size> The maximum stack size, take KB as a unit
-S   Set flexible limits for resources
-t   The maximum amount of cpu time, in seconds
-u   <Number of processes> The maximum number of processes available to a single user
-v   <Virtual memory size> The maximum amount of virtual memory available to the shell, take KB as a unit

For example:

$ ulimit -a
core file size          (blocks, -c) 0
data seg size           (kbytes, -d) unlimited
scheduling priority             (-e) 0
file size               (blocks, -f) unlimited
pending signals                 (-i) 127988
max locked memory       (kbytes, -l) 64
max memory size         (kbytes, -m) unlimited
open files                      (-n) 655360
pipe size            (512 bytes, -p) 8
POSIX message queues     (bytes, -q) 819200
real-time priority              (-r) 0
stack size              (kbytes, -s) 8192
cpu time               (seconds, -t) unlimited
max user processes              (-u) 4096
virtual memory          (kbytes, -v) unlimited
file locks                      (-x) unlimited

Note: open socket and other resources are also kind of file descriptor, if ulimit -n is too small, not only will you not open the file, but also can not establish a socket link.