博客园_EasyNet

CentOS 6系统配置优化

2012-05-09T03:08:00Z

/etc/sysctl.conf内核配置文件优化：

# Kernel sysctl configuration file for Red Hat Linux
#
# For binary values, 0 is disabled, 1 is enabled. See sysctl(8) and
# sysctl.conf(5) for more details.

# Controls IP packet forwarding
net.ipv4.ip_forward = 0

# Controls source route verification
net.ipv4.conf.default.rp_filter = 1

# Do not accept source routing
net.ipv4.conf.default.accept_source_route = 0

# Controls the System Request debugging functionality of the kernel
kernel.sysrq = 0

# Controls whether core dumps will append the PID to the core filename.
# Useful for debugging multi-threaded applications.
kernel.core_uses_pid = 1

# Controls the use of TCP syncookies
net.ipv4.tcp_syncookies = 1

# Disable netfilter on bridges.
net.bridge.bridge-nf-call-ip6tables = 0
net.bridge.bridge-nf-call-iptables = 0
net.bridge.bridge-nf-call-arptables = 0

# Controls the maximum size of a message, in bytes
kernel.msgmnb = 65536

# Controls the default maxmimum size of a mesage queue
kernel.msgmax = 65536

# Controls the maximum shared segment size, in bytes
kernel.shmmax = 68719476736

# Controls the maximum number of shared memory segments, in pages
kernel.shmall = 4294967296

# User Define
net.ipv4.tcp_fin_timeout = 1
net.ipv4.tcp_keepalive_time = 1200
net.ipv4.tcp_mem = 94500000 915000000 927000000
net.ipv4.tcp_tw_reuse = 1
net.ipv4.tcp_timestamps = 0
net.ipv4.tcp_synack_retries = 1
net.ipv4.tcp_syn_retries = 1
net.ipv4.tcp_tw_recycle = 1
net.core.rmem_max = 16777216
net.core.wmem_max = 16777216
net.core.netdev_max_backlog = 262144
net.core.somaxconn = 262144
net.ipv4.tcp_max_orphans = 3276800
net.ipv4.tcp_max_syn_backlog = 262144
net.core.wmem_default = 8388608
net.core.rmem_default = 8388608

关闭selinux，修改/etc/selinux/config：

# This file controls the state of SELinux on the system.
# SELINUX= can take one of these three values:
# enforcing - SELinux security policy is enforced.
# permissive - SELinux prints warnings instead of enforcing.
# disabled - No SELinux policy is loaded.
SELINUX=disabled
# SELINUXTYPE= can take one of these two values:
# targeted - Targeted processes are protected,
# mls - Multi Level Security protection.
SELINUXTYPE=targeted

系统最大打开文件数，修改/etc/security/limits.conf：

# /etc/security/limits.conf
#
#Each line describes a limit for a user in the form:
#
#<domain> <type> <item> <value>
#
#Where:
#<domain> can be:
# - an user name
# - a group name, with @group syntax
# - the wildcard *, for default entry
# - the wildcard %, can be also used with %group syntax,
# for maxlogin limit
#
#<type> can have the two values:
# - "soft" for enforcing the soft limits
# - "hard" for enforcing hard limits
#
#<item> can be one of the following:
# - core - limits the core file size (KB)
# - data - max data size (KB)
# - fsize - maximum filesize (KB)
# - memlock - max locked-in-memory address space (KB)
# - nofile - max number of open files
# - rss - max resident set size (KB)
# - stack - max stack size (KB)
# - cpu - max CPU time (MIN)
# - nproc - max number of processes
# - as - address space limit (KB)
# - maxlogins - max number of logins for this user
# - maxsyslogins - max number of logins on the system
# - priority - the priority to run user process with
# - locks - max number of file locks the user can hold
# - sigpending - max number of pending signals
# - msgqueue - max memory used by POSIX message queues (bytes)
# - nice - max nice priority allowed to raise to values: [-20, 19]
# - rtprio - max realtime priority
#
#<domain> <type> <item> <value>
#

#* soft core 0
#* hard rss 10000
#@student hard nproc 20
#@faculty soft nproc 20
#@faculty hard nproc 50
#ftp hard nproc 0
#@student - maxlogins 4
* soft nofile 65535
* hard nofile 65535
# End of file

本文链接

基于移动互联网的电子商务个性化推荐的一些思考

2012-04-27T03:48:00Z

在上周晚上冒着大雨参加了IT龙门阵主办的，由口袋购物候迅发表的主题为“智能推荐在移动电子商务中的应用”的主题演讲。在演讲中，候迅提出了一种”发现式无意识购物“的观点。很多人在很多时候，去商场，或者去压马路，可能并不是专门买什么而去的，或者是为了专门买什么而去，但是在逛的过程中，发现了一些促销信息、一些吸引眼球的广告、一些好玩感兴趣的东西等等，在很大可能上会产生购买行为。

