#user  nobody;
worker_processes  1;

#error_log  logs/error.log;
#error_log  logs/error.log  notice;
#error_log  logs/error.log  info;

#pid        logs/nginx.pid;


events {
    worker_connections  1024;
}


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

    #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;

    server {
        listen       80;
        server_name  localhost;

        #charset koi8-r;

        #access_log  logs/host.access.log  main;

        location / {
            root   html;
            index  index.html index.htm;
        }

        #error_page  404              /404.html;

        # redirect server error pages to the static page /50x.html
        #
        error_page   500 502 503 504  /50x.html;
        location = /50x.html {
            root   html;
        }

        # proxy the PHP scripts to Apache listening on 127.0.0.1:80
        #
        #location ~ \.php$ {
        #    proxy_pass   http://127.0.0.1;
        #}

        # pass the PHP scripts to FastCGI server listening on 127.0.0.1:9000
        #
        #location ~ \.php$ {
        #    root           html;
        #    fastcgi_pass   127.0.0.1:9000;
        #    fastcgi_index  index.php;
        #    fastcgi_param  SCRIPT_FILENAME  /scripts$fastcgi_script_name;
        #    include        fastcgi_params;
        #}

        # deny access to .htaccess files, if Apache's document root
        # concurs with nginx's one
        #
        #location ~ /\.ht {
        #    deny  all;
        #}
    }


    # another virtual host using mix of IP-, name-, and port-based configuration
    #
    #server {
    #    listen       8000;
    #    listen       somename:8080;
    #    server_name  somename  alias  another.alias;

    #    location / {
    #        root   html;
    #        index  index.html index.htm;
    #    }
    #}


    # HTTPS server
    #
    #server {
    #    listen       443 ssl;
    #    server_name  localhost;

    #    ssl_certificate      cert.pem;
    #    ssl_certificate_key  cert.key;

    #    ssl_session_cache    shared:SSL:1m;
    #    ssl_session_timeout  5m;

    #    ssl_ciphers  HIGH:!aNULL:!MD5;
    #    ssl_prefer_server_ciphers  on;

    #    location / {
    #        root   html;
    #        index  index.html index.htm;
    #    }
    #}

}

stream {

map $ssl_preread_server_name $name {
    backend.example.com      backend;
    default                  backend2;
}

upstream backend {
    server 192.168.0.3:12345;
    server 192.168.0.4:12345;
}

upstream backend2 {
    server 127.0.0.1:8071;
}

server {
    listen      12346;
    proxy_pass  $name;
    ssl_preread on;
}
}

127.0.0.1 backend.example.com

docker run -p 2181:2181 -d ttbb/zookeeper:stand-alone

https://github.com/hezhangjian/maven-demo/tree/master/demo-zookeeper/src/main/java/com/github/hezhangjian/demo/zookeeper

package com.github.hezhangjian.demo.zookeeper;

import com.github.hezhangjian.javatool.util.CommonUtil;
import com.github.hezhangjian.javatool.util.LogUtil;
import lombok.extern.slf4j.Slf4j;
import org.apache.curator.RetryPolicy;
import org.apache.curator.framework.CuratorFramework;
import org.apache.curator.framework.CuratorFrameworkFactory;
import org.apache.curator.retry.RetryNTimes;
import org.apache.zookeeper.CreateMode;

import java.util.concurrent.TimeUnit;

/**
 * @author hezhangjian
 */
@Slf4j
public class TempOrderTest {

    public static void main(String[] args) throws Exception {
        LogUtil.configureLog();
        RetryPolicy retryPolicy = new RetryNTimes(3, 5000);
        CuratorFramework client = CuratorFrameworkFactory.builder().connectString("127.0.0.1:2181")
                .sessionTimeoutMs(10000).retryPolicy(retryPolicy).build();
        client.start();
        String path = client.create().withMode(CreateMode.EPHEMERAL_SEQUENTIAL).forPath("/seq", "World".getBytes());
        log.info("path is [{}]", path);
        CommonUtil.sleep(TimeUnit.HOURS, 1);
    }

}

package com.github.hezhangjian.demo.zookeeper;

