浮山狼de博客 » linux

Linux Skype Robot

fushanlang — Tue, 25 Feb 2014 01:50:51 +0000

Skype Robot in Ubuntu

skype linux 机器人

1.安装所需的软件包

apt-get install python-software-properties
sudo add-apt-repository "deb http://archive.canonical.com/$(lsb_release -sc) partner"
sudo apt-get update
sudo apt-get install gcc
sudo apt-get install skype
sudo apt-get install xvfb
sudo apt-get install fluxbox x11vnc
sudo apt-get install dbus
sudo apt-get install vnc4server

http://www.qxs.ch/2011/01/07/skype-instant-messages-from-zabbix/

wget http://sourceforge.net/projects/skype4py/files/skype4py/1.0.32.0/Skype4Py-1.0.32.0.tar.gz
tar -xzf Skype4Py-1.*
cd Skype4Py-1.0.32.0/
python setup.py install
vi ./build/lib.linux-i686-2.7/Skype4py/api/posix_dbus.py
(64位： vi ./build/lib.linux-x86_64-2.7/Skype4Py/api/posix_dbus.py)
replace os.execlp('skype') with os.execlp('skype', 'skype')
python setup.py install

2.create file skype_chat.py

import os
import sys
import optparse
import Skype4Py

parser = optparse.OptionParser(version='%prog 1.0.0');
parser.add_option('--create-channel', help='create a new channel');
parser.add_option('--user', help='skype username');
parser.add_option('--disband-channel', help='disband a channel');
parser.add_option('--sendto-channel', help='select a channel');
parser.add_option('--message', help='send msg to channel');
parser.add_option('--from-channel', help='from channel');
parser.add_option('--kick', help='kicks member(s) from chat');

opts, args = parser.parse_args();
if args:
    parser.error('unexpected argument(s)'); 

skype = Skype4Py.Skype(Transport='x11');
channel_file = 'skype_channel'; 
def SkypeInit():
    if not skype.Client.IsRunning:
        skype.Client.Start();
    skype.Attach(); 
def GetChatName(channel):
    if not os.path.isfile(channel_file):
        print 'can not find channel file skype_channel, please create new channel.';
        exit();
    f = open(channel_file,'r');
    lines = f.readlines();
    chat_name = None;
    for line in lines:
        channel_list = line.split();
        channel_name = channel_list[0];
        if channel_name == channel:
            chat_name = channel_list[1];
            break;
    f.close();
    return chat_name; 
if opts.create_channel != None and opts.user != None:
    channel = opts.create_channel;
    user = opts.user;
    SkypeInit();
    chat = skype.CreateChatWith(user);
    f = open(channel_file,'a+');
    lines = f.readlines();

    for line in lines:
        cname = line.split();
        cname = cname[0];
        if cname == channel:
            f.close();
            print 'channel ', cname , ' has existed!';
            exit();    
    f.write(channel + ' ' + chat.Name + '\n');
    f.close();
    print 'channel ', channel, ' created successfull.';
elif opts.sendto_channel != None and opts.message != None:
    channel = opts.sendto_channel;
    msg = opts.message;
    chat_name = GetChatName(channel);
    if chat_name != None:
        SkypeInit();
        chat = skype.Chat(chat_name);
        chat.SendMessage(msg);
    else:
         print 'channel ', channel_name, ' not find!';
         exit();
elif opts.kick != None and opts.from_channel != None:
    channel = opts.from_channel;
    chat_name = GetChatName(channel);
    if chat_name != None:
        SkypeInit();
        chat = skype.Chat(chat_name);
        chat.Kick(opts.kick);
    else:
        print 'channel ', channel_name, ' not find!';

3.server socket:

listen port 47777
vi skype_socket.c