由于手机的移动性，随处可用，无处不在，我觉得在移动互联网上实现”发现式无意识购物“更具有意义。用户购物，用户在手机上逛街，这些都是用户行为，但是怎么提供给用户虚拟的购物环境，也就是这个”街“，让用户在无目的行为中，产生兴趣，促使消费，这就是移动互联网应用开发商应该考虑的问题。

现实生活中，我的购物环境，也就是这个街，正常情况是个死的。你今天去，还是明天去，店铺商品一般变化不大。但是在移动互联网的虚拟环境下，就不会存在这种情况。他没有时间性，没有区域性。在现实中逛街，当你在店铺里面发现了一件自己感兴趣的商品，那么店员就会给你讲解沟通。在网络上，当然不会存在类似的角色，但是，我觉得，智能推荐提供了类似的功能。

智能推荐、推荐引擎、个性化智能推荐，这些都是在电子商务领域不可缺少的功能和研究课题。通过对用户行为的分析，用户分类聚合，推荐用户可能感兴趣的商品，这就是商品推荐引擎的目录。

个性化智能推荐，我觉得也可以称之为基于上下文的推荐。用户个性化推荐区别于普适推荐，用户在使用应用时，有一些当时的使用场景，即上下文信息，比如时间、所处地理位置、活动状态、网络状态等等。

基于上下文的个性化智能推荐，这是一个目前在学术界研究的一个难点课题，据我所知目前还没有完善的模型。在实际应用中，我觉得可以这么处理，一种方法是利用上下文信息在数据处理前进行过滤，另一种方式是在数据处理后，利用上下文信息对结果进行过滤，第三种方法就是在运行时，根据上下文信息参与数据运算。我觉得前两种方法应该更容易些。

无论是传统的普适推荐，还是个性化推荐，还是基于上下文的个性化推荐，都离不开基本数学理论，但是针对实际应用场景，采用适合自己的算法，模型，还是需要在实践应用中进行逐步调整。

本文链接

Linux安装性能问题

2012-04-07T12:07:00Z

在硬件系统上安装Linux系统之前，需要考虑许多有助于优化操作系统以及日后在其运行的应用程序的性能问题。这些问题包括：

选择分区位置
使用多个硬盘驱动器
选择文件系统

Linux至少需要一个root分区和一个swap分区，这两个分区以及其他需要频繁访问的分区在磁盘上的安装位置最终会影响到系统的性能。

对于var、swap、/var、/usr和/home等分区，都分别使用单独的分区
大多数硬盘驱动器的盘片在外侧磁道上封装的扇区要多于内侧磁道，因此从外侧磁道上读取数据要快得多。通常将编号较低的分区安装到外部磁道上（例如，/dev/hda1比/dev/hda3更接近与硬盘驱动器的外侧边缘），因此首先要放置需要经常访问的分区
第一个分区应该是swap分区（用于优化内存交换操作）
第二个分区应该是/var，因为日志记录会频繁地写入/var/log中
下一个分区应该是/usr，因为基本的系统工具和命令都位于/usr中
root和/home分区可以驻留在靠近硬盘驱动器末尾的位置

使用多个硬盘驱动器，并要充分利用多个硬盘驱动器。

将经常访问的分区安装到更快的硬盘驱动器上
如果这些硬盘驱动器的性能相近，那么将常用的分区分别安装在不同的硬盘驱动器上。例如，讲/var和/usr分区分别置于两个不同的硬盘驱动器上，而交换分区位于自己单独的硬盘驱动器上
为了最大话总线吞吐率，应该将每个充当主设备的硬盘驱动器安放到I/O通道上。硬盘驱动器在不同I/O通道之间移动后，其设备名称会发生变化，因此需要对文件系统表（/etc/fstab）进行相应改动。如果对包含root或/boot分区的硬盘驱动器进行移动，那么还需要编辑/boot/grub/menu.lst文件

文件系统类型

ext4，ext3的改进版，提供更加的性能和可靠性，更为丰富的功能
ReiserFS，对于小型文件具有更佳的性能
XFS，针对大型文件具有更佳的性能

本文链接

EasyNet.Solr 3.5.1发布及使用中的一些原则

2012-02-05T12:51:00Z

随着Solr的广泛的应用，Solr的版本更新也加快了脚本，EasyNet.Solr（http://easynet.codeplex.com/）其实一直在断断续续维护中，今天也发布了最新版本，完全支持Solr 3.5.1。相对于目前Solr基于.Net的客户端SolrSharp（http://solrsharp.codeplex.com/）、Solr.Net（http://code.google.com/p/solrnet/），具有以下特点：

1.完全支持Solr官方的Xml、Json，特别是Javabin协议

2.基于接口的序列化策略，提供更好的性能

3.简单接口，具有很高的扩展性

EasyNet.Solr使用原则和建议：

1.建议Solr部署在Linux下，并对Tomcat、JVM、系统内核进行优化

2.一定要使用Replication

3.建议采用Javabin协议，在solrconfig中直接设置默认输出协议为Javabin：<queryResponseWriter name="javabin" default="true" class="solr.BinaryResponseWriter"/>

4.轻易不要对Solr进行改动，尽量在上层实现