import com.github.hezhangjian.javatool.util.CommonUtil;
import com.github.hezhangjian.javatool.util.LogUtil;
import lombok.extern.slf4j.Slf4j;
import org.apache.curator.RetryPolicy;
import org.apache.curator.framework.CuratorFramework;
import org.apache.curator.framework.CuratorFrameworkFactory;
import org.apache.curator.retry.RetryNTimes;
import org.apache.zookeeper.CreateMode;

import java.util.concurrent.TimeUnit;

/**
 * @author hezhangjian
 */
@Slf4j
public class TempOrderTest2 {

    public static void main(String[] args) throws Exception {
        LogUtil.configureLog();
        RetryPolicy retryPolicy = new RetryNTimes(3, 5000);
        CuratorFramework client = CuratorFrameworkFactory.builder().connectString("127.0.0.1:2181")
                .sessionTimeoutMs(10000).retryPolicy(retryPolicy).build();
        client.start();
        String path = client.create().creatingParentsIfNeeded().withMode(CreateMode.EPHEMERAL_SEQUENTIAL).forPath("/temp/seq", "World".getBytes());
        log.info("path is [{}]", path);
        client.close();
    }

}

ip route add default  proto static scope global \
nexthop  via <gw_1> weight 1 \
nexthop  via <gw_2> weight 1

ip route add default  proto static scope global \
 nexthop  dev <if_1> weight 1 \
 nexthop  dev <if_2> weight 1

1. 客户简单地发送到网关
2. 网关发送到后端处理服务
3. 后端处理服务接收到请求，做简单校验后直接返回成功/失败，异步发送消息到Kafka
4. 消费者从Kafka拉取消息，拉取到消息就提交，不考虑写入数据库的成功或失败
5. 写入到数据库

1. 客户发送到网关不考虑结果，即时我们返回失败，也不处理。显然会丢失消息，我们的系统并不能保证100%的消息处理成功
2. 网关在与业务处理服务的TCP的四次挥手阶段处理异常，导致业务处理成功(已发送到Kafka)，但实际返回客户失败。导致消息重复
3. 消费者拉取到消息后，写入数据库失败，但此时offset已提交。消息丢失

1. 消费者从Kafka消费到一批数据，但并不commit提交
2. 消费者向数据库prepare这批数据
3. 消费者向Kafka提交Offset
4. 消费者向数据库commit这批数据

1.消费者向Kafka提交Offset后，突然宕机，重启的消费者无法恢复事务，消息丢失
2.消费者commit失败，消息丢失

1. 消费者从Kafka消费到一批数据，但并不commit提交
2. 消费者向数据库prepare这批数据
3. 消费者向数据库commit这批数据
4. 消费者向Kafka提交Offset

客户发送到网关不考虑结果，即时我们返回失败，也不处理。显然会丢失消息，

3. 后端处理服务接收到请求，做简单校验后直接返回成功/失败，异步发送消息到Kafka

1. 网关在与业务处理服务的TCP的四次挥手阶段处理异常，导致业务处理成功(已发送到Kafka)，但实际返回客户失败。导致消息重复
2. 业务处理服务与网关的TCP的四次挥手阶段处理异常，导致业务处理成功，但实际返回客户失败
3. 客户的系统重启，成功应答并没有成功传达

容器内打印路径: /opt/sh/logs/file.log
容器外挂载路径: /opt/log/rabbitmq/file.log

curl 127.0.0.1:9200/filebeat-7.5.1-2020.01.23-000001/_search?pretty
收集上来的数据存在hostname字段,能区分代表单个实例的信息.

import lombok.extern.slf4j.Slf4j;

import java.net.InetAddress;

@Slf4j
public class PingTestMain {

    public static void main(String[] args) throws Exception {
        String testIp = System.getProperty("TestIp");
        InetAddress inetAddress = InetAddress.getByName(testIp);
        boolean addressReachable = inetAddress.isReachable(500);
        log.info("address is reachable is {}", addressReachable);
    }

}

iptables -A INPUT -p tcp --dport 7 -j DROP

setcap cap_net_raw+ep /usr/java/jdk-13.0.1/bin/java

java: error while loading shared libraries: libjli.so: cannot open shared object file: No such file or directory

