SED Tutorial

• The sed utility is an "editor"
• It is also noninteractive. This means you have to insert commands to be executed on the data at the command line or in a script to be processed.
• sed accepts a series of commands and executes them on a file (or set of files).
• sed fittingly stands for stream editor.
• It can be used to change all occurrences of "SAD" to "SED" or "New York" to "Newport."
• The stream editor is ideally suited to performing repetitive edits that would take considerable time if done manually.

How sed Works

The sed utility works by sequentially reading a file, line by line, into memory. It then performs all actions specified for the line and places the line back in memory to dump to the terminal with the requested changes made. After all actions have taken place to this one line, it reads the next line of the file and repeats the process until it is finished with the file. As mentioned, the default output is to display the contents of each line on the screen. Two important factors come into play here—first, the output can be redirected to another file to save the changes; second, the original file, by default, is left unchanged. The default is for sed to read the entire file and make changes to each line within it. It can, however, be restricted to specified lines as needed.

The syntax for the utility is:

sed [options] '{command}' [filename]

In this tutorial we will walk through the most commonly used commands and options and illustrate how they work and where they would be appropriate for use.

The Substitute Command

One of the most common uses of the sed utility, and any similar editor, is to substitute one value for another. To accomplish this, the syntax for the command portion of the operation is:

's/{old value}/{new value}/'

Thus, the following illustrates how "lion" can be changed to "eagle" very simply:

$ echo The lion group will meet on Tuesday after school | sed 



's/lion/eagle/'



The eagle group will meet on Tuesday after school



$

Notice that it is not necessary to specify a filename if input is being derived from the output of a preceding command—the same as is true for awk, sort, and most other LinuxUNIX command-line utility programs.

Multiple Changes

If multiple changes need to be made to the same file or line, there are three methods by which this can be accomplished. The first is to use the "-e" option, which informs the program that more than one editing command is being used. For example:

$ echo The lion group will meet on Tuesday after school | sed -e '



s/lion/eagle/' -e 's/after/before/'



The eagle group will meet on Tuesday before school



$

This is pretty much the long way of going about it, and the "-e" option is not commonly used to any great extent. A more preferable way is to separate command with semicolons:

$ echo The lion group will meet on Tuesday after school | sed '



s/lion/eagle/; s/after/before/'



The eagle group will meet on Tuesday before school 



$

Notice that the semicolon must be the next character following the slash. If a space is between the two, the operation will not successfully complete and an error message will be returned. These two methods are well and good, but there is one more method that many administrators prefer. The key thing to note is that everything between the two apostrophes (' ') is interpreted as sed commands. The shell program reading in the commands will not assume you are finished entering until the second apostrophe is entered. This means that the command can be entered on multiple lines—with Linux changing the prompt from PS1 to a continuation prompt (usually ">")—until the second apostrophe is entered. As soon as it is entered, and Enter pressed, the processing will take place and the same results will be generated, as the following illustrates:

$ echo The lion group will meet on Tuesday after school | sed '



> s/lion/eagle/



> s/after/before/'



The eagle group will meet on Tuesday before school



$

Global Changes

Let's begin with a deceptively simple edit. Suppose the message that is to be changed contains more than one occurrence of the item to be changed. By default, the result can be different than what was expected, as the following illustrates:

$ echo The lion group will meet this Tuesday at the same time



as the meeting last Tuesday | sed 's/Tuesday/Thursday/'



The lion group will meet this Thursday at the same time



as the meeting last Tuesday 



$

Instead of changing every occurrence of "Tuesday" for "Thursday," the sed editor moves on after finding a change and making it, without reading the whole line. The majority of sed commands function like the substitute one, meaning they all work for the first occurrence of the chosen sequence in each line. In order for every occurrence to be substituted, in the event that more than one occurrence appears in the same line, you must specify for the action to take place globally:

$ echo The lion group will meet this Tuesday at the same time



as the meeting last Tuesday | sed 's/Tuesday/Thursday/g'



The lion group will meet this Thursday at the same time



as the meeting last Thursday



$

Bear in mind that this need for globalization is true whether the sequence you are looking for consists of only one character or a phrase.

sed can also be used to change record field delimiters from one to another. For example, the following will change all tabs to spaces:

sed 's/	/ /g' 

where the entry between the first set of slashes is a tab, while the entry between the second set is a space. As a general rule, sed can be used to change any printable character to any other printable character. If you want to change unprintable characters to printable ones—for example, a bell to the word "bell"—sed is not the right tool for the job (but tr would be).

Sometimes, you don't want to change every occurrence that appears in a file. At times, you only want to make a change if certain conditions are met—for example, following a match of some other data. To illustrate, consider the following text file:

$ cat sample_one



one     1



two     1



three   1



one     1



two     1



two     1



three   1



$

Suppose that it would be desirable for "1" to be substituted with "2," but only after the word "two" and not throughout every line. This can be accomplished by specifying that a match is to be found before giving the substitute command:

$ sed '/two/ s/1/2/' sample_one



one     1



two     2



three   1



one     1



two     2



two     2



three   1



$

And now, to make it even more accurate:

$ sed '



> /two/ s/1/2/



> /three/ s/1/3/' sample_one



one     1



two     2



three   3



one     1



two     2



two     2



three   3



$

Bear in mind once again that the only thing changed is the display. If you look at the original file, it is the same as it always was. You must save the output to another file to create permanence. It is worth repeating that the fact that changes are not made to the original file is a true blessing in disguise—it lets you experiment with the file without causing any real harm, until you get the right commands working exactly the way you expect and want them to.

The following saves the changed output to a new file:

$ sed '



> /two/ s/1/2/



> /three/ s/1/3/' sample_one > sample_two

The output file has all the changes incorporated in it that would normally appear on the screen. It can now be viewed with head, cat, or any other similar utility.

Script Files

The sed tool allows you to create a script file containing commands that are processed from the file, rather than at the command line, and is referenced via the "-f" option. By creating a script file, you have the ability to run the same operations over and over again, and to specify far more detailed operations than what you would want to try to tackle from the command line each time.

Consider the following script file:

$ cat sedlist



/two/ s/1/2/



/three/ s/1/3/



$

It can now be used on the data file to obtain the same results we saw earlier:

$ sed -f sedlist sample_one



one     1



two     2



three   3



one     1



two     2



two     2



three   3



$

Notice that apostrophes are not used inside the source file, or from the command line when the "-f" option is invoked. Script files, also known as source files, are invaluable for operations that you intend to repeat more than once and for complicated commands where there is a possibility that you may make an error at the command line. It is far easier to edit the source file and change one character than to retype a multiple-line entry at the command line.

Restricting Lines

The default is for the editor to look at, and for editing to take place on, every line that is input to the stream editor. This can be changed by specifying restrictions preceding the command. For example, to substitute "1" with "2" only in the fifth and sixth lines of the sample file's output, the command would be:

$ sed '5,6 s/1/2/' sample_one



one     1



two     1



three   1



one     1



two     2



two     2



three   1



$

In this case, since the lines to changes were specifically specified, the substitute command was not needed. Thus you have the flexibility of choosing which lines to changes (essentially, restricting the changes) based upon matching criteria that can be either line numbers or a matched pattern.

Prohibiting the Display

The default is for sed to display on the screen (or to a file, if so redirected) every line from the original file, whether it is affected by an edit operation or not; the "-n" parameter overrides this action. "-n" overrides all printing and displays no lines whatsoever, whether they were changed by the edit or not. For example:

$ sed -n -f sedlist sample_one



$







$ sed -n -f sedlist sample_one > sample_two



$ cat sample_two



$

In the first example, nothing is displayed on the screen. In the second example, nothing is changed, and thus nothing is written to the new file—it ends up being empty. Doesn't this negate the whole purpose of the edit? Why is this useful? It is useful only because the "-n" option has the ability to be overridden by a print command (-p). To illustrate, suppose the script file were modified to now resemble the following:

$ cat sedlist



/two/ s/1/2/p



/three/ s/1/3/p



$

Then this would be the result of running it:

$ sed -n -f sedlist sample_one



two     2



three   3



two     2



two     2



three   3



$

Lines that stay the same as they were are not displayed at all. Only the lines affected by the edit are displayed. In this manner, it is possible to pull those lines only, make the changes, and place them in a separate file:

$ sed -n -f sedlist sample_one > sample_two



$







$ cat sample_two



two     2



three   3



two     2



two     2



three   3



$

Another method of utilizing this is to print only a set number of lines. For example, to print only lines two through six while making no other editing changes:

$ sed -n '2,6p' sample_one



two     1



three   1



one     1



two     1



two     1



$

All other lines are ignored, and only lines two through six are printed as output. This is something remarkable that you cannot do easily with any other utility. head will print the top of a file, and tail will print the bottom, but sed allows you to pull anything you want to from anywhere.

Deleting Lines