5.优化可以参考 http://wiki.apache.org/lucene-java/BasicsOfPerformance，http://wiki.apache.org/solr/SolrPerformanceFactors

EasyNet.Solr的应用示例请参加：http://easynet.codeplex.com/wikipage?title=EasyNet%20Solr。

Blog：http://www.cnblogs.com/terryliang

QQ：124244236

Email：easynet.cn@gmail.com liangtianyu@gmail.com

EasyNet QQ Group： 181963043

本文链接

asp.net mvc3的静态化实现

2011-11-13T05:08:00Z

静态化处理，可以大大提高客户的访问浏览速度，提高用户体验，同时也降低了服务器本身的压力。在asp.net mvc3中，可以相对容易地处理静态化问题，不用过多考虑静态网页的同步，生成等等问题。我提供这个方法很简单，就需要在需要静态化处理的Controller或Action上加一个Attribute就可以。下面是我写的一个生成静态文件的ActionFilterAttribute。

1 using System;

  2     using System.IO;
  3     using System.Text;
  4     using System.Web;
  5     using System.Web.Mvc;
  6     using NLog;
  7
  8     /// <summary>
  9     /// 生成静态文件
10     /// </summary>
11     [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, Inherited = true, AllowMultiple = true)]
12     public class GenerateStaticFileAttribute : ActionFilterAttribute
13     {
14         #region 私有属性
15
16         private static readonly Logger logger = LogManager.GetCurrentClassLogger();
17
18         #endregion
19
20         #region 公共属性
21
22         /// <summary>
23         /// 过期时间，以小时为单位
24         /// </summary>
25         public int Expiration { get; set; }
26
27         /// <summary>
28         /// 文件后缀名
29         /// </summary>
30         public string Suffix { get; set; }
31
32         /// <summary>
33         /// 缓存目录
34         /// </summary>
35         public string CacheDirectory { get; set; }
36
37         /// <summary>
38         /// 指定生成的文件名
39         /// </summary>
40         public string FileName { get; set; }
41
42         #endregion
43
44         #region 构造函数
45
46         /// <summary>
47         /// 默认构造函数
48         /// </summary>
49         public GenerateStaticFileAttribute()
50         {
51             Expiration = 1;
52             CacheDirectory = AppDomain.CurrentDomain.BaseDirectory;
53         }
54
55         #endregion
56
57         #region 方法
58
59         public override void OnResultExecuted(ResultExecutedContext filterContext)
60         {
61             var fileInfo = GetCacheFileInfo(filterContext);
62
63             if ((fileInfo.Exists && fileInfo.CreationTime.AddHours(Expiration) < DateTime.Now) || !fileInfo.Exists)
64             {
65                 var deleted = false;
66
67                 try
68                 {
69                     if (fileInfo.Exists)
70                     {
71                         fileInfo.Delete();
72                     }
73
74                     deleted = true;
75                 }
76                 catch (Exception ex)
77                 {
78                     logger.Error("删除文件:{0}发生异常:{1}", fileInfo.FullName, ex.StackTrace);
79                 }
80
81                 var created = false;
82
83                 try
84                 {
85                     if (!fileInfo.Directory.Exists)
86                     {
87                         fileInfo.Directory.Create();
88                     }
89
90                     created = true;
91                 }
92                 catch (IOException ex)
93                 {
94                     logger.Error("创建目录:{0}发生异常:{1}", fileInfo.DirectoryName, ex.StackTrace);
95                 }
96
97                 if (deleted && created)
98                 {
99                     FileStream fileStream = null;
100                     StreamWriter streamWriter = null;
101
102                     try
103                     {
104                         var viewResult = filterContext.Result as ViewResult;
105                         fileStream = new FileStream(fileInfo.FullName, FileMode.CreateNew, FileAccess.Write, FileShare.None);
106                         streamWriter = new StreamWriter(fileStream);
107                         var viewContext = new ViewContext(filterContext.Controller.ControllerContext, viewResult.View, viewResult.ViewData, viewResult.TempData, streamWriter);
108                         viewResult.View.Render(viewContext, streamWriter);
109                     }
110                     catch (Exception ex)
111                     {
112                         logger.Error("生成缓存文件:{0}发生异常:{1}", fileInfo.FullName, ex.StackTrace);
113                     }
114                     finally
115                     {
116                         if (streamWriter != null)
117                         {
118                             streamWriter.Close();
119                         }
120
121                         if (fileStream != null)
122                         {
123                             fileStream.Close();
124                         }
125                     }
126                 }
127             }
128         }
129
130         /// <summary>
131         /// 生成文件Key
132         /// </summary>
133         /// <param name="controllerContext">ControllerContext</param>
134         /// <returns>文件Key</returns>
135         protected virtual string GenerateKey(ControllerContext controllerContext)
136         {
137             var url = controllerContext.HttpContext.Request.Url.ToString();
138
139             if (string.IsNullOrWhiteSpace(url))
140             {
141                 return null;
142             }
143
144             var th = new TigerHash();
145             var data = th.ComputeHash(Encoding.Unicode.GetBytes(url));
146             var key = Convert.ToBase64String(data, Base64FormattingOptions.None);
147             key = HttpUtility.UrlEncode(key);
148
149             return key;
150         }
151
152         /// <summary>
153         /// 获取静态的文件信息
154         /// </summary>
155         /// <param name="controllerContext">ControllerContext</param>
156         /// <returns>缓存文件信息</returns>
157         protected virtual FileInfo GetCacheFileInfo(ControllerContext controllerContext)
158         {
159             var fileName = string.Empty;
160
161             if (string.IsNullOrWhiteSpace(FileName))
162             {
163                 var key = GenerateKey(controllerContext);
164
165                 if (!string.IsNullOrWhiteSpace(key))
166                 {
167                     fileName = Path.Combine(CacheDirectory, string.IsNullOrWhiteSpace(Suffix) ? key : string.Format("{0}.{1}", key, Suffix));
168                 }
169             }
170             else
171             {
172                 fileName = Path.Combine(CacheDirectory, FileName);
173             }
174
175             return new FileInfo(fileName);
176         }
177
178         #endregion
179     }