tcp dst port 135 //tcp协议，目标端口为135的数据包
ether host <Ethernet host> //让wireshark只抓取这个地址相关的以太网帧
ether dst <Ethernet host>
ether src <Ethernet src>
ether broadcast //Wireshark只抓取所有以太网广播流量
ether multicast //只抓取多播流量
ether proto <protocol>
vlan <vlan_id>

ip #只抓取ipv4流量
ipv6
host 10.0.0.2
dest host <host>
src host <host>
broadcast #ip广播包
multicast #ip多播包
ip proto <protocol code> #ip数据包有多种类型，比如TCP(6), UDP(17) ICMP(1)

port <port>
dst port <port>
src port <port>
tcp portrange <p1>-<p2>

tcpdump -w hzj.pcap -s0 -iany port 1028

sudo apt-add-repository ppa:wireshark-dev/stable
sudo apt-get update
sudo apt-get install wireshark
#以root权限启动
sudo wireshark

public abstract class Buffer{
  public final int capacity()
  public final int position()
  public final Buffer position (int newPosition)
  public final int limit ()
  public final Buffer limit(int newLimit)
  public final Buffer mark()
  public final Buffer reset()
  public final Buffer clear()
  public final Buffer flip()
  public final Buffer rewind()
  public final int remaining()
  public final boolean hasRemaining();
  public abstract boolean isReadOnly();
}

buffer.mark();
buffer.position(5);
buffer.reset()
//就可以写成下面这样
buffer.mark().position(5).reset();

public abstract class ByteBuffer extends Buffer implements Comparable {
  //列出了一部分api
  public abstract byte get();
  public abstract byte get(int index);
  public abstract ByteBuffer put(byte b);
  public abstract ByteBuffer put(int index, byte b);
}

buffer.put((byte)'H').put((byte)'e').put((byte)'l').put((byte)'l').put((byte)'o');

buffer.put(0,(byte)'M').put((byte)'w');

buffer.limit(buffer.position()).position(0);
//上面的调用，等同于如下的方法
buffer.flip();

//利用hasRemaining()方法判断Buffer中是否还有数据
for(int i=0;buffer.hasRemaining();i++) {
  myByteArray[I]=buffer.get();
}
//上面的方法未必高效，循环体中每次循环都要进行一次判断
//你可以使用remaining()方法，返回剩余的数目
int count = buffer.remaining();
for(int i=0;buffer.count;i++) {
  myByteArray[I]=buffer.get();
}
//如果你对Buffer有着惊人的控制，那么不进行数据检查将会是最快的

public class BufferFillDrain {
    //原代码作者 Ron Hitchens (ron@ronsoft.com)
    private static int index = 0;

    private static String[] strings = {
            "Hello, this is ZhangJian",
            "He likes Eminem",
            "Put the dick in the dust",
            "And? Fuck the world?",
            "Lyrics are great",
            "But what I like more",
            "is the spirit"
    };

    public static void main(String[] args) throws Exception {
        CharBuffer buffer = CharBuffer.allocate(100);
        while( fillBuffer(buffer)) {
            buffer.flip();
            drainBuffer(buffer);
            buffer.clear();
        }
    }

    private static void drainBuffer (CharBuffer buffer) {
        while (buffer.hasRemaining()) {
            System.out.print(buffer.get());
        }

        System.out.println("");
    }

    private static boolean fillBuffer(CharBuffer buffer) {
        if(index >= strings.length) {
            return false;
        }
        String string = strings[index++];
        for(int i=0;i<string.length();i++) {
            buffer.put(string.charAt(i));
        }
        return true;
    }

}

buffer.compact();

public abstract class CharBuffer extends Buffer implements CharSequence,Comparable {
  //这只是方法的一部分
  public CharBuffer get (char[] dst)
  public CharBuffer get(char[] dst, int offset, int length)

  public final CharBuffer put (char[] src)
  public CharBuffer put(char[] src, int offset, int length)
  public CharBuffer put(char[] src)
  