Substituting one value for another is far from the only function that can be performed with a stream editor. There are many more possibilities, and the second-most-used function in my opinion is delete. Delete works in the same manner as substitute, only it removes the specified lines (if you want to remove a word and not a line, don't think of deleting, but think of substituting it for nothing—s/cat//).

The syntax for the command is:

'{what to find} d'

To remove all of the lines containing "two" from the sample_one file:

$ sed '/two/ d' sample_one



one     1



three   1



one     1



three   1



$

To remove the first three lines from the display, regardless of what they are:

$ sed '1,3 d' sample_one



one     1



two     1



two     1



three   1



$

Only the remaining lines are shown, and the first three cease to exist in the display. There are several things to keep in mind with the stream editor as they relate to global expressions in general, and as they apply to deletions in particular:

sed '/^two/ d' sample_one

sed '/two$/ d' sample_one

sed '/^$/ d' {filename}

$ sed '/two/ s/1/2/; /three/ s/1/3/; /^$/ d' sample_one



one     1



two     1



three   1



one     1



two     2



two     2



three   1



$

sed '1,/^$/ d' {filename}

$ sed '$a



> This is where we stop



> the test' sample_one



one     1



two     1



three   1



one     1



two     1



two     1



three   1



This is where we stop



the test



$

$ sed '3a



> This is where we stop



> the test' sample_one



one     1



two     1



three   1



This is where we stop



the test



one     1



two     1



two     1



three   1



$

$ sed '3i



> This is where we stop



> the test' sample_one



one     1



two     1



This is where we stop



the test



three   1



one     1



two     1



two     1



three   1



$

$ sed '



> /two/ s/1/2/



> /three/ s/1/3/



> 1,3 w sample_three' sample_one



one     1



two     2



three   3



one     1



two     2



two     2



three   3



$







$ cat sample_three



one     1



two     2



three   3



$

$ sed '/two/ c



> We are no longer using two' sample_one



one     1



We are no longer using two



three   1



one     1



We are no longer using two



We are no longer using two



three   1



$

$ sed '/two/ d' sample_one



one     1



three   1



one     1



three   1



$

$ sed '/two/ !d' sample_one



two     1



two     1



two     1



$

#mcd.ksh



for I in $*



do



echo Old McDonald had a $I



echo E-I, E-I-O



done

#sublist



/ a a/ s/ a / an /



/ a e/ s/ a / an /



/a i/ s / a / an /



/a o/ s/ a / an /



/a u/ s/ a / an /

$ sh mcd.ksh 'cat animals' | sed -f sublist  

$ sed '



> /two/ s/1/2/



> /three/ s/1/3/



> 5q' sample_one



one     1



two     2



three   3



one     1



two     2



$

$ sed '



> /two/ s/1/2/



> /three/ s/1/3/



> /three/q' sample_one



one     1



two     2



three   3



$

sed 110q filename

$ sed '



> /two/ s/two/three/



> /three/ s/three/four/' sample_one



one     1



four     1



four   1



one     1



four     1



four     1



four   1



$

$ sed '



> /three/ s/three/four/



> /two/ s/two/three/' sample_one



one     1



three     1



four   1



one     1



three     1



three     1



four   1



$

         :HERE

    b HERE

    :HERE

翻译一篇技术评论社的文章，是讲memcached的连载。fcicq同学说这个东西很有用，希望大家喜欢。

发表日：2008/7/2
作者：长野雅广(Masahiro Nagano)
原文链接：http://gihyo.jp/dev/feature/01/memcached/0001

我是mixi株式会社开发部系统运营组的长野。 日常负责程序的运营。从今天开始，将分几次针对最近在Web应用的可扩展性领域 的热门话题memcached，与我公司开发部研究开发组的前坂一起， 说明其内部结构和使用。

memcached是什么？

memcached 是以LiveJournal 旗下Danga Interactive 公司的Brad Fitzpatric 为首开发的一款软件。现在已成为 mixi、 hatena、 Facebook、 Vox、LiveJournal等众多服务中 提高Web应用扩展性的重要因素。

许多Web应用都将数据保存到RDBMS中，应用服务器从中读取数据并在浏览器中显示。 但随着数据量的增大、访问的集中，就会出现RDBMS的负担加重、数据库响应恶化、 网站显示延迟等重大影响。

这时就该memcached大显身手了。memcached是高性能的分布式内存缓存服务器。 一般的使用目的是，通过缓存数据库查询结果，减少数据库访问次数，以提高动态Web应用的速度、 提高可扩展性。

图1 一般情况下memcached的用途

memcached的特征

memcached作为高速运行的分布式缓存服务器，具有以下的特点。

• 协议简单
• 基于libevent的事件处理
• 内置内存存储方式
• memcached不互相通信的分布式

协议简单

memcached的服务器客户端通信并不使用复杂的XML等格式， 而使用简单的基于文本行的协议。因此，通过telnet 也能在memcached上保存数据、取得数据。下面是例子。

$ telnet localhost 11211



Trying 127.0.0.1...



Connected to localhost.localdomain (127.0.0.1).



Escape character is '^]'.



set foo 0 0 3     （保存命令）



bar               （数据）



STORED            （结果）



get foo           （取得命令）



VALUE foo 0 3     （数据）



bar               （数据）

协议文档位于memcached的源代码内，也可以参考以下的URL。

• http://code.sixapart.com/svn/memcached/trunk/server/doc/protocol.txt

基于libevent的事件处理

libevent是个程序库，它将Linux的epoll、BSD类操作系统的kqueue等事件处理功能 封装成统一的接口。即使对服务器的连接数增加，也能发挥O(1)的性能。 memcached使用这个libevent库，因此能在Linux、BSD、Solaris等操作系统上发挥其高性能。 关于事件处理这里就不再详细介绍，可以参考Dan Kegel的The C10K Problem。

• libevent: http://www.monkey.org/~provos/libevent/
• The C10K Problem: http://www.kegel.com/c10k.html

内置内存存储方式

为了提高性能，memcached中保存的数据都存储在memcached内置的内存存储空间中。 由于数据仅存在于内存中，因此重启memcached、重启操作系统会导致全部数据消失。 另外，内容容量达到指定值之后，就基于LRU(Least Recently Used)算法自动删除不使用的缓存。 memcached本身是为缓存而设计的服务器，因此并没有过多考虑数据的永久性问题。 关于内存存储的详细信息，本连载的第二讲以后前坂会进行介绍，请届时参考。

memcached不互相通信的分布式

memcached尽管是“分布式”缓存服务器，但服务器端并没有分布式功能。 各个memcached不会互相通信以共享信息。那么，怎样进行分布式呢？ 这完全取决于客户端的实现。本连载也将介绍memcached的分布式。

图2 memcached的分布式

接下来简单介绍一下memcached的使用方法。

安装memcached

memcached的安装比较简单，这里稍加说明。

memcached支持许多平台。

• Linux
• FreeBSD
• Solaris (memcached 1.2.5以上版本)
• Mac OS X

另外也能安装在Windows上。这里使用Fedora Core 8进行说明。

memcached的安装

运行memcached需要本文开头介绍的libevent库。Fedora 8中有现成的rpm包， 通过yum命令安装即可。

$ sudo yum install libevent libevent-devel

memcached的源代码可以从memcached网站上下载。本文执笔时的最新版本为1.2.5。 Fedora 8虽然也包含了memcached的rpm，但版本比较老。因为源代码安装并不困难， 这里就不使用rpm了。

• 下载memcached：http://www.danga.com/memcached/download.bml

memcached安装与一般应用程序相同，configure、make、make install就行了。

$ wget http://www.danga.com/memcached/dist/memcached-1.2.5.tar.gz



$ tar zxf memcached-1.2.5.tar.gz



$ cd memcached-1.2.5



$ ./configure



$ make



$ sudo make install

默认情况下memcached安装到/usr/local/bin下。

memcached的启动

从终端输入以下命令，启动memcached。

$ /usr/local/bin/memcached -p 11211 -m 64m -vv



slab class   1: chunk size     88 perslab 11915



slab class   2: chunk size    112 perslab  9362



slab class   3: chunk size    144 perslab  7281



中间省略



slab class  38: chunk size 391224 perslab     2



slab class  39: chunk size 489032 perslab     2



<23 server listening



<24 send buffer was 110592, now 268435456



<24 server listening (udp)



<24 server listening (udp)



<24 server listening (udp)



<24 server listening (udp)

这里显示了调试信息。这样就在前台启动了memcached，监听TCP端口11211 最大内存使用量为64M。调试信息的内容大部分是关于存储的信息， 下次连载时具体说明。

作为daemon后台启动时，只需

$ /usr/local/bin/memcached -p 11211 -m 64m -d

这里使用的memcached启动选项的内容如下。

上面四个是常用的启动选项，其他还有很多，通过

$ /usr/local/bin/memcached -h

命令可以显示。许多选项可以改变memcached的各种行为， 推荐读一读。

用客户端连接

许多语言都实现了连接memcached的客户端，其中以Perl、PHP为主。 仅仅memcached网站上列出的语言就有

• Perl
• PHP
• Python
• Ruby
• C#
• C/C++
• Lua

等等。

• memcached客户端API：http://www.danga.com/memcached/apis.bml

这里介绍通过mixi正在使用的Perl库链接memcached的方法。

使用Cache::Memcached

Perl的memcached客户端有

• Cache::Memcached
• Cache::Memcached::Fast
• Cache::Memcached::libmemcached

等几个CPAN模块。这里介绍的Cache::Memcached是memcached的作者Brad Fitzpatric的作品， 应该算是memcached的客户端中应用最为广泛的模块了。

• Cache::Memcached - search.cpan.org: http://search.cpan.org/dist/Cache-Memcached/

使用Cache::Memcached连接memcached

下面的源代码为通过Cache::Memcached连接刚才启动的memcached的例子。

#!/usr/bin/perl







use strict;



use warnings;



use Cache::Memcached;







my $key = "foo";



my $value = "bar";



my $expires = 3600; # 1 hour



my $memcached = Cache::Memcached->new({



servers => ["127.0.0.1:11211"],



compress_threshold => 10_000



});







$memcached->add($key, $value, $expires);



my $ret = $memcached->get($key);



print "$ret"n";

在这里，为Cache::Memcached指定了memcached服务器的IP地址和一个选项，以生成实例。 Cache::Memcached常用的选项如下所示。

另外，Cache::Memcached通过Storable模块可以将Perl的复杂数据序列化之后再保存， 因此散列、数组、对象等都可以直接保存到memcached中。

保存数据

向memcached保存数据的方法有

• add
• replace
• set

它们的使用方法都相同：

my $add = $memcached->add( '键', '值', '期限' );



my $replace = $memcached->replace( '键', '值', '期限' );



my $set = $memcached->set( '键', '值', '期限' );

向memcached保存数据时可以指定期限(秒)。不指定期限时，memcached按照LRU算法保存数据。 这三个方法的区别如下：

获取数据

获取数据可以使用get和get_multi方法。

my $val = $memcached->get('键');



my $val = $memcached->get_multi('键1', '键2', '键3', '键4', '键5');

一次取得多条数据时使用get_multi。get_multi可以非同步地同时取得多个键值， 其速度要比循环调用get快数十倍。

删除数据

删除数据使用delete方法，不过它有个独特的功能。

$memcached->delete('键', '阻塞时间(秒)');

删除第一个参数指定的键的数据。第二个参数指定一个时间值，可以禁止使用同样的键保存新数据。 此功能可以用于防止缓存数据的不完整。但是要注意，set函数忽视该阻塞，照常保存数据

增一和减一操作

可以将memcached上特定的键值作为计数器使用。

my $ret = $memcached->incr('键');



$memcached->add('键', 0) unless defined $ret;

增一和减一是原子操作，但未设置初始值时，不会自动赋成0。因此， 应当进行错误检查，必要时加入初始化操作。而且，服务器端也不会对 超过2³²时的行为进行检查。

总结

这次简单介绍了memcached，以及它的安装方法、Perl客户端Cache::Memcached的用法。 只要知道，memcached的使用方法十分简单就足够了。

下次由前坂来说明memcached的内部结构。了解memcached的内部构造， 就能知道如何使用memcached才能使Web应用的速度更上一层楼。 欢迎继续阅读下一章。

2.理解memcached的内存存储

下面是《memcached全面剖析》的第二部分。

发表日：2008/7/9
作者：前坂徹(Toru Maesaka)
原文链接：http://gihyo.jp/dev/feature/01/memcached/0002

我是mixi株式会社研究开发组的前坂徹。 上次的文章介绍了memcached是分布式的高速缓存服务器。 本次将介绍memcached的内部构造的实现方式，以及内存的管理方式。 另外，memcached的内部构造导致的弱点也将加以说明。

Slab Allocation机制：整理内存以便重复使用

最近的memcached默认情况下采用了名为Slab Allocator的机制分配、管理内存。 在该机制出现以前，内存的分配是通过对所有记录简单地进行malloc和free来进行的。 但是，这种方式会导致内存碎片，加重操作系统内存管理器的负担，最坏的情况下， 会导致操作系统比memcached进程本身还慢。Slab Allocator就是为解决该问题而诞生的。

下面来看看Slab Allocator的原理。下面是memcached文档中的slab allocator的目标：

the primary goal of the slabs subsystem in memcached was to eliminate memory fragmentation issues totally by using fixed-size memory chunks coming from a few predetermined size classes.

也就是说，Slab Allocator的基本原理是按照预先规定的大小，将分配的内存分割成特定长度的块， 以完全解决内存碎片问题。

Slab Allocation的原理相当简单。 将分配的内存分割成各种尺寸的块（chunk）， 并把尺寸相同的块分成组（chunk的集合）（图1）。

图1 Slab Allocation的构造图

而且，slab allocator还有重复使用已分配的内存的目的。 也就是说，分配到的内存不会释放，而是重复利用。

Slab Allocation的主要术语

Page

分配给Slab的内存空间，默认是1MB。分配给Slab之后根据slab的大小切分成chunk。

Chunk

用于缓存记录的内存空间。

Slab Class

特定大小的chunk的组。

在Slab中缓存记录的原理

下面说明memcached如何针对客户端发送的数据选择slab并缓存到chunk中。

memcached根据收到的数据的大小，选择最适合数据大小的slab（图2）。 memcached中保存着slab内空闲chunk的列表，根据该列表选择chunk， 然后将数据缓存于其中。

图2 选择存储记录的组的方法

实际上，Slab Allocator也是有利也有弊。下面介绍一下它的缺点。

Slab Allocator的缺点

Slab Allocator解决了当初的内存碎片问题，但新的机制也给memcached带来了新的问题。

这个问题就是，由于分配的是特定长度的内存，因此无法有效利用分配的内存。 例如，将100字节的数据缓存到128字节的chunk中，剩余的28字节就浪费了（图3）。

图3 chunk空间的使用

对于该问题目前还没有完美的解决方案，但在文档中记载了比较有效的解决方案。

The most efficient way to reduce the waste is to use a list of size classes that closely matches (if that's at all possible) common sizes of objects that the clients of this particular installation of memcached are likely to store.

就是说，如果预先知道客户端发送的数据的公用大小，或者仅缓存大小相同的数据的情况下， 只要使用适合数据大小的组的列表，就可以减少浪费。

但是很遗憾，现在还不能进行任何调优，只能期待以后的版本了。 但是，我们可以调节slab class的大小的差别。 接下来说明growth factor选项。

使用Growth Factor进行调优

memcached在启动时指定 Growth Factor因子（通过-f选项）， 就可以在某种程度上控制slab之间的差异。默认值为1.25。 但是，在该选项出现之前，这个因子曾经固定为2，称为“powers of 2”策略。

让我们用以前的设置，以verbose模式启动memcached试试看：

$ memcached -f 2 -vv

下面是启动后的verbose输出：

slab class   1: chunk size    128 perslab  8192



slab class   2: chunk size    256 perslab  4096



slab class   3: chunk size    512 perslab  2048



slab class   4: chunk size   1024 perslab  1024



slab class   5: chunk size   2048 perslab   512



slab class   6: chunk size   4096 perslab   256



slab class   7: chunk size   8192 perslab   128



slab class   8: chunk size  16384 perslab    64



slab class   9: chunk size  32768 perslab    32



slab class  10: chunk size  65536 perslab    16



slab class  11: chunk size 131072 perslab     8



slab class  12: chunk size 262144 perslab     4



slab class  13: chunk size 524288 perslab     2

可见，从128字节的组开始，组的大小依次增大为原来的2倍。 这样设置的问题是，slab之间的差别比较大，有些情况下就相当浪费内存。 因此，为尽量减少内存浪费，两年前追加了growth factor这个选项。

来看看现在的默认设置（f=1.25）时的输出（篇幅所限，这里只写到第10组）：

slab class   1: chunk size     88 perslab 11915



slab class   2: chunk size    112 perslab  9362



slab class   3: chunk size    144 perslab  7281



slab class   4: chunk size    184 perslab  5698



slab class   5: chunk size    232 perslab  4519



slab class   6: chunk size    296 perslab  3542



slab class   7: chunk size    376 perslab  2788



slab class   8: chunk size    472 perslab  2221



slab class   9: chunk size    592 perslab  1771



slab class  10: chunk size    744 perslab  1409

可见，组间差距比因子为2时小得多，更适合缓存几百字节的记录。 从上面的输出结果来看，可能会觉得有些计算误差， 这些误差是为了保持字节数的对齐而故意设置的。

将memcached引入产品，或是直接使用默认值进行部署时， 最好是重新计算一下数据的预期平均长度，调整growth factor， 以获得最恰当的设置。内存是珍贵的资源，浪费就太可惜了。

接下来介绍一下如何使用memcached的stats命令查看slabs的利用率等各种各样的信息。

查看memcached的内部状态

memcached有个名为stats的命令，使用它可以获得各种各样的信息。 执行命令的方法很多，用telnet最为简单：

$ telnet 主机名 端口号

连接到memcached之后，输入stats再按回车，即可获得包括资源利用率在内的各种信息。 此外，输入"stats slabs"或"stats items"还可以获得关于缓存记录的信息。 结束程序请输入quit。

这些命令的详细信息可以参考memcached软件包内的protocol.txt文档。

$ telnet localhost 11211



Trying ::1...



Connected to localhost.



Escape character is '^]'.



stats



STAT pid 481



STAT uptime 16574



STAT time 1213687612



STAT version 1.2.5



STAT pointer_size 32



STAT rusage_user 0.102297



STAT rusage_system 0.214317



STAT curr_items 0



STAT total_items 0



STAT bytes 0



STAT curr_connections 6



STAT total_connections 8



STAT connection_structures 7



STAT cmd_get 0



STAT cmd_set 0



STAT get_hits 0



STAT get_misses 0



STAT evictions 0



STAT bytes_read 20



STAT bytes_written 465



STAT limit_maxbytes 67108864



STAT threads 4



END



quit

另外，如果安装了libmemcached这个面向C/C++语言的客户端库，就会安装 memstat 这个命令。 使用方法很简单，可以用更少的步骤获得与telnet相同的信息，还能一次性从多台服务器获得信息。

$ memstat --servers=server1,server2,server3,...

libmemcached可以从下面的地址获得：

• http://tangent.org/552/libmemcached.html

查看slabs的使用状况

使用memcached的创造着Brad写的名为memcached-tool的Perl脚本，可以方便地获得slab的使用情况 （它将memcached的返回值整理成容易阅读的格式）。可以从下面的地址获得脚本：

• http://code.sixapart.com/svn/memcached/trunk/server/scripts/memcached-tool

使用方法也极其简单：

$ memcached-tool 主机名:端口 选项

查看slabs使用状况时无需指定选项，因此用下面的命令即可：

$ memcached-tool 主机名:端口

获得的信息如下所示：

 #  Item_Size   Max_age  1MB_pages Count   Full?



1     104 B  1394292 s    1215 12249628    yes



2     136 B  1456795 s      52  400919     yes



3     176 B  1339587 s      33  196567     yes



4     224 B  1360926 s     109  510221     yes



5     280 B  1570071 s      49  183452     yes



6     352 B  1592051 s      77  229197     yes



7     440 B  1517732 s      66  157183     yes



8     552 B  1460821 s      62  117697     yes



9     696 B  1521917 s     143  215308     yes



10     872 B  1695035 s     205  246162     yes



11     1.1 kB 1681650 s     233  221968     yes



12     1.3 kB 1603363 s     241  183621     yes



13     1.7 kB 1634218 s      94   57197     yes



14     2.1 kB 1695038 s      75   36488     yes



15     2.6 kB 1747075 s      65   25203     yes



16     3.3 kB 1760661 s      78   24167     yes

各列的含义为：

从这个脚本获得的信息对于调优非常方便，强烈推荐使用。

内存存储的总结

本次简单说明了memcached的缓存机制和调优方法。 希望读者能理解memcached的内存管理原理及其优缺点。

下次将继续说明LRU和Expire等原理，以及memcached的最新发展方向—— 可扩充体系（pluggable architecher））。

3.memcached的删除机制和发展方向

下面是《memcached全面剖析》的第三部分。

发表日：2008/7/16
作者：前坂徹(Toru Maesaka)
原文链接：http://gihyo.jp/dev/feature/01/memcached/0003

memcached是缓存，所以数据不会永久保存在服务器上，这是向系统中引入memcached的前提。 本次介绍memcached的数据删除机制，以及memcached的最新发展方向——二进制协议（Binary Protocol） 和外部引擎支持。

memcached在数据删除方面有效利用资源

数据不会真正从memcached中消失

上次介绍过， memcached不会释放已分配的内存。记录超时后，客户端就无法再看见该记录（invisible，透明）， 其存储空间即可重复使用。

Lazy Expiration

memcached内部不会监视记录是否过期，而是在get时查看记录的时间戳，检查记录是否过期。 这种技术被称为lazy（惰性）expiration。因此，memcached不会在过期监视上耗费CPU时间。

LRU：从缓存中有效删除数据的原理

memcached会优先使用已超时的记录的空间，但即使如此，也会发生追加新记录时空间不足的情况， 此时就要使用名为 Least Recently Used（LRU）机制来分配空间。 顾名思义，这是删除“最近最少使用”的记录的机制。 因此，当memcached的内存空间不足时（无法从slab class 获取到新的空间时），就从最近未被使用的记录中搜索，并将其空间分配给新的记录。 从缓存的实用角度来看，该模型十分理想。

不过，有些情况下LRU机制反倒会造成麻烦。memcached启动时通过“-M”参数可以禁止LRU，如下所示：

$ memcached -M -m 1024

启动时必须注意的是，小写的“-m”选项是用来指定最大内存大小的。不指定具体数值则使用默认值64MB。

指定“-M”参数启动后，内存用尽时memcached会返回错误。 话说回来，memcached毕竟不是存储器，而是缓存，所以推荐使用LRU。

memcached的最新发展方向

memcached的roadmap上有两个大的目标。一个是二进制协议的策划和实现，另一个是外部引擎的加载功能。

关于二进制协议

使用二进制协议的理由是它不需要文本协议的解析处理，使得原本高速的memcached的性能更上一层楼， 还能减少文本协议的漏洞。目前已大部分实现，开发用的代码库中已包含了该功能。 memcached的下载页面上有代码库的链接。

• http://danga.com/memcached/download.bml

二进制协议的格式

协议的包为24字节的帧，其后面是键和无结构数据（Unstructured Data）。 实际的格式如下（引自协议文档）：

 Byte/     0       |       1       |       2       |       3       |   



/              |               |               |               |   



|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|



+---------------+---------------+---------------+---------------+



0/ HEADER                                                        /   



/                                                               /   



/                                                               /   



/                                                               /   



+---------------+---------------+---------------+---------------+



24/ COMMAND-SPECIFIC EXTRAS (as needed)                           /   



+/  (note length in th extras length header field)               /   



+---------------+---------------+---------------+---------------+



m/ Key (as needed)                                               /   



+/  (note length in key length header field)                     /   



+---------------+---------------+---------------+---------------+



n/ Value (as needed)                                             /   



+/  (note length is total body length header field, minus        /   



+/   sum of the extras and key length body fields)               /   



+---------------+---------------+---------------+---------------+



Total 24 bytes

如上所示，包格式十分简单。需要注意的是，占据了16字节的头部(HEADER)分为 请求头（Request Header）和响应头（Response Header）两种。 头部中包含了表示包的有效性的Magic字节、命令种类、键长度、值长度等信息，格式如下：

Request Header







Byte/     0       |       1       |       2       |       3       |



/              |               |               |               |



|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|



+---------------+---------------+---------------+---------------+



0| Magic         | Opcode        | Key length                    |



+---------------+---------------+---------------+---------------+



4| Extras length | Data type     | Reserved                      |



+---------------+---------------+---------------+---------------+



8| Total body length                                             |



+---------------+---------------+---------------+---------------+



12| Opaque                                                        |



+---------------+---------------+---------------+---------------+



16| CAS                                                           |



|                                                               |



+---------------+---------------+---------------+---------------+

Response Header







Byte/     0       |       1       |       2       |       3       |



/              |               |               |               |



|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|



+---------------+---------------+---------------+---------------+



0| Magic         | Opcode        | Key Length                    |



+---------------+---------------+---------------+---------------+



4| Extras length | Data type     | Status                        |



+---------------+---------------+---------------+---------------+



8| Total body length                                             |



+---------------+---------------+---------------+---------------+



12| Opaque                                                        |



+---------------+---------------+---------------+---------------+



16| CAS                                                           |



|                                                               |



+---------------+---------------+---------------+---------------+

如希望了解各个部分的详细内容，可以checkout出memcached的二进制协议的代码树， 参考其中的docs文件夹中的protocol_binary.txt文档。

HEADER中引人注目的地方

看到HEADER格式后我的感想是，键的上限太大了！现在的memcached规格中，键长度最大为250字节， 但二进制协议中键的大小用2字节表示。因此，理论上最大可使用65536字节（2¹⁶）长的键。 尽管250字节以上的键并不会太常用，二进制协议发布之后就可以使用巨大的键了。

二进制协议从下一版本1.3系列开始支持。

外部引擎支持

我去年曾经试验性地将memcached的存储层改造成了可扩展的（pluggable）。

• http://alpha.mixi.co.jp/blog/?p=129

MySQL的Brian Aker看到这个改造之后，就将代码发到了memcached的邮件列表。 memcached的开发者也十分感兴趣，就放到了roadmap中。现在由我和 memcached的开发者Trond Norbye协同开发（规格设计、实现和测试）。 和国外协同开发时时差是个大问题，但抱着相同的愿景， 最后终于可以将可扩展架构的原型公布了。 代码库可以从memcached的下载页面 上访问。

外部引擎支持的必要性

世界上有许多memcached的派生软件，其理由是希望永久保存数据、实现数据冗余等， 即使牺牲一些性能也在所不惜。我在开发memcached之前，在mixi的研发部也曾经 考虑过重新发明memcached。

外部引擎的加载机制能封装memcached的网络功能、事件处理等复杂的处理。 因此，现阶段通过强制手段或重新设计等方式使memcached和存储引擎合作的困难 就会烟消云散，尝试各种引擎就会变得轻而易举了。

简单API设计的成功的关键

该项目中我们最重视的是API设计。函数过多，会使引擎开发者感到麻烦； 过于复杂，实现引擎的门槛就会过高。因此，最初版本的接口函数只有13个。 具体内容限于篇幅，这里就省略了，仅说明一下引擎应当完成的操作：

• 引擎信息（版本等）
• 引擎初始化
• 引擎关闭
• 引擎的统计信息
• 在容量方面，测试给定记录能否保存
• 为item（记录）结构分配内存
• 释放item（记录）的内存
• 删除记录
• 保存记录
• 回收记录
• 更新记录的时间戳
• 数学运算处理
• 数据的flush

对详细规格有兴趣的读者，可以checkout engine项目的代码，阅读器中的engine.h。

重新审视现在的体系

memcached支持外部存储的难点是，网络和事件处理相关的代码（核心服务器）与 内存存储的代码紧密关联。这种现象也称为tightly coupled（紧密耦合）。 必须将内存存储的代码从核心服务器中独立出来，才能灵活地支持外部引擎。 因此，基于我们设计的API，memcached被重构成下面的样子：

重构之后，我们与1.2.5版、二进制协议支持版等进行了性能对比，证实了它不会造成性能影响。

在考虑如何支持外部引擎加载时，让memcached进行并行控制（concurrency control）的方案是最为容易的， 但是对于引擎而言，并行控制正是性能的真谛，因此我们采用了将多线程支持完全交给引擎的设计方案。

以后的改进，会使得memcached的应用范围更为广泛。

总结

本次介绍了memcached的超时原理、内部如何删除数据等，在此之上又介绍了二进制协议和 外部引擎支持等memcached的最新发展方向。这些功能要到1.3版才会支持，敬请期待！

这是我在本连载中的最后一篇。感谢大家阅读我的文章！

下次由长野来介绍memcached的应用知识和应用程序兼容性等内容。

4. memcached的分布式算法

发表日：2008/7/23
作者：长野雅广(Masahiro Nagano)
原文链接：http://gihyo.jp/dev/feature/01/memcached/0004

我是Mixi的长野。 第2次、 第3次 由前坂介绍了memcached的内部情况。本次不再介绍memcached的内部结构， 开始介绍memcached的分布式。

memcached的分布式

正如第1次中介绍的那样， memcached虽然称为“分布式”缓存服务器，但服务器端并没有“分布式”功能。 服务器端仅包括 第2次、 第3次 前坂介绍的内存存储功能，其实现非常简单。 至于memcached的分布式，则是完全由客户端程序库实现的。 这种分布式是memcached的最大特点。

memcached的分布式是什么意思？

这里多次使用了“分布式”这个词，但并未做详细解释。 现在开始简单地介绍一下其原理，各个客户端的实现基本相同。

下面假设memcached服务器有node1～node3三台， 应用程序要保存键名为“tokyo”“kanagawa”“chiba”“saitama”“gunma” 的数据。

图1 分布式简介：准备

首先向memcached中添加“tokyo”。将“tokyo”传给客户端程序库后， 客户端实现的算法就会根据“键”来决定保存数据的memcached服务器。 服务器选定后，即命令它保存“tokyo”及其值。

图2 分布式简介：添加时

同样，“kanagawa”“chiba”“saitama”“gunma”都是先选择服务器再保存。

接下来获取保存的数据。获取时也要将要获取的键“tokyo”传递给函数库。 函数库通过与数据保存时相同的算法，根据“键”选择服务器。 使用的算法相同，就能选中与保存时相同的服务器，然后发送get命令。 只要数据没有因为某些原因被删除，就能获得保存的值。

图3 分布式简介：获取时

这样，将不同的键保存到不同的服务器上，就实现了memcached的分布式。 memcached服务器增多后，键就会分散，即使一台memcached服务器发生故障 无法连接，也不会影响其他的缓存，系统依然能继续运行。

接下来介绍第1次 中提到的Perl客户端函数库Cache::Memcached实现的分布式方法。

Cache::Memcached的分布式方法

Perl的memcached客户端函数库Cache::Memcached是 memcached的作者Brad Fitzpatrick的作品，可以说是原装的函数库了。

• Cache::Memcached - search.cpan.org

该函数库实现了分布式功能，是memcached标准的分布式方法。

根据余数计算分散

Cache::Memcached的分布式方法简单来说，就是“根据服务器台数的余数进行分散”。 求得键的整数哈希值，再除以服务器台数，根据其余数来选择服务器。

下面将Cache::Memcached简化成以下的Perl脚本来进行说明。

use strict;



use warnings;



use String::CRC32;







my @nodes = ('node1','node2','node3');



my @keys = ('tokyo', 'kanagawa', 'chiba', 'saitama', 'gunma');







foreach my $key (@keys) {



my $crc = crc32($key);             # CRC値



my $mod = $crc % ( $#nodes + 1 );



my $server = $nodes[ $mod ];       # 根据余数选择服务器



printf "%s => %s"n", $key, $server;



}

Cache::Memcached在求哈希值时使用了CRC。

• String::CRC32 - search.cpan.org

首先求得字符串的CRC值，根据该值除以服务器节点数目得到的余数决定服务器。 上面的代码执行后输入以下结果：

tokyo       => node2



kanagawa => node3



chiba       => node2



saitama   => node1



gunma     => node1

根据该结果，“tokyo”分散到node2，“kanagawa”分散到node3等。 多说一句，当选择的服务器无法连接时，Cache::Memcached会将连接次数 添加到键之后，再次计算哈希值并尝试连接。这个动作称为rehash。 不希望rehash时可以在生成Cache::Memcached对象时指定“rehash => 0”选项。

根据余数计算分散的缺点

余数计算的方法简单，数据的分散性也相当优秀，但也有其缺点。 那就是当添加或移除服务器时，缓存重组的代价相当巨大。 添加服务器后，余数就会产生巨变，这样就无法获取与保存时相同的服务器， 从而影响缓存的命中率。用Perl写段代码来验证其代价。

use strict;



use warnings;



use String::CRC32;







my @nodes = @ARGV;



my @keys = ('a'..'z');



my %nodes;







foreach my $key ( @keys ) {



my $hash = crc32($key);



my $mod = $hash % ( $#nodes + 1 );



my $server = $nodes[ $mod ];



push @{ $nodes{ $server } }, $key;



}







foreach my $node ( sort keys %nodes ) {



printf "%s: %s"n", $node,  join ",", @{ $nodes{$node} };



}

这段Perl脚本演示了将“a”到“z”的键保存到memcached并访问的情况。 将其保存为mod.pl并执行。

首先，当服务器只有三台时：

$ mod.pl node1 node2 nod3



node1: a,c,d,e,h,j,n,u,w,x



node2: g,i,k,l,p,r,s,y



node3: b,f,m,o,q,t,v,z

结果如上，node1保存a、c、d、e……，node2保存g、i、k……， 每台服务器都保存了8个到10个数据。

接下来增加一台memcached服务器。

$ mod.pl node1 node2 node3 node4



node1: d,f,m,o,t,v



node2: b,i,k,p,r,y



node3: e,g,l,n,u,w



node4: a,c,h,j,q,s,x,z

添加了node4。可见，只有d、i、k、p、r、y命中了。像这样，添加节点后 键分散到的服务器会发生巨大变化。26个键中只有六个在访问原来的服务器， 其他的全都移到了其他服务器。命中率降低到23%。在Web应用程序中使用memcached时， 在添加memcached服务器的瞬间缓存效率会大幅度下降，负载会集中到数据库服务器上， 有可能会发生无法提供正常服务的情况。

mixi的Web应用程序运用中也有这个问题，导致无法添加memcached服务器。 但由于使用了新的分布式方法，现在可以轻而易举地添加memcached服务器了。 这种分布式方法称为 Consistent Hashing。

Consistent Hashing

关于Consistent Hashing的思想，mixi株式会社的开发blog等许多地方都介绍过， 这里只简单地说明一下。

• mixi Engineers' Blog - スマートな分散で快適キャッシュライフ
• ConsistentHashing - コンシステント ハッシュ法

Consistent Hashing的简单说明

Consistent Hashing如下所示：首先求出memcached服务器（节点）的哈希值， 并将其配置到0～2³²的圆（continuum）上。 然后用同样的方法求出存储数据的键的哈希值，并映射到圆上。 然后从数据映射到的位置开始顺时针查找，将数据保存到找到的第一个服务器上。 如果超过2³²仍然找不到服务器，就会保存到第一台memcached服务器上。

图4 Consistent Hashing：基本原理

从上图的状态中添加一台memcached服务器。余数分布式算法由于保存键的服务器会发生巨大变化 而影响缓存的命中率，但Consistent Hashing中，只有在continuum上增加服务器的地点逆时针方向的 第一台服务器上的键会受到影响。

图5 Consistent Hashing：添加服务器

因此，Consistent Hashing最大限度地抑制了键的重新分布。 而且，有的Consistent Hashing的实现方法还采用了虚拟节点的思想。 使用一般的hash函数的话，服务器的映射地点的分布非常不均匀。 因此，使用虚拟节点的思想，为每个物理节点（服务器） 在continuum上分配100～200个点。这样就能抑制分布不均匀， 最大限度地减小服务器增减时的缓存重新分布。

通过下文中介绍的使用Consistent Hashing算法的memcached客户端函数库进行测试的结果是， 由服务器台数（n）和增加的服务器台数（m）计算增加服务器后的命中率计算公式如下：

(1 - n/(n+m)) * 100

支持Consistent Hashing的函数库

本连载中多次介绍的Cache::Memcached虽然不支持Consistent Hashing， 但已有几个客户端函数库支持了这种新的分布式算法。 第一个支持Consistent Hashing和虚拟节点的memcached客户端函数库是 名为libketama的PHP库，由last.fm开发。

• libketama - a consistent hashing algo for memcache clients – RJ ブログ - Users at Last.fm

至于Perl客户端，连载的第1次 中介绍过的Cache::Memcached::Fast和Cache::Memcached::libmemcached支持 Consistent Hashing。

• Cache::Memcached::Fast - search.cpan.org
• Cache::Memcached::libmemcached - search.cpan.org

两者的接口都与Cache::Memcached几乎相同，如果正在使用Cache::Memcached， 那么就可以方便地替换过来。Cache::Memcached::Fast重新实现了libketama， 使用Consistent Hashing创建对象时可以指定ketama_points选项。

my $memcached = Cache::Memcached::Fast->new({



servers => ["192.168.0.1:11211","192.168.0.2:11211"],



ketama_points => 150



});

另外，Cache::Memcached::libmemcached 是一个使用了Brain Aker开发的C函数库libmemcached的Perl模块。 libmemcached本身支持几种分布式算法，也支持Consistent Hashing， 其Perl绑定也支持Consistent Hashing。

• Tangent Software: libmemcached

总结

本次介绍了memcached的分布式算法，主要有memcached的分布式是由客户端函数库实现， 以及高效率地分散数据的Consistent Hashing算法。下次将介绍mixi在memcached应用方面的一些经验， 和相关的兼容应用程序。

5. memcached的应用和兼容程序

发表日：2008/7/30
作者：长野雅广(Masahiro Nagano)
原文链接：http://gihyo.jp/dev/feature/01/memcached/0005

我是Mixi的长野。memcached的连载终于要结束了。 到上次为止， 我们介绍了与memcached直接相关的话题，本次介绍一些mixi的案例和 实际应用上的话题，并介绍一些与memcached兼容的程序。

mixi案例研究

mixi在提供服务的初期阶段就使用了memcached。 随着网站访问量的急剧增加，单纯为数据库添加slave已无法满足需要，因此引入了memcached。 此外，我们也从增加可扩展性的方面进行了验证，证明了memcached的速度和稳定性都能满足需要。 现在，memcached已成为mixi服务中非常重要的组成部分。

图1 现在的系统组件

服务器配置和数量

mixi使用了许许多多服务器，如数据库服务器、应用服务器、图片服务器、 反向代理服务器等。单单memcached就有将近200台服务器在运行。 memcached服务器的典型配置如下：

• CPU：Intel Pentium 4 2.8GHz
• 内存：4GB
• 硬盘：146GB SCSI
• 操作系统：Linux（x86_64）

这些服务器以前曾用于数据库服务器等。随着CPU性能提升、内存价格下降， 我们积极地将数据库服务器、应用服务器等换成了性能更强大、内存更多的服务器。 这样，可以抑制mixi整体使用的服务器数量的急剧增加，降低管理成本。 由于memcached服务器几乎不占用CPU，就将换下来的服务器用作memcached服务器了。

memcached进程

每台memcached服务器仅启动一个memcached进程。分配给memcached的内存为3GB， 启动参数如下：

/usr/bin/memcached -p 11211 -u nobody -m 3000 -c 30720

由于使用了x86_64的操作系统，因此能分配2GB以上的内存。32位操作系统中， 每个进程最多只能使用2GB内存。也曾经考虑过启动多个分配2GB以下内存的进程， 但这样一台服务器上的TCP连接数就会成倍增加，管理上也变得复杂， 所以mixi就统一使用了64位操作系统。

另外，虽然服务器的内存为4GB，却仅分配了3GB，是因为内存分配量超过这个值， 就有可能导致内存交换(swap)。连载的第2次中 前坂讲解过了memcached的内存存储“slab allocator”，当时说过，memcached启动时 指定的内存分配量是memcached用于保存数据的量，没有包括“slab allocator”本身占用的内存、 以及为了保存数据而设置的管理空间。因此，memcached进程的实际内存分配量要比 指定的容量要大，这一点应当注意。

mixi保存在memcached中的数据大部分都比较小。这样，进程的大小要比 指定的容量大很多。因此，我们反复改变内存分配量进行验证， 确认了3GB的大小不会引发swap，这就是现在应用的数值。

memcached使用方法和客户端

现在，mixi的服务将200台左右的memcached服务器作为一个pool使用。 每台服务器的容量为3GB，那么全体就有了将近600GB的巨大的内存数据库。 客户端程序库使用了本连载中多次提到车的Cache::Memcached::Fast， 与服务器进行交互。当然，缓存的分布式算法使用的是 第4次介绍过的 Consistent Hashing算法。

• Cache::Memcached::Fast - search.cpan.org

应用层上memcached的使用方法由开发应用程序的工程师自行决定并实现。 但是，为了防止车轮再造、防止Cache::Memcached::Fast上的教训再次发生， 我们提供了Cache::Memcached::Fast的wrap模块并使用。

通过Cache::Memcached::Fast维持连接

Cache::Memcached的情况下，与memcached的连接（文件句柄）保存在Cache::Memcached包内的类变量中。 在mod_perl和FastCGI等环境下，包内的变量不会像CGI那样随时重新启动， 而是在进程中一直保持。其结果就是不会断开与memcached的连接， 减少了TCP连接建立时的开销，同时也能防止短时间内反复进行TCP连接、断开 而导致的TCP端口资源枯竭。

但是，Cache::Memcached::Fast没有这个功能，所以需要在模块之外 将Cache::Memcached::Fast对象保持在类变量中，以保证持久连接。

package Gihyo::Memcached;







use strict;



use warnings;



use Cache::Memcached::Fast;







my @server_list = qw/192.168.1.1:11211 192.168.1.1:11211/;



my $fast;  ## 用于保持对象







sub new {



my $self  = bless {}, shift;



if ( !$fast ) {



$fast = Cache::Memcached::Fast->new({ servers => "@server_list });



}



$self->{_fast} = $fast;



return $self;



}







sub get {



my $self = shift;



$self->{_fast}->get(@_);



}

上面的例子中，Cache::Memcached::Fast对象保存到类变量$fast中。

公共数据的处理和rehash

诸如mixi的主页上的新闻这样的所有用户共享的缓存数据、设置信息等数据， 会占用许多页，访问次数也非常多。在这种条件下，访问很容易集中到某台memcached服务器上。 访问集中本身并不是问题，但是一旦访问集中的那台服务器发生故障导致memcached无法连接， 就会产生巨大的问题。

连载的第4次 中提到，Cache::Memcached拥有rehash功能，即在无法连接保存数据的服务器的情况下， 会再次计算hash值，连接其他的服务器。

但是，Cache::Memcached::Fast没有这个功能。不过，它能够在连接服务器失败时， 短时间内不再连接该服务器的功能。

my $fast = Cache::Memcached::Fast->new({



max_failures     => 3,



failure_timeout  => 1



});

在failure_timeout秒内发生max_failures以上次连接失败，就不再连接该memcached服务器。 我们的设置是1秒钟3次以上。

此外，mixi还为所有用户共享的缓存数据的键名设置命名规则， 符合命名规则的数据会自动保存到多台memcached服务器中， 取得时从中仅选取一台服务器。创建该函数库后，就可以使memcached服务器故障 不再产生其他影响。

memcached应用经验

到此为止介绍了memcached内部构造和函数库，接下来介绍一些其他的应用经验。

通过daemontools启动

通常情况下memcached运行得相当稳定，但mixi现在使用的最新版1.2.5 曾经发生过几次memcached进程死掉的情况。架构上保证了即使有几台memcached故障 也不会影响服务，不过对于memcached进程死掉的服务器，只要重新启动memcached， 就可以正常运行，所以采用了监视memcached进程并自动启动的方法。 于是使用了daemontools。

daemontools是qmail的作者DJB开发的UNIX服务管理工具集， 其中名为supervise的程序可用于服务启动、停止的服务重启等。

• daemontools

这里不介绍daemontools的安装了。mixi使用了以下的run脚本来启动memcached。

#!/bin/sh







if [ -f /etc/sysconfig/memcached ];then



. /etc/sysconfig/memcached



fi







exec 2>&1



exec /usr/bin/memcached -p $PORT -u $USER  -m $CACHESIZE -c $MAXCONN $OPTIONS

监视

mixi使用了名为“nagios”的开源监视软件来监视memcached。

• Nagios: Home

在nagios中可以简单地开发插件，可以详细地监视memcached的get、add等动作。 不过mixi仅通过stats命令来确认memcached的运行状态。

define command {



command_name                   check_memcached



command_line                   $USER1$/check_tcp -H $HOSTADDRESS$ -p 11211 -t 5 -E -s 'stats"r"nquit"r"n' -e 'uptime' -M crit



}

此外，mixi将stats目录的结果通过rrdtool转化成图形，进行性能监视， 并将每天的内存使用量做成报表，通过邮件与开发者共享。

memcached的性能

连载中已介绍过，memcached的性能十分优秀。我们来看看mixi的实际案例。 这里介绍的图表是服务所使用的访问最为集中的memcached服务器。

图2 请求数

图3 流量

图4 TCP连接数

从上至下依次为请求数、流量和TCP连接数。请求数最大为15000qps， 流量达到400Mbps，这时的连接数已超过了10000个。 该服务器没有特别的硬件，就是开头介绍的普通的memcached服务器。 此时的CPU利用率为：

图5 CPU利用率

可见，仍然有idle的部分。因此，memcached的性能非常高， 可以作为Web应用程序开发者放心地保存临时数据或缓存数据的地方。

兼容应用程序

memcached的实现和协议都十分简单，因此有很多与memcached兼容的实现。 一些功能强大的扩展可以将memcached的内存数据写到磁盘上，实现数据的持久性和冗余。 连载第3次 介绍过，以后的memcached的存储层将变成可扩展的（pluggable），逐渐支持这些功能。

这里介绍几个与memcached兼容的应用程序。

repcached

为memcached提供复制(replication)功能的patch。

Flared

存储到QDBM。同时实现了异步复制和fail over等功能。

memcachedb

存储到BerkleyDB。还实现了message queue。

Tokyo Tyrant

将数据存储到Tokyo Cabinet。不仅与memcached协议兼容，还能通过HTTP进行访问。

Tokyo Tyrant案例

mixi使用了上述兼容应用程序中的Tokyo Tyrant。Tokyo Tyrant是平林开发的 Tokyo Cabinet DBM的网络接口。它有自己的协议，但也拥有memcached兼容协议， 也可以通过HTTP进行数据交换。Tokyo Cabinet虽然是一种将数据写到磁盘的实现，但速度相当快。

mixi并没有将Tokyo Tyrant作为缓存服务器，而是将它作为保存键值对组合的DBMS来使用。 主要作为存储用户上次访问时间的数据库来使用。它与几乎所有的mixi服务都有关， 每次用户访问页面时都要更新数据，因此负荷相当高。MySQL的处理十分笨重， 单独使用memcached保存数据又有可能会丢失数据，所以引入了Tokyo Tyrant。 但无需重新开发客户端，只需原封不动地使用Cache::Memcached::Fast即可， 这也是优点之一。关于Tokyo Tyrant的详细信息，请参考本公司的开发blog。

• mixi Engineers' Blog - Tokyo Tyrantによる耐高負荷DBの構築
• mixi Engineers' Blog - Tokyo (Cabinet|Tyrant)の新機能

总结

到本次为止，“memcached全面剖析”系列就结束了。我们介绍了memcached的基础、内部结构、 分散算法和应用等内容。读完后如果您能对memcached产生兴趣，就是我们的荣幸。 关于mixi的系统、应用方面的信息，请参考本公司的开发blog。 感谢您的阅读。

In Internet terminology, a private network is typically a network that uses private IP address space, following the standards set by RFC 1918 and RFC 4193. These addresses are common in home and office local area networks (LANs), as using globally routable addresses is seen as impractical or unnecessary. Private IP addresses were originally created due to the shortage of publicly registered IP addresses created by the IPv4 standard, but are also a feature of the next generation Internet Protocol, IPv6.

These addresses are private because they are not globally assigned, meaning they aren't allocated to a specific organization--instead, any organization needing private address space can use these addresses without needing approval from a regional Internet registry (RIR). Consequently, they are not routable on the public Internet, meaning that if such a private network wishes to connect to the Internet, it must use either a Network Address Translation (NAT) gateway, or a proxy server.

The most common use of these addresses is in home networks, since most Internet Service Providers (ISPs) only allocate a single IP address to each customer, but many homes have more than one networking device (for example, several computers, or a printer). In this situation, a NAT gateway is almost always used to provide Internet connectivity. They are also commonly used in corporate networks, which for security reasons, are not connected directly to the internet, meaning globally routable addresses are unnecessary. Often a proxy, SOCKS gateway, or similar is used to provide restricted internet access to internal users. In both cases, private addresses are seen as adding security to the internal network, since it's impossible for an Internet host to connect directly to an internal system.

Because many internal networks use the same private IP addresses, a common problem when trying to merge two such networks (e.g. during a company merger or takeover) is that both organizations have allocated the same IPs in their networks. In this case, either one network must renumber, often a difficult and time-consuming task, or a NAT router must be placed between the networks to translate one network's addresses before they can reach the other side.

It is not uncommon for private address space to "leak" onto the Internet in various ways. Poorly configured private networks often attempt reverse DNS lookups for these addresses, putting extra load on the Internet's root nameservers. The AS112 project mitigates this load by providing special "blackhole" anycast nameservers for private addresses which only return "not found" answers for these queries. Organizational edge routers are usually configured to drop ingress IP traffic for these networks, which can occur either by accident, or from malicious traffic using a spoofed source address. Less commonly, ISP edge routers will drop such ingress traffic from customers, which reduces the impact to the Internet of such misconfigured or malicious hosts on the customer's network.

A common misconception is that these addresses are not routable. While not routable on the public Internet, they are routable within an organization or site.

The Internet Engineering Task Force (IETF) has directed IANA to reserve the following IPv4 address ranges for private networks, as published in RFC 1918:

Note that classful addressing is obsolete and no longer used on the Internet. For example, while 10.0.0.0/8 would be a single class A network, it is not uncommon for organisations to divide it into smaller /16 or /24 networks.

[edit] Link-local addresses

A second set of private networks is the link-local address range codified in RFC 3330 and RFC 3927. The intention behind these RFCs is to provide an IP address (and by implication, network connectivity) without a DHCP server being available and without having to configure a network address manually. The network 169.254/16 has been reserved for this purpose. Within this address range, the networks 169.254.0.0/24 and 169.254.255.0/24 have been set aside for future use.

If a host on an IEEE 802 (ethernet) network cannot obtain a network address via DHCP, an address from 169.254.0.0 to 169.254.255.255 is assigned pseudorandomly. The standard prescribes that address collisions must be handled gracefully.

Link-local addresses have even more restrictive rules than the private network addresses defined in RFC 1918: packets to or from link-local addresses must not be allowed to pass through a router at all (RFC 3927, section 7).

[edit] Private networks and IPv6

The concept of private networks and special addresses for such networks has been carried over to the next generation of the Internet Protocol, IPv6.

The address block fc00::/7 has been reserved by IANA as described in RFC 4193. These addresses are called Unique Local Addresses (ULA). They are defined as being unicast in character and contain a 40-bit random number in the routing prefix to prevent collisions when two private networks are interconnected. Despite being inherently local in usage, the IPv6 address scope of unique local addresses is global (cf. IPv6, section "Address Scopes").

A former standard proposed the use of so-called "site-local" addresses in the fec0::/10 range, but due to major concerns about scalability and the poor definition of what constitutes a site, its use has been deprecated since September 2004 by RFC 3879.

[edit] Private use of other reserved addresses

Several other address ranges, in addition to the official private ranges, are reserved for other or future uses, including 1.0.0.0/8 and 2.0.0.0/8^[1]. Though discouraged, some enterprises have begun to use this address space internally for interconnecting private networks to eliminate the chance of address conflicts when using standards-based private ranges.^{[citation needed]}

IANA has stated that it will, eventually, allocate these ranges to the Regional Internet Registries and thus significant addressing problem might be encountered in the future due to non-standard use of reserved blocks.

[edit] RFC References

• RFC 1918 – "Address Allocation for Private Internets"
• RFC 2036 – ""Observations on the use of Components of the Class A Address Space within the Internet."
• RFC 2050 – ""Internet Registry IP Allocation Guidelines""
• RFC 2101 – ""IPv4 Address Behaviour Today.""
• RFC 2663 – ""IP Network Address Translator (NAT) Terminology and Considerations."
• RFC 3022 – ""Traditional IP Network Address Translator (Traditional NAT)""
• RFC 3330 – ""Special-Use IPv4 Addresses. IANA. September 2002::
• RFC 3879 – "Deprecating Site Local Addresses"
• RFC 3927 – "Dynamic Configuration of IPv4 Link-Local Addresses"
• RFC 4193 – "Unique Local IPv6 Unicast Addresses"

[edit] References

1. ^ Internet Protocol v4 Address Space

[edit] External links

• Generator for RFC 4193 Addresses (source code available from same page)

Name | Synopsis | Description | Options | Operands | Examples | Exit Status | See Also

Name

start-node-agent– starts a node agent

Synopsis

start-node-agent [--user user]

        

        [--passwordfile passwordfile] [--secure={true|false}] 

        

        [ --terse={true|false} ] [ --echo={true|false} ]

        

        [ --interactive={true|false} ] [ --verbose={true|false} ] 

        

        [ --agentdir  nodeagent_path] [--startinstances={true|false}] 

        

        [ --syncinstances={true|false} ] [nodeagent_name]

Description

---

Note –

This command is available only in domains that are configured to support clusters, such as domains that are created with the cluster profile.

---

Use the start-node-agent command start a node agent. The command will return control to the user before instances are actually started. The list-instances command can be executed to see if they have actually started. This command may take a while to execute since the node agent may need to create and start a number of server instances.

This command is supported in local mode only.

Options

-u --user

The authorized domain administration server administrative username.

--passwordfile

The --passwordfile option specifies the name of a file containing the password entries in a specific format. The entry for the password must have the AS_ADMIN_ prefix followed by the password name in uppercase letters.

For example, to specify the domain administration server password, use an entry with the following format: AS_ADMIN_PASSWORD=password, where password is the actual administrator password. Other passwords that can be specified include AS_ADMIN_MAPPEDPASSWORD, AS_ADMIN_USERPASSWORD, and AS_ADMIN_ALIASPASSWORD.

All remote commands must specify the administration password to authenticate to the domain administration server, either through --passwordfile or asadmin login, or interactively on the command prompt. The asadmin login command can be used only to specify the administration password. For other passwords, that must be specified for remote commands, use the --passwordfile or enter them at the command prompt.

If you have authenticated to a domain using the asadmin login command, then you need not specify the administration password through the --passwordfile option on subsequent operations to this particular domain. However, this is applicable only to AS_ADMIN_PASSWORD option. You will still need to provide the other passwords, for example, AS_ADMIN_USERPASSWORD, as and when required by individual commands, such as update-file-user.

For security reasons, passwords specified as an environment variable will not be read by asadmin.

The default value for AS_ADMIN_MASTERPASSWORD is changeit.

-s --secure

If set to true, uses SSL/TLS to communicate with the domain administration server. Default is true.

-t --terse

Indicates that any output data must be very concise, typically avoiding human-friendly sentences and favoring well-formatted data for consumption by a script. Default is false.

-e --echo

Setting to true will echo the command line statement on the standard output. Default is false.

-I --interactive

If set to true (default), only the required password options are prompted.

-h --help

Displays the help text for the command.

--verbose

By default this flag is set to false. If set to true, a console window is opened for the node agent and for every server instance a node agent manages. On Windows, press Ctrl-Break in the console to print a thread dump. On UNIX, press CTRL-Backslash in the console to print a thread dump. The node agent thread dump goes to its console. The server instance thread dump goes to the instance log file.

--agentdir

Like a Domain Administration Server (DAS), each node agent resides in a top level directory named agentdir/nodeagent_name. If specified, the path must be accessible in the filesystem. If not specified, defaults to the install_dir/nodeagents directory.

--startinstances

If set to true, all server instances that are not currently running are started. If set to false, instances are not started. If the option is omitted, it defaults to the value of the node agent's start-servers-in-startup attribute, located in the domain.xml file.

--syncinstances

If set to true, forcibly synchronizes the cache repositories of all server instances with the central repository of the DAS. The synchronization occurs when the node agent is started. Default is false.

Operands

nodeagent_name

The name of the node agent to be started.

Examples

---

Example 1 Using the start-node-agent command




asadmin> start-node-agent --user admin --passwordfile passwordfile nodeagent1 Nodeagent1 started.

The node agent nodeagent1 is started in the default install_dir/nodeagents directory.

---

Exit Status

0

command executed successfully

1

error in executing the command

See Also

stop-node-agent(1), delete-node-agent(1), list-node-agents(1), create-node-agent(1)

Terminology:

DAS: Domain Admin Server (One per domain) -- The process that controls the management of the entire domain.

NA: Node Agent -- Generally, one per box or Solaris container -- The process that controls the life cycle of server instances.

SI: Server Instance --  The real Java EE instances that run user applications in an enterprise.

Answer:

1. Background: The domain.xml controls the configuration. At every node-agent, there are also a few configuration files that are consulted by every NA. See NA section at docs.sun.com for details. Following are the points in time when the communication (for administration/management purpose) happens:

• DAS communicates with each NA: Only when DAS needs to know NA's running status.
• DAS communicates with each SI: When DAS needs to know SI's running status and when it needs to cascade the SI MBeans into the DAS's MBenServer.
  
• NA communicates with DAS: During initial rendezvous (which may happen during creation of NA), synchronization of the NA itself and synchronization of each SI that NA is responsible for.
• SI communicates with the DAS: Never, explicitly.

Thus, the communication is mainly driven by DAS. When the domain is created, the administration is configured to use an authentication realm named admin-realm. This realm points to what's called a FileRealm which is nothing but the implementation of a security realm implementation that uses admin-keyfile. If you see the domain's configuration, you'll find this file in config folder of that domain.

The communication happens over two channels. One is the HTTP channel and the other is RMI channel. For this purpose, there is a SynchronizationServlet and a System JMX Connector (standard in JDK 5) that is provided. Every DAS and SI, including the NA start a JMX RMI ConnectorServer that can be optionally configured to use transport layer security.

Every NA communicates with DAS multiple times, but the key points are of initial hand-shake and synchronization. The initial hand-shake is when NA makes DAS aware of its own existence and DAS correspondingly responds if it has the correct credentials. When the DAS is configured to have secure access (this is the default in enterprise profile domain), both the HTTP and JMX/RMI channels use Transport Layer Security with SSL/v3.  Note that during the initial hand-shake, the DAS knows about NA's existence alone. DAS does not release the contents of the domain's repository during this phase. This happens over HTTP channel since creation of node-agent takes the DAS's admin-port (default: 4848) as an option.

After an NA is created, the most natural step is to start that NA. This is done by executing the asadmin start-node-agent command. Since this is the first-time startup of the NA, NA syncs up with the DAS. Note that startup of NA requires the correct credentials (admin user name and admin password) to be supplied. The DAS compares them against its own admin-keyfile and the communication succeeds only when this succeeds. The NA startup also requires the master password to be provided on the command line because in order to start, the NA has to be able to unlock the security store (e.g. keystore.jks) that it synced from the DAS. Note that master password is never put on the wire! It has to be provided at the time of both DAS startup and every NA startup. For advanced use cases, there is an unattended boot scenario that is handled by using the option --savemasterpassword which should be used with care.

The reason NA needs the master password is also to pass it on to the SI's it starts (as part of start-instance or start-cluster) so that these instances are able to unlock the security store to get the primary keys and certificates. 

The NA always communicates with the DAS over JMX/RMI channel. Thus NA opens an RMI connection to the DAS where DAS is listening for RMI/JMX Connections. This is where the RMI Registry in DAS (default port 8686) comes into picture.

When the domain is created, it uses the self-signed certificate aliased s1as which is used for internal communication. This certificate is created anew every time a domain is created. The master password of a domain is what locks the server's keystore. In enterprise profile domain, NSS is used to manage the secure store, whereas in cluster profile domain, JKS manages the secure store. The semantics of the master password are unchanged in both the cases.

The Server Instances are synced with the DAS as part of either:

1. start-instance, or
2. start-cluster, or
3. start-node-agent --syncinstances procedure.

For this synchronization, they use the HTTP layer and communicate with the SynchronizationServlet that's listening for sync requests. This servlet is (of course) running in the DAS.

The server instances get the admin credentials from the node-agent process in a secure manner (using stdin). This also evident when you try to use the startserv script that's located in instance's bin folder.

The process of DAS communicating with the NA and SI's is identical in that it communicates with them over RMI/JMX in the other direction.

2. Transport Layer Security:

This is achieved when we enable the security-enabled flag on the admin-listener and jmx-connector named system on the DAS and server instances. Note that  admin-listener (HTTP/S) is started only in the DAS. There is no admin-listener in server instances.

It's of course possible to use another CA-signed certificate for this purpose. It needs additional configuration after importing those certs in the store.

3. Authentication and Credentials:

Please see: http://wiki.glassfish.java.net/attach/GlassFishAdministrationPages/admincreds.html

1. Create a user glassfish (you can call it anything you want) under which Glassfish will run.

   #useradd glassfish

2. Install glassfish in /home/glassfish.
3. Create the startup script /etc/init.d/glassifsh for glassfish.

   #!/bin/bash # # glassfish: Startup script for Glassfish Application Server. # # chkconfig: 3 80 05 # description: Startup script for domain1 of Glassfish Application Server. GLASSFISH_HOME=/home/glassfish/glassfish; export GLASSFISH_HOME GLASSFISH_OWNER=glassfish; export GLASSFISH_OWNER start() { echo -n "Starting Glassfish: " echo "Starting Glassfish at `date`" >> $GLASSFISH_HOME/domains/domain1/logs/startup.log su $GLASSFISH_OWNER -c "$GLASSFISH_HOME/bin/asadmin start-domain domain1" >> $GLASSFISH_HOME/domains/domain1/logs/startup.log sleep 2 echo "done" } stop() { echo -n "Stopping Glassfish: " echo "Stopping Glassfish at `date`" >> $GLASSFISH_HOME/domains/domain1/logs/startup.log su $GLASSFISH_OWNER -c "$GLASSFISH_HOME/bin/asadmin stop-domain domain1" >> $GLASSFISH_HOME/domains/domain1/logs/startup.log echo "done" } # See how we were called. case "$1" in start) start ;; stop) stop ;; restart) stop start ;; *) echo $"Usage: glassfish {start|stop|restart}" exit esac

4. Install the service

   #chmod +x /etc/init.d/glassfish
   
       #chkconfig -add glassfish
   
       #chkconfig --level 3 glassfish on

5. Start glassfish.

   #/etc/init.d/glassfish start

I’ve been working with Glassfish recently, from the system administration point of view.  First task, after getting a good build with Maven (doing it with basic rpm methods netted me a massive dependency list, including things like Firefox!), was to write an init script so that Glassfish can be integrated into the CentOS boot sequence.

Because we might have multiple domains set up inside of Glassfish, I opted for a setup similar to the Tomcat5 init script - check the basename of $0, and use that to determine which domain to boot up.  The fiddling in start() gets around the fact that Glassfish doesn’t seem to write a PID file out where we need one.

So, just in case anyone else needs to do this:

#!/bin/bash

# chkconfig: 2345 85 15

# description: GlassFish is a Java Application Server.

# processname: glassfish

# pidfile: /var/run/glassfish.pid



# source function library

. /etc/init.d/functions



RETVAL=0



GLASSFISH_BIN="/var/lib/glassfish/bin"



# Basename works with symbolic links.

NAME="$(basename $0)"

unset ISBOOT



# Trim off the Sxx/Kxx prefix

if [ "${NAME:0:1}" = "S" -o "${NAME:0:1}" = "K" ]; then

NAME="${NAME:3}"

ISBOOT="1"

fi



# Trim off the glassfish- prefix

NAME=${NAME:10}



# /etc/init.d/glassfish should never be called directly.

if [ -z $NAME ]; then

echo -n $"Cannot start Glassfish without specifying a domain."

failure

echo

exit 1

fi



start() {



echo -n $"Starting Glassfish V2 domain $NAME: "

daemon --user glassfish --pidfile /var/run/glassfish-$NAME.pid "$GLASSFISH_BIN/asadmin start-domain $NAME >/dev/null 2>&1"

RETVAL=$?



if [ $RETVAL -eq 0 ]; then

PID=`ps U glassfish | grep $NAME | awk '{ print $1}'`

echo $PID > /var/run/glassfish-$NAME.pid

touch /var/lock/subsys/glassfish-$NAME

fi



echo

}





stop() {



echo -n $"Shutting down Glassfish V2 domain $NAME: "



$GLASSFISH_BIN/asadmin stop-domain $NAME >/dev/null 2>&1



RETVAL=$?



[ $RETVAL -eq 0 ] && rm -f /var/lock/subsys/glassfish-$NAME && rm -f /var/run/glassfish-$NAME  && success || failure



echo



}



case "$1" in



start)



start



;;



stop)



stop

;;



restart|reload)



stop



start



;;



condrestart)



if [ -f /var/lock/subsys/glassfish-$NAME ]; then



stop



start

fi

;;



status)

status glassfish-$NAME



RETVAL=$?

;;



*)