如果大家对于生成的文件和目录有特殊的要求，那可以重写GetCacheFileInfo方法，比如按照日期生成目录等等更复杂的目录和文件结构。当然以上代码只是提供了生成静态页的方法，但是访问如何解决呢？访问静态文件和规则就需要在HttpApplication的Application_BeginRequest实现了。首先可以设置需要静态化访问的路由地址以html结尾。下面的是一个用于首页的静态化访问的实现，很简单，当然你可以实现比较复杂的逻辑，比如根据文件时间来判断是否应该访问静态文件等等。

1         protected void Application_BeginRequest(object sender, EventArgs e)
2         {
3             StaticContentRewrite();
4         }
5
6         /// <summary>
7         /// 处理静态发布内容
8         /// </summary>
9         private void StaticContentRewrite()
10         {
11             if (Context.Request.FilePath == "/" || Context.Request.FilePath.StartsWith("/index.html", StringComparison.OrdinalIgnoreCase))
12             {
13                 if (File.Exists(Server.MapPath("index.html")))
14                 {
15                     Context.RewritePath("index.html");
16                 }
17             }

18 }

本文链接

CentOS 6 设置KVM的桥接方式

2011-09-23T07:08:00Z

禁用网络管理器

# chkconfig NetworkManager off

# service NetworkManager stop

创建用以桥接的虚拟网卡

# cd /etc/sysconfig/network-scripts

# cp ifcfg-eth0 ifcfg-br0

编辑 ifcfg-br0

# vi ifcfg-br0

DEVICE="br0"

TYPE="Bridge"

ONBOOT="yes"

BOOTPROTO=static

IPADDR=192.168.1.17

PREFIX=24

GATEWAY=192.168.1.1

DNS1=202.106.46.151

DELAY=0

编辑ifcfg-eth0

# vi ifcfg-eth0

DEVICE="eth0"

NM_CONTROLLED="yes"

ONBOOT=yes

TYPE=Ethernet

BRIDGE="br0"

BOOTPROTO=none

IPADDR=192.168.1.17

PREFIX=24

GATEWAY=192.168.1.1

DEFROUTE=yes

IPV4_FAILURE_FATAL=yes

IPV6INIT=no

NAME="System eth0"

UUID=5fb06bd0-0bb0-7ffb-45f1-d6edd65f3e03

DNS1=202.106.46.151

HWADDR=00:1E:67:07:EC:30

重新启动网络

# service network restart

本文链接

CentOS 6编译安装ipvsadm和keepalived

2011-09-22T03:40:00Z

我的CentOS 6采用的最小安装，ipvsadm和keepalived均采用最新版本。

# yum update libnl-devel
# cd /home/software/lvs
# tar zxvf popt-1.14.tar.gz
# cd popt-1.14
# ./configure
# make
# make install
# ln -s /usr/src/kernels/2.6.32-71.29.1.el6.x86_64/ /usr/src/linux
# tar zxvf ipvsadm-1.26.tar.gz
# cd ipvsadm-1.26
# make
# make install
# cd /home/software/keepalived
# yum install openssl-devel
# ./configure
# make

# make install

本文链接

源码编译安装Percona Server 5.5

2011-09-20T05:01:00Z

Percona Server（http://www.percona.com/）是MySQL的衍生版，其对MySQL进行了改进，在功能、性能和稳定性上有着显著的提高。下面介绍一下如何用源码自行编译安装目前最新版本的Percona Server 5.5。

服务器系统版本为Centos 6。

从地址http://www.percona.com/redir/downloads/Percona-Server-5.5/Percona-Server-5.5.15-21.0/source/Percona-Server-5.5.15-rel21.0.tar.gz 下载最新源码包，并拷贝到/home/software/percona下。在控制台执行以下命令：

# cd /home/software/percona

# tar zxvf Percona-Server-5.5.15-rel21.0.tar.gz

# cd Percona-Server-5.5.15-rel21.0