  public final CharBuffer put(String src)
  public CharBuffer put(String src, int start, int end)

char[] bigArray = new char[1000];
//获取buffer剩余输出
int length = buffer.remaining();
//如果length不够填充整个数组
buffer.get(bigArray,0,length);
processData(bigArray,length);

char[] smallArray = new char[10];

while (buffer.hasRemaining()) {
    int length = Math.min(buffer.remaining(), smallArray.length);
    buffer.get(smallArray, 0, length);
    processData(smallArray, length);
}

dstBuffer.put(srcBuffer) 等价于 dstBuffer.put(srcBuffer.get());

public abstract class CharBuffer extends Buffer implements CharSequence, Comparable {
  public static CharBuffer allocate (int capacity)
  
  public static CharBuffer wrap(char[] array)
  public static CharBuffer wrap(char[] array, int offset, int length)

  public final boolean hasArray()
  public final char[] array()
  public final int arrayOffset()
}

//分配一个CharBuffer可以容纳100个字符
CharBuffer charBuffer = CharBuffer.allocate(100);
//如果你想要使用你自己的数组
char[] myArray = new char[100];
CharBuffer charBuffer = CharBuffer.wrap(myArray);

CharBuffer charBuffer = CharBuffer.wrap(myArray,12,42);

public abstract class CharBuffer extends Buffer implements CharSequence, Comparable {
  public abstract CharBuffer duplicate();
  public abstract CharBuffer asReadOnlyBuffer();
  public abstract CharBuffer slice();
}

CharBuffer buffer = CharBuffer.allocate(8);
buffer.position(3).limit(5);
CharBuffer sliceBuffer = buffer.slice();

public final class ByteOrder {
  public static final ByteOrder BIG_ENDIAN
  public static final ByteOrder LITTLE_ENDIAN

  public static ByteOrder nativeOrder()
  public String toString()
}

public final ByteOrder order()

public final ByteOrder order()
public final ByteOrder order(ByteOrder bo)

public abstract class ByteBuffer extends Buffer implements Comparable {
  public static ByteBuffer allocate(int capacity)
  public static ByteBuffer allocateDirect(int capacity)
  public abstract boolean isDirect();
}

public interface Channel {
  public boolean isOpen();
  public void close() throws IOException;
}

public interface ReadableByteChannel extends Channel {
  public int read (ByteBuffer dst) throws IOException;
}
public interface WritableByteChannel extends Channel {
  public int write(ByteBuffer src) throws IOException;
}
public interface ByteChannel extends ReadableByteChannel, WritableByteChannel {
}

public interface ReadableByteChannel extends Channel {
  public int read (ByteBuffer dst) throws IOException;
}
public interface WritableByteChannel extends Channel {
  public int write(ByteBuffer src) throws IOException;
}
public interface ByteChannel extends ReadableByteChannel, WritableByteChannel {
}

public static final int BUFFER_SIZE = 16*1024;

public static void main(String[] args) throws IOException {

    ReadableByteChannel source = Channels.newChannel(System.in);
    WritableByteChannel dest = Channels.newChannel(System.out);
    //call one of copy method
    source.close();
    dest.close();
}

public static void channelCopy1 (ReadableByteChannel src, WritableByteChannel dest) throws IOException{
    ByteBuffer buffer = ByteBuffer.allocate(BUFFER_SIZE);
    while (src.read(buffer)!=-1) {
        //准备好数据
        buffer.flip();

        //向通道中写入数据，可能阻塞
        dest.write(buffer);

        //调用compact方法，可以确保数据都被dest处理
        buffer.compact();
    }
    //还有可能有数据剩余，此时只是没有可读数据了而已
    while (buffer.hasRemaining()) {
        dest.write(buffer);
    }
    buffer.clear();
}

public static void channelCopy2 (ReadableByteChannel src, WritableByteChannel dest) throws IOException {
    ByteBuffer buffer = ByteBuffer.allocate(BUFFER_SIZE);
    while (src.read(buffer)!=-1) {
        buffer.flip();
        while (buffer.hasRemaining()) {
            dest.write(buffer);
        }
        buffer.clear();
    }
}

public interface ScatteringByteChannel extends ReadableByteChannel {
  public long read(ByteBuffer[] dsts) throws IOException;
  public long read(ByteBuffer[] dots,int offset, int length) throws IOException;
}

public interface GatheringByteChannel extends WritableByteChannel {
  public long write(ByteBuffer[] srcs) throws IOException;
  public long write(ByteBuffer[] srcs, int offset, int length) throws IOException;
}

ByteBuffer header = ByteBuffer.allocateDirect(10);
ByteBuffer body = ByteBuffer.allocateDirect(80);
ByteBuffer[] buffers = {header, body};
int bytesRead = channel.read(buffers);

body.clear();
body.put("FOO".getBytes()).flip();
header.clear();
header.putShort(TYPE_FILE).putLong(body.limit()).flip();
long bytesWritten = channel.write(buffers);

public class FileLock implements AutoClosable{
  public FileChannel channel()
  public long position()
  public long size()
  public boolean isShared()
  public boolean overlaps(long position, long size)
  public boolean isValid()
  public void release()
  public String toString()
}

RandomAccessFile randomAccessFile = new RandomAccessFile("filename","r");
//设置position
randomAccessFile.seek(1000);
//创建一个channel
FielChannel fileChannel = randomAccessFile.getChannel();
System.out.println(fileChannel.position());//打印1000
randomAccessFile.seek(500);
System.out.println(fileChannel.position());//500
fileChannel.position(200);
System.out.println(randomAccessFile.getFilePointer());//200

public abstract class FileChannel extends AbstractChannel implements ByteChannel, GatheringByteChannel, ScatteringByteChannel {
  