echo $"Usage: $0 {start|stop|restart|condrestart|status}"



exit 1



esac



exit $RETVAL

The alternative is to define a /etc/sysconfig/glassfish file, and insert a variable with the list of domains to boot, in sequence.  This is a little harder to manage automatically in Puppet, but might be a better solution if precise boot sequences are required (this method will boot in sequence based on the S numbers in the base script, and then the alphabetical ordering of the names).

Disable directory browsing using .htaccess:-

• Open your .htacces file
• Look for Options Indexes
• If Options Indexes exists modify it to Options -Indexes or else add Options -Indexes as a new line
• The directory browsing feature should be disable by now

Disable directory browsing using httpd.conf:-

• Open your httpd.conf, normally it’s located at /usr/local/apache/conf or /etc/httpd.conf
• Go to your own Virtual Host settings and look for “Options Indexes”
• Change the Indexes to -Indexes if Option Indexes exists or else add the Options -Indexes line
• Restart your apache web server.
• The directory browsing feature should be disable by now

Disable directory browsing in CPanel Share Hosting enviroment:-

• Login to your CPanel
• Click on Index Manager
• Directory will be list down. Click on the directory name which you want to disable the directory browsing
• Select No Index and click Save
• The directory browsing feature should be disable by now

Once you disable directory browsing, visitor will not able to browse your directory by accessing the directory directly (if there is no index.html file). This will protect your files from exposing to the public.