# CC=gcc CFLAGS="-DBIG_JOINS=1 -DHAVE_DLOPEN=1 -O3" CXX=g++ CXXFLAGS="-DBIG_JOINS=1 -DHAVE_DLOPEN=1 -felide-constructors -fno-rtti -O3"

# cmake . \

-DCMAKE_BUILD_TYPE:STRING=Release \

-DSYSCONFDIR:PATH=/usr/local/mysql \

-DCMAKE_INSTALL_PREFIX:PATH=/usr/local/mysql \

-DENABLED_PROFILING:BOOL=ON \

-DENABLE_DEBUG_SYNC:BOOL=OFF \

-DMYSQL_DATADIR:PATH=/usr/local/mysql/data \

-DMYSQL_MAINTAINER_MODE:BOOL=OFF \

-DWITH_EXTRA_CHARSETS:STRING=utf8,gbk,gb2312 \

-DWITH_BIG_TABLES:BOOL=ON \

-DWITH_FAST_MUTEXES:BOOL=ON \

-DENABLE-PROFILING:BOOL=ON \

-DWITH_SSL:STRING=bundled \

-DWITH_UNIT_TESTS:BOOL=OFF \

-DWITH_ZLIB:STRING=bundled \

-DWITH_PARTITION_STORAGE_ENGINE:BOOL=ON \

-DWITH_SERVER_SUFFIX=hxsw \

-DWITH_PLUGINS=heap,csv,partition,innodb_plugin,myisam \

-DEFAULT_COLLATION=utf8_general_ci \

-DEFAULT_CHARSET=utf8 \

-DENABLED_ASSEMBLER:BOOL=ON \

-DENABLED_LOCAL_INFILE:BOOL=ON \

-DENABLED_THREAD_SAFE_CLIENT:BOOL=ON \

-DENABLED_EMBEDDED_SERVER:BOOL=OFF \

-DWITH_CLIENT_LDFLAGS:STRING=all-static \

-DINSTALL_LAYOUT:STRING=STANDALONE \

-DCOMMUNITY_BUILD:BOOL=ON;

# make

# make install

修改/etc/my.cnf，如如下内容：

# Example MySQL config file for medium systems.

# This is for a system with little memory (32M - 64M) where MySQL plays

# an important part, or systems up to 128M where MySQL is used together with

# other programs (such as a web server)

# You can copy this file to

# /etc/my.cnf to set global options,

# mysql-data-dir/my.cnf to set server-specific options (in this

# installation this directory is /usr/local/mysql/data) or

# ~/.my.cnf to set user-specific options.

# In this file, you can use all long options that a program supports.

# If you want to know which options a program supports, run the program

# with the "--help" option.

# The following options will be passed to all MySQL clients

[client]

#password = your_password

port = 3306

socket = /tmp/mysql.sock

default-character-set = utf8

# Here follows entries for some specific programs

# The MySQL server

[mysqld]

character_set_server = utf8

connect_timeout = 20

basedir = /usr/local/mysql/

datadir = /usr/local/mysql/data

user = mysql

port = 3306

socket = /tmp/mysql.sock

pid-file = /usr/local/mysql/data/mysql.pid

back_log = 500

event_scheduler = OFF

expire_logs_days= 7

skip-name-resolve

#default_table_type = Innodb

innodb_file_format=Barracuda

max_connections = 1100

max_connect_errors = 1000

table_cache = 2048

table_open_cache = 6144

table_definition_cache = 4096

wait_timeout=100

interactive_timeout = 100

tmpdir = /usr/local/mysql/tmp

tmp_table_size = 64M

max_heap_table_size = 64M

thread_cache_size = 64

thread_concurrency = 32

thread_stack = 192K

max_allowed_packet = 1G

sort_buffer_size = 512K

join_buffer_size = 1M

query_cache_size = 0

#query_cache_limit = 2M

key_buffer_size = 64M

read_buffer_size = 512k

read_rnd_buffer_size = 512k

bulk_insert_buffer_size = 32M

loose_handlersocket_port = 9998

# the port number to bind to (for read requests)

loose_handlersocket_port_wr = 9999

# the port number to bind to (for write requests)

loose_handlersocket_threads = 16

# the number of worker threads (for read requests)

loose_handlersocket_threads_wr = 1

# the number of worker threads (for write requests)

open_files_limit = 65535

# to allow handlersocket accept many concurrent

# connections, make open_files_limit as large as

# possible.

# Don't listen on a TCP/IP port at all. This can be a security enhancement,

# if all processes that need to connect to mysqld run on the same host.

# All interaction with mysqld must be made via Unix sockets or named pipes.

# Note that using this option without enabling named pipes on Windows

# (via the "enable-named-pipe" option) will render mysqld useless!

#skip-networking

# Replication Master Server (default)

# binary logging is required for replication

binlog_format = mixed

binlog_cache_size = 1M

log-bin = /usr/local/mysql/logs/mysql-bin

max_binlog_size = 128M

#log_long_format

#slow_query_log_file = mysql.slow