skype_socket.c
#include #include #include #include #include #include #include #include #define MAXLINE 1024 #define SERV_PORT 47777 int substr(char* dchr,char schr,int begin,int len){ int slen=0; int rc=0; if (begin<=0) begin=1; slen=strlen(schr)-begin; if (slen<=0\|\|len==0){ dchr=NULL; return rc; } if (len<0){ len=-len; if(len>strlen(schr)) begin=1; else if((begin-len)<=0){ len=begin; begin=1; } else { begin-=len; begin++; } } begin–; schr+=begin; int i=0; for(i=0;i dchr++ = schr++; } dchr=0; rc=i; return rc; } int main(int argc,char argv[]){ pid_t pid; struct sockaddr_in servaddr,cliaddr; socklen_t cliaddr_len; int listenfd,connfd; char buf[MAXLINE]; char str[INET_ADDRSTRLEN]; int i,n,m; char delim[10] = “;;”; //default delim int max_size = 800; //default max msg size if(argc == 2 ){ strcpy(delim, argv[1]); } if(argc == 3){ max_size = (int)argv[2]; } listenfd = socket(AF_INET,SOCK_STREAM,0); if( listenfd < 0){ printf(“Create Socket Failed!”); exit(1); } bzero(&servaddr,sizeof(servaddr)); servaddr.sin_family = AF_INET; servaddr.sin_addr.s_addr = htonl(INADDR_ANY); servaddr.sin_port = htons(SERV_PORT); if(bind(listenfd,(struct sockaddr )(&servaddr),sizeof(servaddr)) == -1){ perror(“bind Error”); exit(1); } if(listen(listenfd,20) < 0){ perror(“listen Error”); exit(1); } while(1){ cliaddr_len = sizeof(struct sockaddr_in); connfd = accept(listenfd,(struct sockaddr )(&cliaddr),&cliaddr_len); if(connfd < 0){ perror(“accept Error”); exit(1); } m = fork(); if(m == -1){ perror(“call to fork error”); exit(1); }else if(m == 0){ //sub process while(1){ n = read(connfd,buf,MAXLINE); if(n < 0){ perror(“read Error”); exit(1); } if(n == 0){ //printf(“the other side has been closed.\n”); break; } char p; char channel[20], msg[max_size]; memset(channel, ‘\0′, sizeof(channel)); p = strstr(buf, delim); substr(channel, buf, 0, strlen(buf)-strlen(p)); substr(msg, p, 3, max_size); //printf(“%s\n”, msg); / if(!strcasecmp(channel, “ls”)){ system(“ls -lh /data/binary/ “); } / char cmdfile[10] = “./”; char filename[] = “send.sh”; strcat(cmdfile, filename); char arg[]={filename, channel, msg, NULL}; if( access(filename, F_OK) != 0 ) { //printf(“file %s not find.\n”, filename); exit(1); } //execute shell script if(execvp(cmdfile, arg) < 0){ //printf(“execvp error”); exit(1); } } close(connfd); exit(0); }else{ close(connfd); } } }

skype_socket.c

#include

#define MAXLINE 1024

#define SERV_PORT 47777