http://ubuntuforums.org/archive/index.php/t-234876.html

是不是感觉，交互性很差，

有时，想把结果直接在终端上输出，又怕不小心关闭了终端导致进程退出？ （有些sshd服务还会设置连接超时，自动退出终端）

现在用 screen 这个指令可以很好的解决跑后台服务的尴尬。

命令其实超简单的：

直接在终端上输入 screen , 这个时候，服务器端会启一个新的终端，但这个终端，与之前的普通终端不一样，它不隶属于 sshd 进程组，这样，当本地终端关闭后，服务器终端不会被 kill。

当然，优点还不止这么些，在服务器终端里执行任务时，你甚至可以随时地切换到本地终端做些其他事情，然后，要回去时，再恢复到刚才已经打开的服务器终端里，如果刚才的任务没有结束，还可以继续执行任务。

操作步骤：

首先，进入 screen -S sessionname终端。(sessionname是为了分辨你的session)

然后按 ctrl + a ，再按 d 键暂时退出终端。

当要返回时， 先查看刚才的终端进程ID， screen -list

或直接

 screen -r xx (刚才的sessionname)就可以了

当然，当你开了很多个session后，打算关闭几个session，可以进入到session后，exit 一下就可以了.

总的来说， screen是可以完全替代 nohup 的，并且本身提供了较复杂的功能，但是我认为，刚才那些简单的功能足以应付日常运作。