#log_queries_not_using_indexes = 0

long_query_time = 1

#log-slow-queries=/usr/local/mysql/logs/slowquery.log

slow_query_log_file=/usr/local/mysql/logs/slowquery.log

#myisam_sort_buffer_size = 32M

#myisam_max_sort_file_size = 512M

#myisam_max_extra_sort_file_size = 512M

#myisam_repair_threads = 1

#myisam_recover

#SLAVE

#server-id = 60133

#master-host = 172.21.32.129

#master-user = repl

#master-password = repl

#master-port = 3306

#replicate-do-db=mydb

#replicate-ignore-table=mysql.inventory

#replicate-ignore-db=mysql

#replicate-ignore-table=mysql.user

#slave-net-timeout=35

#master-connect-retry=30

#relay-log = relay-bin

#max-relay-log-size = 128M

#log_slave_updates

#replicate-same-server-id=0

skip-slave-start

#slave_skip_errors =1032

##slave_skip_errors = all

#read-only

#transaction_isolation = READ-COMMITTED

innodb_flush_method = O_DIRECT

innodb_buffer_pool_size = 2G

innodb_additional_mem_pool_size = 16M

innodb_data_home_dir = /usr/local/mysql/data

innodb_data_file_path = ibdata1:2G:autoextend

innodb_file_per_table = 1

innodb_log_group_home_dir = /usr/local/mysql/logs

innodb_log_buffer_size = 64M

innodb_log_file_size = 256M

innodb_log_files_in_group = 3

innodb_thread_concurrency = 288

innodb_thread_sleep_delay = 500

innodb_file_io_threads = 4

innodb_concurrency_tickets = 1000

innodb_adaptive_hash_index = 1

innodb_adaptive_flushing = 1

innodb_doublewrite = 1

innodb_sync_spin_loops = 40

innodb_io_capacity = 200

innodb_flush_log_at_trx_commit = 0

innodb_max_dirty_pages_pct = 80

#innodb_lock_wait_timeout = 120

innodb_lock_wait_timeout = 10

innodb_support_xa = 0

log_bin_trust_function_creators = 1

[mysqldump]

quick

max_allowed_packet = 16M

[mysql]

no-auto-rehash

# Remove the next comment character if you are not familiar with SQL

#safe-updates

[myisamchk]

key_buffer_size = 20M

sort_buffer_size = 20M

read_buffer = 2M

write_buffer = 2M

[mysqlhotcopy]

interactive-timeout

注意：在标红处，可以设置字符集为utf8，缓冲区大小根据实际情况来调整。

在/usr/local/mysql目录下，创建目录：logs、tmp，并且赋予读写权限。

添加到启动项：

# cd /usr/local/mysql

# cp support-files/mysql.server /etc/rc.d/init.d/mysqld

# chmod 700 /etc/init.d/mysqld

# chkconfig --add mysqld

# chkconfig --level 345 mysqld on

安装handlersocket

# cd cd /home/software/percona/Percona-Server-5.5.15-rel21.0/storage/HandlerSocket-Plugin-for-MySQL/

# ./autogen.sh

# ./configure --with-mysql-source=/home/software/percona/Percona-Server-5.5.15-rel21.0 --with-mysql-bindir=/usr/local/mysql/bin/ --with-mysql-plugindir=/usr/local/mysql/lib/mysql/plugin

# make

# make install

初始化话数据库我就不写了，网上资料很多。完成后登录到mysql可以安装handlersocket插件了：

# mysql> INSTALL PLUGIN handlersocket SONAME 'handlersocket.so';

# mysql> SHOW PLUGINS;

本文链接

CentOS 6下ActiveMQ 5.5安装及使用MySQL

2011-09-16T03:27:00Z

从http://activemq.apache.org/download.html下载ActiveMQ的最新版本，当前是5.50，把包apache-activemq-5.5.0-bin .tar.gz拷贝到/home/software/apache-activemq目录下，执行以下命令：

# cd /home/software/apache-activemq

# tar zxvf apache-activemq-5.5.0-bin .tar.gz

# cp -a apache-activemq-5.5.0 /usr/local/activemq

# cd /usr/local/activemq

我使用mysql作为消息的存储，修改 /usr/local/activemq/conf/activemq.xml如下：

<!--

Licensed to the Apache Software Foundation (ASF) under one or more

contributor license agreements. See the NOTICE file distributed with

this work for additional information regarding copyright ownership.

The ASF licenses this file to You under the Apache License, Version 2.0

(the "License"); you may not use this file except in compliance with

the License. You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software

distributed under the License is distributed on an "AS IS" BASIS,

WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

See the License for the specific language governing permissions and

limitations under the License.

-->

<beans

xmlns="http://www.springframework.org/schema/beans"

xmlns:amq="http://activemq.apache.org/schema/core"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd

http://activemq.apache.org/schema/core http://activemq.apache.org/schema/core/activemq-core.xsd">

<value>file:${activemq.base}/conf/credentials.properties</value>

</property>

</bean>

</bean>

<!--

