博客园_蒙趣空间

Sphinx 客户端API编写过程中遇到的问题

2010-09-16T07:20:00Z

Sphinx是什么阿蒙在这里就不解释了，直接进正题吧。

官方提供的API接口实在是太简陋了，完全是从PHP迁移到C#的，对于不熟悉Sphinx的开发人员来说，颇费一番功夫才能明白如何去调用各个方法，而且在网络连接上未使用连接池，这对于工作在Nginx或lighttpd这类单进程单线程的Web Server下的PHP来说，的确是比较好的，但对于工作在IIS下的.NET程序就不那么令人愉悦了。

在这个前提下，于是决定自己动手开发一个Sphinx的客户端类库。

Sphinx协议是很简单的，但是其中也隐含着一些陷阱，例如今天在测试接口时，发现的一些问题：

1、按时间(DateTime)或整型(Int32)过滤结果时，始终报错：“invalid or truncated request”，在网上搜索半天无果，只有自己动眼看服务端源码（伸手党不好做:-(）。

在源码中发现了，分析范围过滤的方式的相关代码：

                switch ( tFilter.m_eType )
                {
                    case SPH_FILTER_RANGE:
                        tFilter.m_uMinValue = ( iVer>=0x114 ) ? tReq.GetUint64() : tReq.GetDword ();
                        tFilter.m_uMaxValue = ( iVer>=0x114 ) ? tReq.GetUint64() : tReq.GetDword ();
                        break;

                    case SPH_FILTER_FLOATRANGE:
                        tFilter.m_fMinValue = tReq.GetFloat ();
                        tFilter.m_fMaxValue = tReq.GetFloat ();
                        break;

                    case SPH_FILTER_VALUES:
                        {
                            bool bRes = ( iVer>=0x114 )
                                ? tReq.GetQwords ( tFilter.m_dValues, g_iMaxFilterValues, "invalid attribute set length %d (should be in 0..%d range)" )
                                : tReq.GetDwords ( tFilter.m_dValues, g_iMaxFilterValues, "invalid attribute set length %d (should be in 0..%d range)" );
                            if ( !bRes )
                                return false;
                        }
                        break;

                    default:
                        tReq.SendErrorReply ( "unknown filter type (type-id=%d)", tFilter.m_eType );
                        return false;
                }

原来Sphinx的服务端在客户端代码版本高于0x114时，是以8字节长整型来读取的最大最小值，问题找到了，将所有进行范围过滤的值在发送到服务端之前都转换为Int64，再写入流中，OK，问题解决。

2、用Socket不要用TcpClient - -

在做压力测试时，Socket通信的性能明显好于TcpClient，而且TcpClient在压力测试过程中，经常报错，目前尚未去查找原因，不过用Socket的话，工作得非常好。

目前该类库还在测试中，可能还会遇到其他问题，慢慢补充。

本文链接

lvs + nginx +iis 架构遇到的问题（二）

2010-05-17T14:51:00Z

前几天遇到的问题，今天终于得到解决。

今天到公司之后，写了一个telnet的测试程序，分别在公司内网、服务器环境、在加拿大的同事机器上、湖南朋友的机器上、以及在其他几个公司就职的同事机器上运行了一下。

每次运行，telnet 1000次LVS的VIP的80端口，公司内网测试结果失败了20%，其他测试均全部通过，因此断定了问题出在内网环境中。

找来公司网管一起分析这个问题，怀疑是出在公司使用的一个叫“网康”的软件上，但排查后，也非出在这个东西上，因为它是基于域名过滤的- -，郁闷！

无意中，换了几个IP测试，发现除了LVS的这一个VIP之外其他的VIP都是可以成功通过测试，于是决定换一个VIP来转发80端口的请求，谁知新建一个VIP之后，故障VIP居然神奇的正常了 - -

尽管这个灵异现象解决得十分不完美，but... it's work!!!!

本文链接

lvs + nginx +iis 架构遇到的问题...

2010-05-14T13:33:00Z

昨天晚上公司的网站换了lvs + nginx + iis的架构，因为公司网站用的.NET开发，又因为不知道在Mono下能否跑，因此还是逃不开IIS。

最前端是lvs + keepalived接受用户访问，然后转发到三台nginx中，nginx做反向代理到后端的IIS，今天到公司后，不少同事反应，访问网站时快时慢，偶尔还出现访问失败的现象，即使静态页面也是这样，起初以为是内网的原因，公司网管检查了反应慢的同事电脑，排除各种原因后，现象依然存在，于是开始怀疑是昨晚的调整造成的，看了一下lvs的master，连接数很低，查看nginx服务器，80端口有不少fin_wait1状态，看了一下nginx的日志，应该是lvs做健康检查造成的，直到下班，原因未查到～

下班之后，回到家中，不甘心，又开始排查这个问题，但无论怎么访问网站，即使用webbench做压力测试，lvs连接统计超过白天的100倍也没能出现，访问失败的情况，而且静态页面在这种情况下还能正常访问，这让我百思不得其解......

难道还是内网问题吗？

本文链接

修改memecache客户端API，解决ttserver反序列化问题

2010-05-06T13:37:00Z

之前在一篇随笔中提到使用Memcache的API无法正确将保存在ttserver中的值正确反序列化，原因是，Memcache协议中的对象类型值未被保存到ttserver上，于是简单的修改了一下Memcache API（使用的beit-memcached）中的Serializer.cs文件，将序列化对象的原始类型保存在序列化串的第一个字节中，也就是将值的类型，连同值一起保存到ttserver上。

//Copyright (c) 2007-2008 Henrik Schr鰀er, Oliver Kofoed Pedersen

//Permission is hereby granted, free of charge, to any person
//obtaining a copy of this software and associated documentation
//files (the "Software"), to deal in the Software without
//restriction, including without limitation the rights to use,
//copy, modify, merge, publish, distribute, sublicense, and/or sell
//copies of the Software, and to permit persons to whom the
//Software is furnished to do so, subject to the following
//conditions:

//The above copyright notice and this permission notice shall be
//included in all copies or substantial portions of the Software.

//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
//EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
//OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
//NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
//HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
//WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
//FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
//OTHER DEALINGS IN THE SOFTWARE.

#region 文件信息
/*=================================================================
*  文件：Serializer.cs
*  创建者：<原作者>
*  创建日期：<未知>
*  最后修改：（楼下请注意保持队形）
*  ##############################################################
*  时间          修改人                      备注
*  2010-04-19       田真                 因为TT不支持Memcached的类型存储，这里修改了序列化方式，主要体现在对Serialize和Deserialize方法的修改
*  2010-04-19       田真                 增加了MergedBuffer和ParsedBuffer两个方法
*  2010-04-19       田真                 修改SerializedType继承自byte，以前是ushort
*  2010-04-19       田真                 修改CompressedByteArray = 255, CompressedObject = 256, CompressedString = 257
*                                              为：CompressedByteArray = 253, CompressedObject = 254, CompressedString = 255
*  ##############################################################
* ================================================================*/
#endregion

using System;
using System.IO;
using System.IO.Compression;
using System.Runtime.Serialization.Formatters.Binary;
using System.Text;

namespace SubCon.Caching.MemCached
{
    /// <summary>
    /// 序列化的对象类型
    /// </summary>
    internal enum SerializedType : byte
    {
        ByteArray    = 0,
        Object        = 1,
        String        = 2,
        Datetime    = 3,
        Bool        = 4,
        //SByte        = 5, //Makes no sense.
        Byte        = 6,
        Short        = 7,
        UShort        = 8,
        Int            = 9,
        UInt        = 10,
        Long        = 11,
        ULong        = 12,
        Float        = 13,
        Double        = 14,

        CompressedByteArray    = 253,
        CompressedObject    = 254,
        CompressedString    = 255,
    }

    /// <summary>
    /// 存储值序列器
    /// </summary>
    internal class Serializer
    {
        /// <summary>
        /// 序列化存储值
        /// </summary>
        /// <param name="value">要进行序列化的值</param>
        /// <param name="type">被序列的值是什么类型</param>
        /// <param name="compressionThreshold">压缩基准，当序列化后的字节数组长度大于该值时进行压缩</param>
        /// <returns></returns>
        public static byte[] Serialize(object value, out SerializedType type, uint compressionThreshold) {
            byte[] bytes;
            if (value is byte[]) {
                bytes = (byte[])value;
                type = SerializedType.ByteArray;
                if (bytes.Length > compressionThreshold) {
                    bytes = Compress(bytes);
                    type = SerializedType.CompressedByteArray;
                }
            } else if (value is string) {
                bytes = Encoding.UTF8.GetBytes((string)value);
                type = SerializedType.String;
                if (bytes.Length > compressionThreshold) {
                    bytes = Compress(bytes);
                    type = SerializedType.CompressedString;
                }
            } else if (value is DateTime) {
                bytes = BitConverter.GetBytes(((DateTime)value).Ticks);
                type = SerializedType.Datetime;
            } else if (value is bool) {
                bytes = new byte[]{(byte)((bool)value ? 1 : 0)};
                type = SerializedType.Bool;
            } else if (value is byte) {
                bytes = new byte[]{(byte)value};
                type = SerializedType.Byte;
            } else if (value is short) {
                bytes = BitConverter.GetBytes((short)value);
                type = SerializedType.Short;
            } else if (value is ushort) {
                bytes = BitConverter.GetBytes((ushort)value);
                type = SerializedType.UShort;
            } else if (value is int) {
                bytes = BitConverter.GetBytes((int)value);
                type = SerializedType.Int;
            } else if (value is uint) {
                bytes = BitConverter.GetBytes((uint)value);
                type = SerializedType.UInt;
            } else if (value is long) {
                bytes = BitConverter.GetBytes((long)value);
                type = SerializedType.Long;
            } else if (value is ulong) {
                bytes = BitConverter.GetBytes((ulong)value);
                type = SerializedType.ULong;
            } else if (value is float) {
                bytes = BitConverter.GetBytes((float)value);
                type = SerializedType.Float;
            } else if (value is double) {
                bytes = BitConverter.GetBytes((double)value);
                type = SerializedType.Double;
            } else {
                //Object
                using(MemoryStream ms = new MemoryStream()) {
                    new BinaryFormatter().Serialize(ms, value);
                    bytes = ms.ToArray();
                    type = SerializedType.Object;
                    if (bytes.Length > compressionThreshold) {
                        bytes = Compress(bytes);
                        type = SerializedType.CompressedObject;
                    }
                }
            }
            //针对TT进行的修改
            //edited by: 2010-4-19
            //田真
            return MergedBuffer(bytes, type);
        }

        /// <summary>
        /// 解析缓存字节数组，解析出实际数据和数据类型
        /// </summary>
        /// <param name="buffer"></param>
        /// <param name="type"></param>
        /// <returns></returns>
        private static byte[] ParsedBuffer(byte[] buffer, out SerializedType type)
        {
            //构造实际数据字节数组
            byte[] bytes = new byte[buffer.Length - 1];
            //提取类型
            if (!Enum.IsDefined(typeof(SerializedType), buffer[0]))
                type = SerializedType.ByteArray;
            else
                type = (SerializedType)buffer[0];
            //提取数据
            Buffer.BlockCopy(buffer, 1, bytes, 0, bytes.Length);
            return bytes;

        }

        /// <summary>
        /// 将序列化类型整合到存储的字节数组中（因为TT不支持Memcached的Type值存储）
        /// </summary>
        /// <param name="bytes">字节数组</param>
        /// <param name="type">字节数组的类型</param>
        /// <returns></returns>
        private static byte[] MergedBuffer(byte[] bytes, SerializedType type)
        {
            //增加一个字节，用于存放字节数组的类型
            byte[] buffer = new byte[bytes.Length + 1];
            //将类型存储到第一个字节中
            buffer[0] = (byte)type;
            Buffer.BlockCopy(bytes, 0, buffer, 1, bytes.Length);
            return buffer;
        }

        /// <summary>
        /// 压缩指定的字节数组
        /// </summary>
        /// <param name="bytes"></param>
        /// <returns></returns>
        private static byte[] Compress(byte[] bytes) {
            using (MemoryStream ms = new MemoryStream()) {
                using (DeflateStream gzs = new DeflateStream(ms, CompressionMode.Compress, false)) {
                    gzs.Write(bytes, 0, bytes.Length);
                }
                ms.Close();
                return ms.ToArray();
            }
        }

        /// <summary>
        /// 解压缩指定的字节数组
        /// </summary>
        /// <param name="bytes"></param>
        /// <returns></returns>
        private static byte[] Decompress (byte[] bytes) {
            using (MemoryStream ms = new MemoryStream(bytes, false)) {
                using(DeflateStream gzs = new DeflateStream(ms, CompressionMode.Decompress, false)) {
                    using(MemoryStream dest = new MemoryStream()) {
                        byte[] tmp = new byte[bytes.Length];
                        int read;
                        while ((read = gzs.Read(tmp, 0, tmp.Length)) != 0) {
                            dest.Write(tmp, 0, read);
                        }
                        dest.Close();
                        return dest.ToArray();
                    }
                }
            }
        }

        /// <summary>
        /// 反序列化数据
        /// </summary>
        /// <param name="bytes"></param>
        /// <param name="type"></param>
        /// <returns></returns>
        public static object Deserialize(byte[] bytes, SerializedType type) {
            //针对TT进行的修改
            //edited by: 2010-4-19
            //田真
            bytes = ParsedBuffer(bytes, out type);
            switch (type) {
                case SerializedType.String:
                    return Encoding.UTF8.GetString(bytes);
                case SerializedType.Datetime:
                    return new DateTime(BitConverter.ToInt64(bytes, 0));
                case SerializedType.Bool:
                    return bytes[0] == 1;
                case SerializedType.Byte:
                    return bytes[0];
                case SerializedType.Short:
                    return BitConverter.ToInt16(bytes, 0);
                case SerializedType.UShort:
                    return BitConverter.ToUInt16(bytes, 0);
                case SerializedType.Int:
                    return BitConverter.ToInt32(bytes, 0);
                case SerializedType.UInt:
                    return BitConverter.ToUInt32(bytes, 0);
                case SerializedType.Long:
                    return BitConverter.ToInt64(bytes, 0);
                case SerializedType.ULong:
                    return BitConverter.ToUInt64(bytes, 0);
                case SerializedType.Float:
                    return BitConverter.ToSingle(bytes, 0);
                case SerializedType.Double:
                    return BitConverter.ToDouble(bytes, 0);
                case SerializedType.Object:
                    using(MemoryStream ms = new MemoryStream(bytes)) {
                        return new BinaryFormatter().Deserialize(ms);
                    }
                case SerializedType.CompressedByteArray:
                    return Deserialize(Decompress(bytes), SerializedType.ByteArray);
                case SerializedType.CompressedString:
                    return Deserialize(Decompress(bytes), SerializedType.String);
                case SerializedType.CompressedObject:
                    return Deserialize(Decompress(bytes), SerializedType.Object);
                case SerializedType.ByteArray:
                default:
                    return bytes;
            }
        }
    }
}

Raw file: Serializer.cs

本文链接

Tokyo Tyrant使用中发现的问题

2010-04-13T08:15:00Z

从Tokyo Tyrant官网上看，它是兼容Memcached协议的，但在实际使用中发现以下两个问题：

1、在保存值到服务器时，Memcached的API会对值进行一次序列化，并且把值的原类型（一个整型，Memcached自己定义的），保存到服务器上，但是TTServer是无法保存的，每次get回来的类型值都是0（Memcached的API定义的0为ByteArray），造成无法将返回值自动反序列化，要解决这个问题，看来只有在存入前自己序列化一次，取出时再自己反序列化，比较不爽。

2、Memcached中的超时时间对TTServer无效，即所有数据如果存入TTServer如果不显式删除，它将永远存在。要解决这个问题，只有包装存入的值了，自己实现超时的功能。

Memcachedb没有问题1，但有问题2...

本文链接

Nginx做MogileFS的反向代理服务器

2010-04-11T01:29:00Z

在准备用MogileFS来替代公司现有文件系统时，一直困扰于文件的显示，因为像图片这样的静态文件，如果在显示时也要用Http Response来输出，那是一件非常杯具的事情。

经过一番查找，发现Nginx有一个MogileFS的Module，使用本模块，可以直接对MogileFS的文件进行定位。

由于本人现在对Nginx十分着迷，拿到这样一个东西简直如获至宝，于是立即着手测试。

我的Nginx版本是0.8.35，下载的MogileFS模块版本是1.0.2，最开始部署时，十分不顺，因为在将模块编译安装进Nginx后，启动Nginx老是报一个“Segmentation Fault”的错误，这个错误是因为程序中使用了一个空指针引起的，看来是模块版本和Nginx版本不兼容了。但是按照模块的帮助文件中的描述，使用Nginx的0.7系列，依然无法正常启动Nginx....

最后下载了MogileFS模块的1.0.3版本，终于成功搞定，以下是本人针对自己的需求配置的文件服务器的配置：

#user  nobody;
worker_processes  4;

error_log  logs/error.log  notice;

worker_rlimit_nofile 10240;

events {
    use epoll;
    worker_connections  10240;
}

http {
    include       mime.types;
    default_type  application/octet-stream;

    server_names_hash_bucket_size 128;
    client_header_buffer_size 32k;
    large_client_header_buffers 4 32k;

    client_max_body_size 8m;
    client_body_buffer_size 128k;

    proxy_connect_timeout 600;
    proxy_read_timeout 600;
    proxy_send_timeout 600;
    proxy_buffer_size 16k;
    proxy_buffers 4 32k;
    proxy_busy_buffers_size 64k;
    proxy_temp_file_write_size 64k;

    log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                      '$status $body_bytes_sent "$http_referer" '
                      '"$http_user_agent" "$http_x_forwarded_for"';

    access_log  logs/access.log  main;

    sendfile        on;
    #tcp_nopush     on;

    #keepalive_timeout  0;
    keepalive_timeout  65;

    gzip on;
    gzip_min_length 1k;
    gzip_buffers 4 16k;
    gzip_http_version 1.1;
    gzip_comp_level 2;
    gzip_types text/plain application/x-javascript text/css application/xml image/jpg image/jpeg image/gif image/png image/x-xbitmap image/pjpeg application/vnd.ms-excel application/vnd.ms-powerpoint application/msword application/x-shockwave-flash application/octet-stream;
    gzip_vary on;

    tcp_nodelay on;

    server {
        listen       80;
        server_name  yourdomain.com;

        location / {
        mogilefs_tracker 192.168.33.2:6001;
        mogilefs_domain test;
        mogilefs_methods get;

        mogilefs_pass {
        proxy_pass $mogilefs_path;
        proxy_hide_header Content-Type;
        proxy_buffering off;
        }
        expires 1h;
        }

        error_page   500 502 503 504  /50x.html;
        location = /50x.html {
            root   html;
        }

    }

}

值得注意的是，在实际使用时，要注意根据情况调整default_type，默认的值在FireFox下，会把图片当成无法打开的文件进行下载。

本文链接

记于波兰总统座机坠毁

2010-04-11T01:06:00Z

昨日的新闻，真是相当杯具的事情，多名国家大员同时殒命，想象一下这种事情发生在中国会是什么样子......

本文链接

聚集索引比非聚集索引更快吗？

2010-04-11T00:59:00Z

大概数周之前，因为公司招人，想在网上找点面试题“借用借用”，于是无意中找到这样一道数据库题：

“索引有那两种形式？分别有什么优缺点？”

文章作者给出的答案是：

“聚集索引：表中存储的数据按照索引的顺序存储，检索效率比非聚集索引高，但对数据更新影响较大。
非聚集索引：不影响表中数据的存储顺序，检索效率比聚集索引低，但对数据更新影响较小。”

非聚集索引真的比聚集索引慢吗？就本人对数据库的理解，并不是这样的。

以SQL SERVER为例，数据记录是分布在以8KB为单位的数据页上的。聚集索引就是数据本身，而非聚集索引保存的是索引键和对应的聚集索引键值。

因此绝大多数情况，一单位聚集索引的大小都大于一单位非聚集索引的大小，换句话说，一个数据页上能够容纳非聚集索引的条数是多余聚集索引的。

而SQL SERVER是以页为单位来扫描数据的，因此扫描相同页数量的数据页，能够覆盖的非聚集索引数量会更多，如果合理的利用SQL SERVER 2005的包含列的话，非聚集索引的查询效率是高于聚集索引的。

本文链接

封装的MogileFS的客户端API

2010-04-11T00:29:00Z

最近公司改造文件系统，由于以前的工作经验，选择了MogileFS来做。

在网上找到两个版本的客户端API，但是阅读代码后，发现都没有连接池的支持，于是自己动手在原API的基础上封装了一个支持连接池的API。

由于是基于ADO.NET的机制写的，因此在编写接口时，也要求提供一个类似数据库连接字符串的东东，格式如下：

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
    <connectionStrings>
        
        <add
            name="MogileFS"
            connectionString="host=192.168.33.2;port=6001;pooling=true;connection timeout=100;Connection Lifetime=150;domain=test;"/>
    </connectionStrings>
</configuration>

“MogileFS”是默认使用的配置节点名称。

配置中，除host和domain是必须项外，其它都是可选项。

源码：Maocos.IO.rar （该代码可自由传播、修改，但请保留版权申明）

本文链接

同一个Socket实例第二次无法接收服务端数据！！ (暂时占用一下首页，请多包涵，该问题困扰我两天了)

2008-12-24T03:19:00Z