  public final FileLock lock()
  public abstract FileLock lock (long position, long size, boolean shared)

  public final FileLock tryLock()
  public abstract FileLock tryLock(long position, long size, boolean shared)
}

FileLock lock = fileChannel.lock();
try{
  <perform read/write/whatever on channel>
} catch (IOException e) {
  <handle unexcepted exception>
} finally {
  lock.release();
}

    private static final int SIZEOF_INT = 4;
    private static final int INDEX_START = 0;
    private static final int INDEX_COUNT = 10;
    private static final int INDEX_SIZE = INDEX_COUNT * SIZEOF_INT;

    private ByteBuffer buffer = ByteBuffer.allocate(INDEX_SIZE);
    private IntBuffer indexBuffer = buffer.asIntBuffer();
    private Random rand = new Random();

    public static void main(String[] args) throws Exception{
        boolean writer = false;
        String filename;
        //决定你所做的操作，读或者写
        if(args.length!=2) {
            System.out.println("Usage: [-r|-w] filename");
            return;
        }
        writer = args[0].equals("-w");//true写false读
        filename = args[1];
        RandomAccessFile raf = new RandomAccessFile(filename,writer?"rw":"r");
        FileChannel fc = raf.getChannel();//通过RandomAccessFile拿到fileChannel
        LockTest lockTest = new LockTest();
        if(writer) {
            lockTest.doUpdates(fc);
        } else {
            lockTest.doQueries(fc);
        }
    }

    void doQueries (FileChannel fc) throws Exception {
        //如果是单次操作的话，没有这个循环，这里使用这个循环，为了多次
        //运行程序，发现锁的工作原理
        while (true) {
            FileLock lock = fc.lock(INDEX_START,INDEX_SIZE,true);
            int reps = rand.nextInt(60) + 20;
            for(int i=0; i<reps; i++) {
                int n = rand.nextInt(INDEX_COUNT);
                int position = INDEX_START + (n*SIZEOF_INT);
                buffer.clear();
                fc.read(buffer,position);
                int value = indexBuffer.get(n);
                Thread.sleep(100);//doing some work
            }
            lock.release();
            Thread.sleep(rand.nextInt(3000)+500);
        }
    }

    void doUpdates (FileChannel fc) throws Exception {
        while (true) {
            FileLock lock = fc.lock(INDEX_START,INDEX_SIZE,false);
            updateIndex(fc);
            lock.release();
            Thread.sleep(rand.nextInt(2000)+500);
        }
    }

    private int idxval = 1;

    private void updateIndex (FileChannel fc) throws Exception{
        indexBuffer.clear();
        for(int i=0; i<INDEX_COUNT; i++) {
            idxval++;
            indexBuffer.put(idxval);
            Thread.sleep(500);
        }
        buffer.clear();
        fc.write(buffer,INDEX_START);
    }


}