The <broker> element is used to configure the ActiveMQ broker.

-->

<!--

For better performances use VM cursor and small memory limit.

For more information, see:

http://activemq.apache.org/message-cursors.html

Also, if your producer is "hanging", it's probably due to producer flow control.

For more information, see:

http://activemq.apache.org/producer-flow-control.html

-->

<policyEntry topic=">" producerFlowControl="true" memoryLimit="1mb">

</pendingSubscriberPolicy>

</policyEntry>

<policyEntry queue=">" producerFlowControl="true" memoryLimit="1mb">

<!-- Use VM cursor for better latency

For more information, see:

http://activemq.apache.org/message-cursors.html

</pendingQueuePolicy>

-->

</policyEntry>

</policyEntries>

</policyMap>

</destinationPolicy>

<!--

The managementContext is used to configure how ActiveMQ is exposed in

JMX. By default, ActiveMQ uses the MBean server that is started by

the JVM. For more information, see:

http://activemq.apache.org/jmx.html

-->

</managementContext>

<!--

Configure message persistence for the broker. The default persistence

mechanism is the KahaDB store (identified by the kahaDB tag).

For more information, see:

http://activemq.apache.org/persistence.html

-->

<!-- <persistenceAdapter>

</persistenceAdapter> -->

</persistenceAdapter>

<!--

The systemUsage controls the maximum amount of space the broker will

use before slowing down producers. For more information, see:

http://activemq.apache.org/producer-flow-control.html

</memoryUsage>

</storeUsage>

</tempUsage>

</systemUsage>

-->

<!--

The transport connectors expose ActiveMQ over a given protocol to

clients and other brokers. For more information, see:

http://activemq.apache.org/configuring-transports.html

-->

</transportConnectors>

</broker>

<!--

Enable web consoles, REST and Ajax APIs and demos

It also includes Camel (with its web console), see ${ACTIVEMQ_HOME}/conf/camel.xml for more info

Take a look at ${ACTIVEMQ_HOME}/conf/jetty.xml for more details

-->

</beans>

在启动前，需要创建数据库 activemq，并且不要参照activemq-jdbc.xml配置 <property name="poolPreparedStatements" value="true"/>。

# bin/activemq start

从浏览器中打开：，发给消息测试一下，可以正常发送的话，就应该没有什么大问题。

本文链接

extjs 4中TreePanel和GridPanel使用

2011-09-07T00:45:00Z

本示例实现了以下功能：

1.用TreePanel展现部门列表

2 .点击部门，可以显示此部门下所有的员工

在extjs 4中GridPanel的分页对于旧版本有所变化，具体变化可以参加下面提供的代码。