如果对该指令感兴趣的朋友，推荐一篇文章：

http://www.ibm.com/developerworks/cn/linux/l-cn-screen/

补充：

A: secureCRT链接linux服务器时，网络断线了，但是服务器上的tty还没退出，我想重新连接到原来那个tty，可以做到么？

B: 可以啊，你可以安装一个Screen，就可以享受他给你带来的方便了。

A：如何创建一个虚拟shell环境？

B：screen -S MyScr （其中“MyScr”是你为这个虚拟shell环境起的名字，可以自定义）
输入回车之后，你就可以在这个虚拟的shell环境中工作了，你工作的内容都会被一直保留下来。试试吧，在里面敲几个命令，运行几个程序，和平常没有两样吧。

A: 如何退出工作环境呢？

B：如果想要退出要怎么办呢？只要按下Ctrl+A，然后按d，就可以退出刚刚建立的虚拟shell环境了（名字是MyScr）
若干时间后，你又想继续刚才的工作了，只要再敲：
screen -r MyScr
就可以看到刚刚的界面了。怎么样，还是很简单适用的吧，呵呵。

A: 可以不给他起名么？

B：当然，你不给这个虚拟shell环境命名也是没问题的，如果只有一个虚拟环境的话，也可以这样用
screen（回车）
工作……退出……
screen -r
继续工作
系统还会默认用PID号码表识screen虚拟的shell环境。
例如，我直接用screen命令建立了一个虚拟环境，退出之后，我想查看虚拟环境的情况：