int substr(char* dchr,char *schr,int begin,int len){

int slen=0;

int rc=0;

if (begin<=0) begin=1;

slen=strlen(schr)-begin;

if (slen<=0||len==0){

*dchr=NULL;

return rc;

}

if (len<0){

len=-len;

if(len>strlen(schr)) begin=1;

else if((begin-len)<=0){

len=begin;

begin=1;

}

else {

begin-=len;

begin++;

}

begin–;

schr+=begin;

int i=0;

for(i=0;i

*dchr++ = *schr++;

}

*dchr=0;

rc=i;

return rc;

}

int main(int argc,char *argv[]){

pid_t pid;

struct sockaddr_in servaddr,cliaddr;

socklen_t cliaddr_len;

int listenfd,connfd;

char buf[MAXLINE];

char str[INET_ADDRSTRLEN];

int i,n,m;

char delim[10] = “;;”; //default delim

int max_size = 800; //default max msg size

if(argc == 2 ){

strcpy(delim, argv[1]);

}

if(argc == 3){

max_size = (int)argv[2];

}

listenfd = socket(AF_INET,SOCK_STREAM,0);

if( listenfd < 0){

printf(“Create Socket Failed!”);

exit(1);

}

bzero(&servaddr,sizeof(servaddr));

servaddr.sin_family = AF_INET;

servaddr.sin_addr.s_addr = htonl(INADDR_ANY);

servaddr.sin_port = htons(SERV_PORT);

if(bind(listenfd,(struct sockaddr *)(&servaddr),sizeof(servaddr)) == -1){

perror(“bind Error”);

exit(1);

}

if(listen(listenfd,20) < 0){

perror(“listen Error”);

exit(1);

}

while(1){

cliaddr_len = sizeof(struct sockaddr_in);

connfd = accept(listenfd,(struct sockaddr *)(&cliaddr),&cliaddr_len);

if(connfd < 0){

perror(“accept Error”);

exit(1);

}

m = fork();

if(m == -1){

perror(“call to fork error”);

exit(1);

}else if(m == 0){

//sub process

while(1){

n = read(connfd,buf,MAXLINE);

if(n < 0){

perror(“read Error”);

exit(1);

}

if(n == 0){

//printf(“the other side has been closed.\n”);

break;

}

char *p;

char channel[20], msg[max_size];

memset(channel, ‘\0′, sizeof(channel));

p = strstr(buf, delim);

substr(channel, buf, 0, strlen(buf)-strlen(p));

substr(msg, p, 3, max_size);

//printf(“%s\n”, msg);

if(!strcasecmp(channel, “ls”)){

system(“ls -lh /data/binary/ “);

}

char cmdfile[10] = “./”;

char filename[] = “send.sh”;

strcat(cmdfile, filename);

char *arg[]={filename, channel, msg, NULL};

if( access(filename, F_OK) != 0 ) {

//printf(“file %s not find.\n”, filename);

exit(1);

}

//execute shell script

if(execvp(cmdfile, arg) < 0){

//printf(“execvp error”);

exit(1);

}

close(connfd);

exit(0);

}else{

close(connfd);

}

create “send.sh” :

#!/bin/bash
channel=$1
msg=$2
python skype_chat.py --sendto-channel="$channel" --message="(*) $msg"

4. compile skype_socket.c:

gcc -o skype_socket skype_socket.c

5.start socket and test send message by VNC:

on server that skype installed run vncserver:

vncserver

enter password: skype

on your client computer run vnc clien and connect to server, you will open a window and a shell window, then run command:

skype &

then login skype with ROBOT account, and then start socket:

./skype_socket >/dev/null 2>&1 &

run “netstat -tlnp|grep skype”, you can find listen port 47777

create chat channel:

python skype_chat.py --create-channel="AAA" --user="your_skype_account"

6.on any server ,send message to chat chennel:

echo "AAA;;Hello everyone."|nc Server 47777

引自：
http://www.76ku.cn/articles/archives/252

vps推荐之DigitalOcean

fushanlang — Tue, 14 Jan 2014 16:36:42 +0000

作为一个爱折腾的网站”程序猿“，我用过多家vps，由于一般支持paypal 月付，所以基本上都会用两三个月，不行就换另一家。

1.Yard VPS

台湾人开的，有中文支持，貌似也支持支付宝付款，偶尔会有7折，5折，甚至4折的优惠码，这个用过xen plan 768MB的一款vps，后来由于晚上的时候，网站速度慢，所以就没坚持继续使用，换了另外一家PhotonVPS ，后来才知道原来是一家的囧。

2.BudgetVM

这家也还好，openvz的vps 流量限制挺高都超过1T，3T的，xen plan 也很实惠，机房选的是洛杉矶，速度还可以当时用过时间最长的是xen vps plan 是10刀/月。

3.Virpus

找便宜性价比较高的vps是找到这个，当时用是9.5刀/月的 plan,流量1T，现在各大vps都在比流量限制，所以Virpus的流量限制也像BudgetVM一样提高到3T了。

4.SemoWeb

是个老主机商（跟最近这两年雨后春笋般的新主机商比），卖的vps plan很便宜但是用过了才知道，一分钱一分货，如果手头紧，想拿vps练练手还是可以试用一下的。

5.WeLoveServers

这家vps打折打得很凶，在赵荣vps推荐里有很多打折信息，入手了一个openvz的，但是选的德州机房，做外贸站的可以考虑。

6.Linode

如果想省心再省心，但是别想着省钱，Linode绝对是最佳选择，尤其是为了适应新的vps提供商竞争，linode 升级了自己的vps plan之后。

7.DigitalOcean

lucky 7! 用过了这么多vps，终于等到了DigitalOcean，终于不想用再试了。目前已用半年了，操作模式跟普通VPS不太相同，用过Amazon Ec2的同学都会知道，它是按需收费的，它的直接竞争对手是伟大的amazon ec2.

一个1G 内存30G SSD硬盘双核CPU的 droplet（digitalocean 创建的节点称之为droplet 水滴）一个小时是0.7美分，你没看错就是这么便宜。

又一次调试一个第三方功能，公司没测试主机了，我临时创建了一个droplet，搞了2个多小时测试完毕，账单时1.5美分，最有趣的是，DigitalOcean 竟然运行你的billing 余额是负数，这也就意味着你可以先用再付钱， oh my god，就像水电煤气费一样，真的与前面几家预付费的vps很大不同。

有兴趣的同学可以尝试一下。

sysctl.conf网络内核参数说明(转)

fushanlang — Fri, 13 Dec 2013 03:44:05 +0000

下面是我的理解，可能有误，仅供参考。

要调优，三次/四次握手必须烂熟于心。

client                  server
(SYN_SENT)      —> (SYN_RECV)
(ESTABLISHED)   <—
—> (ESTABLISHED)

client(主动)            server
(FIN_WAIT_1)    —>    (CLOSE_WAIT)
(FIN_WAIT_2)    <—
(TIME_WAIT)     <—    (LAST_ACK)
—>    (CLOSED)

大家熟知的 SYN flooding/SYN spoofing 就是在 SYN_RECV 的状态下发起的进攻。这种由于 TCP/IP 协议引起的缺陷只能防治而不好根治，除非换了 TCP/IP。通过下面的方式，可以在一定程度上缓解 DDOS 攻击。

增大半连接的队列，即 backlog queue
人工干预以减少 SYS_RECV 的时间，可以降低第一个重传包的时间或者减少重传的次数

检测 SYN 攻击，可以使用 netstat 命令查看当前的连接类型以及连接数目,如果发现有大量的 SYN_RECV,就值得怀疑了:
$ netstat -tuna | grep :80 | awk '{print $6}' | sort | uniq -c

或者可以通过 wget/curl 从远端实际来测试一下访问的速度：
$ time wget -O /dev/null www.example.com
正常情况下，其 real time 在个位数(s)左右，如果出现长达数十秒乃至几百秒的情况，有可能是此类情况。

最简单的方式是通过 syncookie 实现，Linux 还实现了一种称作 SYN cookie 的机制，开启：
# echo 1 > /proc/sys/net/ipv4/tcp_syncookies

该机制会在服务器收到 SYN 请求后，构造一个带有 ISN(initial sequence number)的 SYN/ACK 包，该 ISN 称为 cookie，其实就是一个哈希。通过此就可以验证客户端的真实性了
注意：SYN cookie 机制不会使用到 backlog queue，因此不必担心 queue 被填满然后服务器主动放弃连接。

使用了 SYN cookie 之后，在 /var/log/kern.log 会发现不少如下的 log，起作用了
possible SYN flooding on port 80. Sending cookies

除了使用 syncookie，还可以修改 backlog queue 来达到目的。backlog queue 是一个用来处理在三次握手过程中带有 SYN 标志的包的数据结构，可以用来控制系统同时处理的最大连接，当达到该阈值后，接下来的请求会被系统丢弃。这需要系统开辟额外的内存来处理进来的包。如果处理的不好会导致系统内存耗尽，导致严重的性能问题。

tcp_max_syn_backlog 定义了 backlog queue 的半连接数量：
# echo 90000 > /proc/sys/net/ipv4/tcp_max_syn_backlog

当客户端发起 SYN 请求后，服务端会立刻发送 SYN+ACK 的回应，该次半连接会到 backlog queue 中，服务器会等待客户返回 ACK，如果在一段时间内没有应答，服务器会重新发送刚刚的 SYN+ACK，经历了几次还是没有回应后，服务器会主动断开此次半连接。
我们就可以修改重发的次数来减少整个半连接的时间：
# echo 3 > /proc/sys/net/ipv4/tcp_synack_retries

——————————————————————————-
|Value|    Time of retransmission |         Total time         |
——————————————————————————-
|1       | in 3rd second                |            9 seconds     |
——————————————————————————-
|2       | in 3rd and 9th second        |            21 seconds   |
——————————————————————————-
|3     | in 3rd, 9th and 21st second |            45 seconds    |
——————————————————————————-
这张表格显示了不同重传次数消耗的总时间

上面属于 passive 连接，也就是客户端连接服务端，还有个相反的 active TCP connection 参数：
# echo 3 > /proc/sys/net/ipv4/tcp_syn_retries

tcp_fin_timeout 参数会通知 kernel 在 FIN_WAIT_2 状态 sockets 的存活时间，根据理解应该是 server 主动终止，像下面这样。

server                        client
(FIN_WAIT_1)    —>    (CLOSE_WAIT)
(FIN_WAIT_2)    <—
(TIME_WAIT)     <—    (LAST_ACK)
—>    (CLOSED)

当处于 CLOST_WAIT 的 client 有意(攻击)/无意(client 突然崩溃等)不发 fin 来继续时，server 会一直停留在 FIN_WAIT_2 状态，造成资源的浪费。
可以适当的减小该时间：
# echo 15 > /proc/sys/net/ipv4/tcp_fin_timeout

跟 tcp_fin_timeout 相关的有 tcp_max_orphans 参数，表示没有跟任何用户文件相关联的 socket 最大个数，超出的将被内核丢弃。
建议该参数只增加不减小，但增加也意味着内存的消耗增加：
# echo 327680 > /proc/sys/net/ipv4/tcp_max_orphans

相关的 tcp_orphans_retries 关闭本端 TCP 连接前的重试次数，默认 7，高负载的 webserver 建议可以减小。这里解释了设置为 0 的情况。

下面这三个参数一起解释：
tcp_tw_recycle
tcp_tw_reuse
tcp_timestamps

其中 tcp_tw_recycle/tcp_tw_reuse 这两个官方的建议保持默认为 0，而 tcp_timestamps 这个参数在特定的情况开启会引起很严重的问题(via 1, 2)。

基本的情况就是，你的客户或者你的服务器在一个 NAT 后面，如果开启这个参数，会导致服务器能收到三次握手的 SYN 但是不会返回任何的 SYN+ACK，其结果是客户无法访问你的网站。可以通过 tcpdump 或者下面的这个查看：
# netstat -s | grep timestamp

tcp_timestamps 是 tcp 协议中的一个扩展项，通过时间戳的方式来检测过来的包以防止 PAWS(Protect Against Wrapped Sequence numbers)，可以提高 tcp 的性能，2.6 的内核默认是打开的。只要 client/server/nat/loadbalancer 不同时打开该选项就不会出现上面的问题。与之相关的包括 tcp_tw_recycle，如果 tcp_timestamps 和 tcp_tw_recycle 同时开启，就会开启时间戳选项，导致上面的问题。如果有上述的网络结构，比较合理的方式是禁用 tcp_tw_recyle 而开启 tcp_timestamps。禁用了 tcp_tw_recycle 其 TIME_OUT sockets 回收功能就没了，可以配合 tcp_tw_reuse 让 TIME_WAIT 降下来。

netdev_max_backlog 这个参数跟 TCP 的传输队列有关,发送队列长度是 txqueuelen ，netdev_backlog 则决定接收队列的长度。
前者通过 ifconfig 命令改变：
# ifconfig eth0 txqueuelen 10000
对于高吞吐的网络而言，默认的 100 肯定是不够的，一个 rrt 为 120ms 的千兆以太网络，可以设置成 10000 以上的值。

对于接受端而言，需要修改的话就涉及到了 /proc/sys/net/core/netdev_max_backlog 了，如果接收包的速度大于内核能处理的速度，则需要队列来维持，此数值表示最大队列值。默认为 1000，如果超过该数值，会引起丢包，根据实际情况增大。

对于网络不是很好的情况，可以开启 tcp_sack 参数。该实现是 TCP 的一个选项，称为 Selective Acknowlegement(SACK)，默认开启，对于千兆网络可以关闭，能提高一定的性能。

keepalive 的情况，Linux 内置支持，只需要开启相应的内核参数就可以了，主要是下面三个：
tcp_keepalive_time 表示 TCP 发出第一个 keepalive 信息之前等待的时间，默认为 7200
tcp_keepalive_intvl keepalive 的时间间隔，默认是 75
tcp_keepalive_probes 触发的次数，默认是 9

ip_local_port_range 128M 内存以上的机器默认是 32768 61000，可以进一步扩大 10240 65535，尽量不要使用 1024 周围的，避免冲突。

以上只是网络内核参数的一小小部分，有待继续补充。

ref:

http://www.frozentux.net/ipsysctl-tutorial/chunkyhtml/tcpvariables.html
http://www.kernel.org/doc/Documentation/networking/ip-sysctl.txt
http://www.symantec.com/connect/articles/hardening-tcpip-stack-syn-attacks
http://www.saview.net/archives/201

HAProxy – route by domain name

fushanlang — Thu, 07 Nov 2013 01:30:07 +0000

——————by Sean Mcgary on September 28, 2013

http://seanmcgary.com/posts/haproxy—route-by-domain-name

I tend to build a lot of web applications in NodeJS using the Express.js webserver. When you have a few of these apps running on one server, you generally want to run them on unique ports and put some kind of proxy in front of them. Nginx works great for this and Apache can be another decent, though more bloated, alternative. Recently I decided to branch out for the sake of variety and to learn something new. HAProxy filled that role.

For the uninformed, HAProxy is more than just a reverse proxy; it’s a high performance load balancer. Sites with lots of traffic will use something like HAProxy to funnel traffic to a cluster of web servers or even balance taffic between database servers. But what happens when we want to route multiple domains (or subdomains) to different hosts or clusters?

Setting up a single proxy
First lets take a look at the basics of proxying to an app server.

# config for haproxy 1.5.x

global
log 127.0.0.1 local0
log 127.0.0.1 local1 notice
maxconn 4096
user haproxy
group haproxy
daemon

defaults
log global
mode http
option httplog
option dontlognull
option forwardfor
option http-server-close
stats enable
stats auth someuser:somepassword
stats uri /haproxyStats

frontend http-in
bind :80
default_backend web-app-cluster

backend web-app-cluster
balance leastconn
option httpclose
cookie JSESSIONID prefix
server node1 10.0.0.1:8080 cookie A check
server node2 10.0.0.2:8080 cookie A check
server node3 10.0.0.3:8080 cookie A check
So this is a pretty basic config that will loadbalance across 3 application servers, each of which is on a unqiue IP and probably on its own dedicated machine. Generally you’ll also want to run your load balancer(s) on a different server.

So what does this all mean? global and defaults should be pretty self-explanatory, then we have a frontend and abackend. The frontend, as you can see, tells HAProxy what to bind to and defines a default backend. There are a lot of things that can be specified in the front end and you can also have multiple frontend definitions (for example, if you wanted to provide an unsecure route running on port 80 and SSL on port 443 and have different, or the same, backends for each). We’ll go over some other options in the multiple domain example.

Diving into multiple domains and ACLs
Now lets take a look at how to route to multiple domains based on matching specific domain names.

# config for haproxy 1.5.x

global
log 127.0.0.1 local0
log 127.0.0.1 local1 notice
maxconn 4096
user haproxy
group haproxy
daemon

defaults
log global
mode http
option httplog
option dontlognull
option forwardfor
option http-server-close
stats enable
stats auth someuser:somepassword
stats uri /haproxyStats

frontend http-in
bind *:80

# Define hosts
acl host_bacon hdr(host) -i ilovebacon.com
acl host_milkshakes hdr(host) -i bobsmilkshakes.com

## figure out which one to use
use_backend bacon_cluster if host_bacon
use_backend milshake_cluster if host_milkshakes

backend baconcluster
balance leastconn
option httpclose
option forwardfor
cookie JSESSIONID prefix
server node1 10.0.0.1:8080 cookie A check
server node1 10.0.0.2:8080 cookie A check
server node1 10.0.0.3:8080 cookie A check

backend milshake_cluster
balance leastconn
option httpclose
option forwardfor
cookie JSESSIONID prefix
server node1 10.0.0.4:8080 cookie A check
server node1 10.0.0.5:8080 cookie A check
server node1 10.0.0.6:8080 cookie A check
So here we are routing between two applications; ilovebacon.com and bobsmilkshakes.com. Each one has its own cluster of app servers that we want to load balance between. Lets take a closer look at where all the magic happens in the frontend.

frontend http-in
bind *:80

# Define hosts
acl host_bacon hdr(host) -i ilovebacon.com
acl host_milkshakes hdr(host) -i bobsmilkshakes.com

## figure out which one to use
use_backend bacon_cluster if host_bacon
use_backend milshake_cluster if host_milkshakes
If you’ve ever used nginx or Apache as reverse proxies, youd generally set things up using virtual hosts. HAProxy uses the notion of access control lists (acl) which can be used to direct traffic.

After we bind to port 80, we set up two acls. The hdr (short for header) checks the hostname header. We also specify -i to make sure its case insensitive, then provide the domain name that we want to match. You could also setup acls to match routes, file types, file names, etc. If you want to know more, feel free to check the docs. So now we effectively have two variables; host_bacon and host_milkshakes. Then we tell HAProxy what backend to use by checking to see if the variable is true or not. One other thing that we could do after the use_backend checks is specify a default_backend like we did in the first example to act as a catch-all to traffic hitting our load balancer that doesn’t match either of the domain names.

convert mysql table engine myisam to innodb

fushanlang — Sat, 26 Oct 2013 12:14:57 +0000

#!/bin/bash if [ $# -ne 1 ]; then echo "usage: convert.sh database" exit 1 fi date db=$1 echo "Convert database $db" ; mysql -B -N -e "SELECT TABLE_NAME, ENGINE FROM information_schema.TABLES where TABLE_SCHEMA = '$db' and engine='myisam'" |awk '{print $1}'| while read table; \ do \ echo "+ Converting Table $table"; \ mysql . . . → Read More: convert mysql table engine myisam to innodb

浮山狼de博客 » linux

Linux Skype Robot

Skype Robot in Ubuntu

skype linux 机器人

vps推荐之DigitalOcean

sysctl.conf网络内核参数说明(转)

Related articles across the web

HAProxy – route by domain name

convert mysql table engine myisam to innodb