Ext.define('MyDesktop.EmployeeWindow', {
    extend: 'Ext.ux.desktop.Module',

    id: 'employee-win',

    init: function () {
        this.launcher = {
            text: '员工管理',
            iconCls: 'icon-grid',
            handler: this.createWindow,
            scope: this
        };
    },

    createWindow: function () {
        var desktop = this.app.getDesktop();
        var win = desktop.getWindow('employee-win');
        var deptStore = Ext.create('Ext.data.TreeStore', {
            model: 'Department',
            proxy: {
                type: 'ajax',
                url: '/department/getall'
            }
        });
        var employeeStore = Ext.create('Ext.data.Store', {
            id: 'employeeStore',
            model: 'Employee',
            pageSize: 2,
            //autoLoad: {start: 0, limit: 2},
            proxy: {
                type: 'ajax',
                url: '/employee/getpagedbydepartmentid',
                reader: {
                    type: 'json',
                    root: 'Data',
                    totalProperty: 'Total'
                },

                extraParams: {
                    departmentId: 0
                }

            }
        });
        if (!win) {
            win = desktop.createWindow({
                id: 'employee-win',
                title: '员工信息',
                width: 740,
                height: 480,
                iconCls: 'icon-grid',
                layout: 'border',
                items: [{
                    region: 'west',
                    split: true,
                    margins: '2 0 5 5',
                    width: 275,
                    minSize: 100,
                    maxSize: 500,
                    xtype: 'treepanel',
                    useArrows: true,
                    root: {
                        Name: '所有部门',
                        Id: 0,
                        expanded: true,
                        selected: true
                    },
                    rootVisible: true,
                    store: deptStore,
                    singleExpand: true,
                    columns: [{
                        xtype: 'treecolumn',
                        text: '名称',
                        flex: 2,
                        sortable: true,
                        dataIndex: 'Name'
                    }],
                    listeners: {
                        afterrender: function (tree) {
                            tree.getSelectionModel().select(0);
                        },
                        itemclick: function (tree, record) {
                            employeeStore.currentPage = 1;
                            employeeStore.load({
                                start: 0,
                                limit: 2,

                                params: {
                                    departmentId: record.data.Id
                                }
                            });
                        }
                    }
                },
                    {
                        region: 'center',
                        layout: 'card',
                        margins: '2 5 5 0',
                        border: false,
                        xtype: 'grid',
                        store: employeeStore,
                        columns: [{
                            text: 'Id',
                            dataIndex: 'Id'
                        }, {
                            text: '编号',
                            dataIndex: 'Number'
                        }, {
                            text: "姓名",
                            dataIndex: 'Name'
                        }, {
                            text: "部门",
                            dataIndex: 'Department',
                            renderer: function (value) {
                                return value.Name;
                            }
                        }, {
                            text: "性别",
                            dataIndex: 'Gender',
                            renderer: function (value) {
                                return value == 0 ? '女' : '男';
                            }
                        }
                        ],
                        bbar: Ext.create('Ext.PagingToolbar', {
                            store: employeeStore,
                            displayInfo: true,
                            displayMsg: '显示员工 {0} - {1} / {2}',
                            emptyMsg: '没有员工信息'
                        })
                    }
                ],
                tbar: [{
                    text: '添加',
                    tooltip: '添加员工信息',
                    handler: function () {
                        var addWin;
                        if (!addWin) {
                            addWin = Ext.create('widget.window', {
                                title: '添加员工信息',
                                width: 400,
                                modal: true,
                                resizable: false,
                                items: [{
                                    xtype: 'form',
                                    frame: true,
                                    bodyPadding: '10 10 0',
                                    url: '/employee/create',
                                    defaults: {
                                        anchor: '100%',
                                        allowBlank: false,
                                        msgTarget: 'side',
                                        labelWidth: 50
                                    },
                                    defaultType: 'textfield',
                                    items: [{
                                        fieldLabel: '姓名',
                                        name: 'name'
                                    }, {
                                        fieldLabel: '性别',
                                        name: 'Gender',
                                        value: '0'
                                    }],
                                    buttons: [{
                                        text: '保存',
                                        formBind: true,
                                        handler: function () {
                                            var form = this.up('form').getForm();
                                            var tree = win.items.items[0];
                                            var selModel = tree.getSelectionModel();
                                            var selected = selModel.getSelection();
                                            var dept = null;

                                            if (selected.length > 0) {
                                                dept = selected[0].data;
                                            }
                                            if (form.isValid()) {
                                                form.submit({
                                                    params: {
                                                        Number: dept == null ? 0 : dept.Id
                                                    },
                                                    waitTitle: '添加员工信息',
                                                    waitMsg: '正在处理',
                                                    success: function (form, action) {
                                                        form.reset();
                                                        employeeStore.load();
                                                    },
                                                    failure: function (form, action) {
                                                        Ext.Msg.alert('添加员工信息', '添加员工信息失败');
                                                    }
                                                });

                                            }
                                        }
                                    }, {
                                        text: '重置',
                                        handler: function () {
                                            this.up('form').getForm().reset();
                                        }
                                    }]
                                }]
                            });
                        }

                        addWin.show();
                    }
                }, '-', {
                    text: '修改',
                    tooltip: '修改员工信息',
                    iconCls: 'update',
                    handler: function () {
                        var grid = win.items.items[0];
                        var selModel = grid.getSelectionModel();
                        var selected = selModel.getSelection();

                        if (selected.length == 0) {
                            Ext.Msg.alert('修改', '请选择员工');
                            return;
                        }

                        var employee = selected[0].data;
                        var updateWin;

                        if (!updateWin) {
                            updateWin = Ext.create('widget.window', {
                                title: '修改员工信息',
                                width: 400,
                                modal: true,
                                items: [{
                                    xtype: 'form',
                                    frame: true,
                                    bodyPadding: '10 10 0',
                                    url: '/employee/update',
                                    defaults: {
                                        anchor: '100%',
                                        allowBlank: false,
                                        msgTarget: 'side',
                                        labelWidth: 50
                                    },
                                    defaultType: 'textfield',
                                    items: [{
                                        xtype: 'hiddenfield',
                                        name: 'id',
                                        value: employee.Id
                                    }, {
                                        fieldLabel: '名称',
                                        name: 'name',
                                        value: employee.Name
                                    }, {
                                        xtype: 'textareafield',
                                        fieldLabel: '部门',
                                        name: 'number',
                                        value: employee.Number
                                    }, {
                                        fieldLabel: '性别',
                                        name: 'gender',
                                        value: employee.Gender
                                    }],
                                    buttons: [{
                                        text: '保存',
                                        formBind: true,
                                        handler: function () {
                                            var form = this.up('form').getForm();

                                            if (form.isValid()) {
                                                form.submit({
                                                    waitTitle: '修改员工信息',
                                                    waitMsg: '正在处理',
                                                    success: function (form, action) {
                                                        form.reset();
                                                        employeeStore.load();
                                                    },
                                                    failure: function (form, action) {
                                                        Ext.Msg.alert('更新员工信息', '更新员工信息失败');
                                                    }
                                                });

                                            }
                                        }
                                    }, {
                                        text: '重置',
                                        handler: function () {
                                            this.up('form').getForm().reset();
                                        }
                                    }]
                                }]
                            });
                        }

                        updateWin.show();
                    }
                }]
            });
        }
        win.show();

        return win;
    }
});

本文链接