A：如何察看当前有哪些Screen工作环境呢？

B：screen -list
输出应该是类似下面的：
There is a screen on:
25202.pts-1.firewallX (Detached)
1 Socket in /tmp/screens/S-root.
其中：
“25202”是这个虚拟环境的PID。不信的话，可以ps查看一下，呵呵~
“pts-1”是说你的ssh客户端登录的系统端口号是pts-1
“firewallX”是我这台主机的名字
如果你建立了很多虚拟环境，又没有为他们命名的话，就只能用PID来识别他们了。（记住这个PID号码太烦了吧，还是名字好！）
例如，我现在有两个screen建立的虚拟环境，我输入：
screen -list
输出为：
There are screens on:
25202.pts-1.firewallX (Detached)
25403.pts-1.firewallX (Detached)
2 Sockets in /tmp/screens/S-root.
那么，我如果想进入第二个虚拟环境的话，我可以用什么命令呢？答案如下：
screen -r 25403

A：如何创建新的screen呢？

B：如果我登录进去之后，用ctrl-a c：再创建一个新的虚拟Shell环境，那么这个环境就是在PID为25403的虚拟环境里面的子虚拟环境。

A：如何彻底退出一个screen工作环境呢？

B：Ctrl-D

A：如何在进入工作环境的时候就自动的运行screen呢？
B：可以在~/.bash_profiler里最下面一行添加一句screen

