Nging是一个网站服务程序，可以代替Nginx或Apache来搭建Web开发测试环境，并附带了实用的周边工具

# S2 Compression S2 is an extension of [Snappy](https://github.com/google/snappy). S2 is aimed for high throughput, which is why it features concurrent compression for bigger payloads. Decoding is compatible with Snappy compressed content, but content compressed with S2 cannot be decompressed by Snappy. This means that S2 can seamlessly replace Snappy without converting compressed content. S2 can produce Snappy compatible output, faster and better than Snappy. If you want full benefit of the changes you should use s2 without Snappy compatibility. S2 is designed to have high throughput on content that cannot be compressed. This is important, so you don't have to worry about spending CPU cycles on already compressed data. ## Benefits over Snappy * Better compression * Adjustable compression (3 levels) * Concurrent stream compression * Faster decompression, even for Snappy compatible content * Concurrent Snappy/S2 stream decompression * Skip forward in compressed stream * Random seeking with indexes * Compatible with reading Snappy compressed content * Smaller block size overhead on incompressible blocks * Block concatenation * Block Dictionary support * Uncompressed stream mode * Automatic stream size padding * Snappy compatible block compression ## Drawbacks over Snappy * Not optimized for 32 bit systems * Streams use slightly more memory due to larger blocks and concurrency (configurable) # Usage Installation: `go get -u github.com/klauspost/compress/s2` Full package documentation: [![godoc][1]][2] [1]: https://godoc.org/github.com/klauspost/compress?status.svg [2]: https://godoc.org/github.com/klauspost/compress/s2 ## Compression ```Go func EncodeStream(src io.Reader, dst io.Writer) error { enc := s2.NewWriter(dst) _, err := io.Copy(enc, src) if err != nil { enc.Close() return err } // Blocks until compression is done. return enc.Close() } ``` You should always call `enc.Close()`, otherwise you will leak resources and your encode will be incomplete. For the best throughput, you should attempt to reuse the `Writer` using the `Reset()` method. The Writer in S2 is always buffered, therefore `NewBufferedWriter` in Snappy can be replaced with `NewWriter` in S2. It is possible to flush any buffered data using the `Flush()` method. This will block until all data sent to the encoder has been written to the output. S2 also supports the `io.ReaderFrom` interface, which will consume all input from a reader. As a final method to compress data, if you have a single block of data you would like to have encoded as a stream, a slightly more efficient method is to use the `EncodeBuffer` method. This will take ownership of the buffer until the stream is closed. ```Go func EncodeStream(src []byte, dst io.Writer) error { enc := s2.NewWriter(dst) // The encoder owns the buffer until Flush or Close is called. err := enc.EncodeBuffer(buf) if err != nil { enc.Close() return err } // Blocks until compression is done. return enc.Close() } ``` Each call to `EncodeBuffer` will result in discrete blocks being created without buffering, so it should only be used a single time per stream. If you need to write several blocks, you should use the regular io.Writer interface. ## Decompression ```Go func DecodeStream(src io.Reader, dst io.Writer) error { dec := s2.NewReader(src) _, err := io.Copy(dst, dec) return err } ``` Similar to the Writer, a Reader can be reused using the `Reset` method. For the best possible throughput, there is a `EncodeBuffer(buf []byte)` function available. However, it requires that the provided buffer isn't used after it is handed over to S2 and until the stream is flushed or closed. For smaller data blocks, there is also a non-streaming interface: `Encode()`, `EncodeBetter()` and `Decode()`. Do however note that these functions (similar to Snappy) does not provide validation of data, so data corruption may be undetected. Stream encoding provides CRC checks of data. It is possible to efficiently skip forward in a compressed stream using the `Skip()` method. For big skips the decompressor is able to skip blocks without decompressing them. ## Single Blocks Similar to Snappy S2 offers single block compression. Blocks do not offer the same flexibility and safety as streams, but may be preferable for very small payloads, less than 100K. Using a simple `dst := s2.Encode(nil, src)` will compress `src` and return the compressed result. It is possible to provide a destination buffer. If the buffer has a capacity of `s2.MaxEncodedLen(len(src))` it will be used. If not a new will be allocated. Alternatively `EncodeBetter`/`EncodeBest` can also be used for better, but slightly slower compression. Similarly to decompress a block you can use `dst, err := s2.Decode(nil, src)`. Again an optional destination buffer can be supplied. The `s2.DecodedLen(src)` can be used to get the minimum capacity needed. If that is not satisfied a new buffer will be allocated. Block function always operate on a single goroutine since it should only be used for small payloads. # Commandline tools Some very simply commandline tools are provided; `s2c` for compression and `s2d` for decompression. Binaries can be downloaded on the [Releases Page](https://github.com/klauspost/compress/releases). Installing then requires Go to be installed. To install them, use: `go install github.com/klauspost/compress/s2/cmd/s2c@latest && go install github.com/klauspost/compress/s2/cmd/s2d@latest` To build binaries to the current folder use: `go build github.com/klauspost/compress/s2/cmd/s2c && go build github.com/klauspost/compress/s2/cmd/s2d` ## s2c ``` Usage: s2c [options] file1 file2 Compresses all files supplied as input separately. Output files are written as 'filename.ext.s2' or 'filename.ext.snappy'. By default output files will be overwritten. Use - as the only file name to read from stdin and write to stdout. Wildcards are accepted: testdir/*.txt will compress all files in testdir ending with .txt Directories can be wildcards as well. testdir/*/*.txt will match testdir/subdir/b.txt File names beginning with 'http://' and 'https://' will be downloaded and compressed. Only http response code 200 is accepted. Options: -bench int Run benchmark n times. No output will be written -blocksize string Max block size. Examples: 64K, 256K, 1M, 4M. Must be power of two and <= 4MB (default "4M") -c Write all output to stdout. Multiple input files will be concatenated -cpu int Compress using this amount of threads (default 32) -faster Compress faster, but with a minor compression loss -help Display help -index Add seek index (default true) -o string Write output to another file. Single input file only -pad string Pad size to a multiple of this value, Examples: 500, 64K, 256K, 1M, 4M, etc (default "1") -q Don't write any output to terminal, except errors -rm Delete source file(s) after successful compression -safe Do not overwrite output files -slower Compress more, but a lot slower -snappy Generate Snappy compatible output stream -verify Verify written files ``` ## s2d ``` Usage: s2d [options] file1 file2 Decompresses all files supplied as input. Input files must end with '.s2' or '.snappy'. Output file names have the extension removed. By default output files will be overwritten. Use - as the only file name to read from stdin and write to stdout. Wildcards are accepted: testdir/*.txt will compress all files in testdir ending with .txt Directories can be wildcards as well. testdir/*/*.txt will match testdir/subdir/b.txt File names beginning with 'http://' and 'https://' will be downloaded and decompressed. Extensions on downloaded files are ignored. Only http response code 200 is accepted. Options: -bench int Run benchmark n times