注意事项：关闭secureCRT之前，请先使用 Ctrl-D 退出screen

　　其他的行也更这个类似；最有用的信息我用红色标记，其大意是不能执行上面的2进制或可执行文件。在这个条目中，只有2个执行文件—printf及mail。我把它按原样单独拿出来执行，操作过程如下：

　　（1）/usr/bin/printf  “"%b" "***** Nagios 2.9 *****\n”  输出 ***** Nagios 2.9 *****，这是正常的结果。

　　（2）/bin/mail -s "Host DOWN alert for mail-server!" sery@163.com 输出su: /bin/mail: No such file or directory，没找到路径或目录。前面还手动发了邮件的，明明有mail这个客户端程序呀！可能这个路径不对，是linux的mail路径。查一下freebsd的mail路径，执行find / -name 得到mail在freebsd的路径为/usr/bin/mail 。

　　到这里，我们知道了为啥不能发邮件的根本原因，接下来，我把nagios的配置文件commands.cfg的host-notify-by-email、service-notify-by-email的”/bin/mail”替换为“/usr/bin/mail”。其完整形式为：

　　# 'host-notify-by-email' command definition
define command{
command_name    host-notify-by-email
command_line    /usr/bin/printf "%b" "***** Nagios 2.9 *****\n\nNotification Type: $NOTIFICATIONTYPE$\nHost: $HOSTNAME$\nState: $HOSTSTATE$\nAddress: $HOSTADDRESS$\nInfo: $HOSTOUTPUT$\n\nDate/Time: $LONGDATETIME$\n" | /usr/bin/mail -s "Host $HOSTSTATE$ alert for $HOSTNAME$!" $CONTACTEMAIL$
}
# 'notify-by-email' command definition
define command{
command_name    service-notify-by-email
command_line    /usr/bin/printf "%b" "***** Nagios 2.9 *****\n\nNotification Type: $NOTIFICATIONTYPE$\n\nService: $SERVICEDESC$\nHost: $HOSTALIAS$\nAddress: $HOSTADDRESS$\nState: $SERVICESTATE$\n\nDate/Time: $LONGDATETIME$\n\nAdditional Info:\n\n$SERVICEOUTPUT$" | /usr/bin/mail -s "** $NOTIFICATIONTYPE$ alert - $HOSTALIAS$/$SERVICEDESC$ is $SERVICESTATE$ **" $CONTACTEMAIL$
}

　　修改完配置文件commands.cfg后重启 Nagios，再查看nagios日志，不再有“Make sure the script or binary you are trying to execute actually exists...”报错，并且有发送报警邮件的记录了：

　　[root@nagios /usr/local/nagios/var]# tail -f nagios.log
[1217170467] SERVICE ALERT: mail-server;check_tcp 995;CRITICAL;SOFT;1;CRITICAL - Socket timeout after 10 seconds
[1217170534] Auto-save of retention data completed successfully.
[1217170577] HOST ALERT: mail-server;DOWN;SOFT;1;CRITICAL - Plugin timed out after 10 seconds
[1217170587] HOST ALERT: mail-server;DOWN;SOFT;2;CRITICAL - Plugin timed out after 10 seconds
[1217170597] HOST ALERT: mail-server;DOWN;SOFT;3;CRITICAL - Plugin timed out after 10 seconds
[1217170607] HOST ALERT: mail-server;DOWN;SOFT;4;CRITICAL - Plugin timed out after 10 seconds
[1217170607] HOST ALERT: mail-server;UP;SOFT;5;PING OK - Packet loss = 0%, RTA = 111.63 ms
[1217170607] SERVICE ALERT: mail-server;check_tcp 995;CRITICAL;SOFT;2;CRITICAL - Socket timeout after 10 seconds
[1217170687] SERVICE ALERT: mail-server;check_tcp 995;OK;SOFT;3;TCP OK - 3.137 second response time on port 995
[1217171057] SERVICE NOTIFICATION: sery;fav-0;check_tcp 443;CRITICAL;service-notify-by-email;CRITICAL - Socket timeout after 10 seconds

　　收邮件，迫不及待，哈哈，我的163邮箱收到久违的报警信息了。再回去瞧一眼邮件日志/var/log/malllog,也记录了这个发送情况。

　　经验总结：通过日志记录，对于我们排查故障确实有着不可估量的好处。在实际的工作中，我们应该随时检查系统日志以及应用程序相关的日志，从记录项中寻找蛛丝马迹，从而得出解决问题的方法。