Yqsas Blog

Unity URP Shader PBR 转 BlinnPhong

Mon, 25 Sep 2023 00:00:00 +0000

前言

项目中有一些第三方或者ASE生成的Shader代码，默认都是用的PBR光照，然而大部分材质BlinnPhong光照模型就够用了，尤其在移动端我们可以考虑优化。
如何使用最少的代码，将PBR使用的Metallic流程的材质参数快速转换到BlinnPhong光照呢，今天研究了一会儿效果还行，供大家参考。

Shader

//BlinnPhong额外加强高光，贴近PBR效果。
half4 UniversalFragmentBlinnPhongAddSpecular(InputData inputData, half3 diffuse, half4 specularGloss, half smoothness, half smoothnessPower, half3 emission, half alpha)
{
    // To ensure backward compatibility we have to avoid using shadowMask input, as it is not present in older shaders
    #if defined(SHADOWS_SHADOWMASK) && defined(LIGHTMAP_ON)
    half4 shadowMask = inputData.shadowMask;
    #elif !defined (LIGHTMAP_ON)
    half4 shadowMask = unity_ProbesOcclusion;
    #else
    half4 shadowMask = half4(1, 1, 1, 1);
    #endif

    Light mainLight = GetMainLight(inputData.shadowCoord, inputData.positionWS, shadowMask);

    #if defined(_SCREEN_SPACE_OCCLUSION)
        AmbientOcclusionFactor aoFactor = GetScreenSpaceAmbientOcclusion(inputData.normalizedScreenSpaceUV);
        mainLight.color *= aoFactor.directAmbientOcclusion;
        inputData.bakedGI *= aoFactor.indirectAmbientOcclusion;
    #endif

    MixRealtimeAndBakedGI(mainLight, inputData.normalWS, inputData.bakedGI);

    half3 attenuatedLightColor = mainLight.color * (mainLight.distanceAttenuation * mainLight.shadowAttenuation);
    half3 diffuseColor = inputData.bakedGI + LightingLambert(attenuatedLightColor, mainLight.direction, inputData.normalWS);
    #if defined(_SPECGLOSSMAP) || defined(_SPECULAR_COLOR) || defined(_MASKMAP)
    half3 specularColor = LightingSpecular(attenuatedLightColor, mainLight.direction, inputData.normalWS, inputData.viewDirectionWS, specularGloss, smoothness) * (smoothnessPower * 16);
    #endif

    #ifdef _ADDITIONAL_LIGHTS
    uint pixelLightCount = GetAdditionalLightsCount();
    for (uint lightIndex = 0u; lightIndex < pixelLightCount; ++lightIndex)
    {
        Light light = GetAdditionalLight(lightIndex, inputData.positionWS, shadowMask);
    #if defined(_SCREEN_SPACE_OCCLUSION)
            light.color *= aoFactor.directAmbientOcclusion;
    #endif
        half3 attenuatedLightColor = light.color * (light.distanceAttenuation * light.shadowAttenuation);
        diffuseColor += LightingLambert(attenuatedLightColor, light.direction, inputData.normalWS);
    #if defined(_SPECGLOSSMAP) || defined(_SPECULAR_COLOR) || defined(_MASKMAP)
        specularColor += LightingSpecular(attenuatedLightColor, light.direction, inputData.normalWS, inputData.viewDirectionWS, specularGloss, smoothness) * (smoothnessPower * 16);
    #endif
    }
    #endif

    #ifdef _ADDITIONAL_LIGHTS_VERTEX
    diffuseColor += inputData.vertexLighting;
    #endif

    half3 finalColor = diffuseColor * diffuse + emission;

    #if defined(_SPECGLOSSMAP) || defined(_SPECULAR_COLOR) || defined(_MASKMAP)
    finalColor += specularColor;
    #endif

    return half4(finalColor, alpha);
}

//metallic、smoothness 均为采样后已混合好的结果值
half4 MetallicBlinnPhong(InputData inputData, half3 albedo, half3 specularColor, half metallic, half smoothness, half3 emission, half alpha)
{
    const half smoothnessPower = smoothness;
    smoothness = exp2(10 * smoothness + 1); //SimpleLit做法
    const half oneMinusReflectivity = OneMinusReflectivityMetallic(metallic);
    albedo = albedo * oneMinusReflectivity;
    half3 specular = lerp(kDieletricSpec.rgb, albedo, metallic) * specularColor;

    half4 color = UniversalFragmentBlinnPhongAddSpecular(
        inputData,
        albedo,
        half4(specular.rgb, 0),
        smoothness,
        smoothnessPower,
        emission,
        alpha);
    return color;
}

对比

对比图偷懒就不放了🫣。

我们以 URP 自带的地形着色器 Universal Render Pipeline/Terrain/Lit 举个例子。

修改前：

half4 color = UniversalFragmentPBR(inputData,
                                     albedo,
                                     metallic,
                                     /* specular */ half3(0.0h, 0.0h, 0.0h),
                                     smoothness,
                                     occlusion,
                                     /* emission */ half3(0, 0, 0),
                                     alpha);

修改后

half4 color = MetallicBlinnPhong(
                  inputData,
                  albedo,
                  1,
                  metallic,
                  smoothness,
                  half3(0, 0, 0),
                  alpha);

折腾之 ER-X 编译尝鲜 OpenWrt

Fri, 21 Feb 2020 00:00:00 +0000

EdgeMax 虽然基于debian扩展性比较高，但是鉴于每次修改路由器配置的麻烦，还是刷成熟悉的OpenWrt，毕竟有NAS的情况下，路由器做好自己的网络管理就好了。

准备环境

操作系统推荐 Ubuntu 18.04，避免编译依赖的问题。如果使用 win10，通过 wsl 安装也可具备环境，推荐使用这种方式。
替换国内源

安装所需的依赖

   sudo apt-get -y install git build-essential asciidoc binutils bzip2 gawk gettext git libncurses5-dev libz-dev patch python3 unzip zlib1g-dev lib32gcc1 libc6-dev-i386 subversion flex uglifyjs git-core gcc-multilib p7zip p7zip-full msmtp libssl-dev texinfo libglib2.0-dev xmlto qemu-utils upx libelf-dev autoconf automake libtool autopoint device-tree-compiler

代理工具
- 安装 proxychains4
  
  sudo apt-get install proxychains4
- 配置 proxychains4.conf
  
  sudo vim /etc/proxychains4.conf
  
  socks5 xxx.xxx.xxx.xxx 1080

git 代理配置

 git config --global http.proxy 'socks5://xxx.xxx.xxx.xxx:1080'
 git config --global https.proxy 'socks5://xxx.xxx.xxx.xxx:1080'

 # 取消代理
 git config --global --unset http.proxy
 git config --global --unset https.proxy

编译

自己编译可以只有选择需要的插件和功能，对于内存吃紧的同学来说比较有用，不想折腾的同学可以直接使用官方编译的镜像。 OpenWrt 官方镜像地址：https://downloads.openwrt.org/

以下开始编译步骤：

git clone https://github.com/coolsnowwolf/lede 命令下载好源代码，然后 cd lede 进入目录
./scripts/feeds update -a ./scripts/feeds install -a
对固件功能进行配置 make menuconfig
- Target System 选择 MediaTek Ralink MIPS，Subtarget 选择MT7621 based boards，Target Profile 选择EdgeRouter X
- 选择自用插件、主题等。主题使用
预下载编译过程所需工具
- proxychains4 make download ；此处注意需要配置好 proxychains4
- 如果编译过程中网络问题卡住，可手动下载依赖包到 dl 文件夹：https://sources.openwrt.org/。
- 提供我编译过程总用到的依赖文件，解压后文件放在 lede/dl 路径下即可。需要的同学自取：链接: lede-dl.zip 提取码: tb92。
开始编译：make -j1 V=s（-j1 后面是线程数。第一次编译推荐用单线程，国内请尽量全局科学上网）即可开始编译你要的固件了。如果过程中因为网络问题卡住，也建议加上 proxychains4 代理
编译完成，在 lede/bin/targets/ramips/mt7621 下找到编译生成的文件：openwrt-ramips-mt7621-ubiquiti_edgerouterx-initramfs-kernel.bin,openwrt-ramips-mt7621-ubiquiti_edgerouterx-squashfs-sysupgrade.bin

安装

编译结果从 19.x 版本后不支持生成 tar 版的内核镜像包，实际编译结果是 initramfs-kernel.bin ，据说是由于后续内核超过一定大小的原因。而 bin 类型的内核刷机较复杂，需要连接 TTL 线或者在 uboot 下刷入。所以接下来我们使用一个只需 ssh 的简单的方式，就是在网上找一个 18.x 版本的内核 tar 包，刷入内核成功后，再用 sysupgrade 升级安装系统，sysupgrade 可以使用 .bin 文件。

18.x 的内核 tar 文件，可使用 UBNT-ER-X 刷机教程-openwrt 帖子中的附件。

上传ubnt-erx-squashfs-factory-initramfs.tar到 ERX 原版系统的/tmp 下面
用 ssh 登录进原版系统，输入命令add system image openwrt-ramips-mt7621-ubnt-erx-squashfs-factory-initramfs.tar
输入 reboot 重启路由器
用 ssh 登录路由器，网线连接路由器，默认没有密码，现在应该已经是 openwrt 了，上传 squashfs-sysupgrade.bin 到路由器 /tmp 目录里，再运行 sysupgrade squashfs-sysupgrade.bin 完成后系统会自动重启，等待即可。
再次连上路由器，就可以进入路由器了网页界面了

默认地址：http(s)://192.168.1.1，默认用户root，默认密码 password。

参考链接

Spring Cloud 项目国际化

Sat, 18 May 2019 00:00:00 +0000

Spring Cloud 项目国际化

0. 前言

最近几天给项目做了国际化相关工作，以此记录。

Spring Boot 默认就支持国际化，而且不需要我们过多的做什么配置，只需要在 resources/下定义国际化配置文件即可，注意名称必须以 messages 开头。但是考虑到配置管理以及自定义解析需求，一般还是另外自定义配置类。

原理是读取国际化配置文件，以 编码=内容 为映射记录。当收到一个请求时，使用配置的 LocaleResolver 解析当前请求语言，最后使用 MessageSource 获取编码映射的实际语言内容。

Demo 代码 github 地址：https://github.com/yqsas/spring-cloud-i18n-demo

1. Spring 国际化配置

spring:
  messages:
    encoding: UTF-8
    basename: i18n/messages

2. 国际化语言配置文件

在 resources 下创建 i18n 目录，并在其中新建文件：messages.properties、messages_en_US.properties、messages_zh_CN.properties。，注意以 messages 开头。

配置文件中填写 编码=内容 形式的映射记录。

如： messages_en_US.properties

user.welcome=Welcome

messages_zh_CN.properties

user.welcome=欢迎

3. 自定义语言区域解析器

Spring 在 org.springframework.web.servlet.i18n 包下，提供默认几种语言区域解析器：CookieLocaleResolver、AcceptHeaderLocaleResolver、 FixedLocaleResolver、SessionLocaleResolver 等，几种方式顾名思义，各有用途。

但是在 Spring Cloud 体系中，我们用到 OAuth2 作为鉴权机制，后端无 Session 可用，所以首先排除 SessionLocaleResolver；其次微服务之间接口调用使用的 Feign，无法传递 Cookie，所以也排除 CookieLocaleResolver；并且 AcceptHeaderLocaleResolver 使用 Header 中的 “Accept-Language” 属性来判断客户端语言环境，排除。

最终确定自定义语言区域解析器，使用请求头中自定义属性作为解析依据。

public class LocaleHeaderLocaleResolver implements LocaleContextResolver {

    public static final String LOCALE_REQUEST_ATTRIBUTE_NAME = LocaleHeaderLocaleResolver.class.getName() + ".LOCALE";

    public static final String TIME_ZONE_REQUEST_ATTRIBUTE_NAME = LocaleHeaderLocaleResolver.class.getName() + ".TIME_ZONE";

    @Nullable
    private Locale defaultLocale;
    @Nullable
    private TimeZone defaultTimeZone;

    @Nullable
    private String localeHeadName;

    public void setLocaleHeadName(@Nullable String localeHeadName) {
        this.localeHeadName = localeHeadName;
    }

    @Nullable
    public String getLocaleHeadName() {
        return this.localeHeadName;
    }

    public void setDefaultLocale(@Nullable Locale defaultLocale) {
        this.defaultLocale = defaultLocale;
    }

    @Nullable
    public Locale getDefaultLocale() {
        return this.defaultLocale;
    }

    public void setDefaultTimeZone(@Nullable TimeZone defaultTimeZone) {
        this.defaultTimeZone = defaultTimeZone;
    }

    @Nullable
    protected TimeZone getDefaultTimeZone() {
        return this.defaultTimeZone;
    }

    @Override
    public Locale resolveLocale(HttpServletRequest request) {
        parseLocaleHeaderIfNecessary(request);
        return (Locale) request.getAttribute(LOCALE_REQUEST_ATTRIBUTE_NAME);
    }

    @Override
    public LocaleContext resolveLocaleContext(final HttpServletRequest request) {
        parseLocaleHeaderIfNecessary(request);
        return new TimeZoneAwareLocaleContext() {
            @Override
            @Nullable
            public Locale getLocale() {
                return (Locale) request.getAttribute(LOCALE_REQUEST_ATTRIBUTE_NAME);
            }

            @Override
            @Nullable
            public TimeZone getTimeZone() {
                return (TimeZone) request.getAttribute(TIME_ZONE_REQUEST_ATTRIBUTE_NAME);
            }
        };
    }

    @Override
    public void setLocaleContext(HttpServletRequest request, @Nullable HttpServletResponse response,
                                 @Nullable LocaleContext localeContext) {
        Assert.notNull(response, "HttpServletResponse is required for LocaleHeaderLocaleResolver");

        Locale locale = null;
        TimeZone timeZone = null;
        if (localeContext != null) {
            locale = localeContext.getLocale();
            if (localeContext instanceof TimeZoneAwareLocaleContext) {
                timeZone = ((TimeZoneAwareLocaleContext) localeContext).getTimeZone();
            }
            response.setHeader(getLocaleHeadName(),
                (locale != null ? locale.toString() : "-") + (timeZone != null ? ' ' + timeZone.getID() : ""));
        }
        request.setAttribute(LOCALE_REQUEST_ATTRIBUTE_NAME,
            (locale != null ? locale : determineDefaultLocale(request)));
        request.setAttribute(TIME_ZONE_REQUEST_ATTRIBUTE_NAME,
            (timeZone != null ? timeZone : determineDefaultTimeZone(request)));
    }

    private void parseLocaleHeaderIfNecessary(HttpServletRequest request) {
        if (request.getAttribute(LOCALE_REQUEST_ATTRIBUTE_NAME) == null) {
            Locale locale = null;
            TimeZone timeZone = null;

            String headName = getLocaleHeadName();
            if (headName != null) {
                String localeStr = request.getHeader(headName);
                if (localeStr != null) {
                    String localePart = localeStr;
                    String timeZonePart = null;
                    int spaceIndex = localePart.indexOf(' ');
                    if (spaceIndex != -1) {
                        localePart = localeStr.substring(0, spaceIndex);
                        timeZonePart = localeStr.substring(spaceIndex + 1);
                    }
                    try {
                        locale = (!"-".equals(localePart) ? parseLocaleValue(localePart) : null);
                        if (timeZonePart != null) {
                            timeZone = StringUtils.parseTimeZoneString(timeZonePart);
                        }
                    } catch (IllegalArgumentException ex) {
                        if (request.getAttribute(WebUtils.ERROR_EXCEPTION_ATTRIBUTE) != null) {
                            // Error dispatch: ignore locale/timezone parse exceptions
                        } else {
                            throw new IllegalStateException("Invalid locale Header '" + getLocaleHeadName() +
                                "' with value [" + localeStr + "]: " + ex.getMessage());
                        }
                    }
                }
            }

            request.setAttribute(LOCALE_REQUEST_ATTRIBUTE_NAME,
                (locale != null ? locale : determineDefaultLocale(request)));
            request.setAttribute(TIME_ZONE_REQUEST_ATTRIBUTE_NAME,
                (timeZone != null ? timeZone : determineDefaultTimeZone(request)));
        }
    }

    @Nullable
    protected Locale determineDefaultLocale(HttpServletRequest request) {
        Locale defaultLocale = getDefaultLocale();
        if (defaultLocale == null) {
            defaultLocale = request.getLocale();
        }
        return defaultLocale;
    }

    @Nullable
    protected TimeZone determineDefaultTimeZone(HttpServletRequest request) {
        return getDefaultTimeZone();
    }

    @Nullable
    protected Locale parseLocaleValue(String locale) {
        return StringUtils.parseLocaleString(locale);
    }

    @Override
    public void setLocale(HttpServletRequest request, @Nullable HttpServletResponse response, @Nullable Locale locale) {
        setLocaleContext(request, response, (locale != null ? new SimpleLocaleContext(locale) : null));
    }

}

4. 国际化配置类

使用自定义区域解析类。

@Configuration
public class LocaleConfig {

    private final String LOCAL_HEAD_NAME = "Locale";

    @Bean
    public LocaleResolver localeResolver() {
        LocaleHeaderLocaleResolver localeResolver = new LocaleHeaderLocaleResolver();
        localeResolver.setLocaleHeadName(LOCAL_HEAD_NAME);
        localeResolver.setDefaultLocale(Locale.SIMPLIFIED_CHINESE);
        return localeResolver;
    }

    @Bean
    public WebMvcConfigurer localeInterceptor() {
        return new WebMvcConfigurer() {
            @Override
            public void addInterceptors(InterceptorRegistry registry) {
                LocaleChangeInterceptor localeInterceptor = new LocaleChangeInterceptor();
                localeInterceptor.setParamName(LOCAL_HEAD_NAME);
                registry.addInterceptor(localeInterceptor);
            }
        };
    }
}

5. 其他

配合 Feign 使用，需要 Feign 配置转发请求 Header；
工具类提供静态方法获取当前请求线程时区，以及编码内容映射转换；
前端配合使用用户信息中的 lang 属性，设置当前用户使用的语言，在所有请求头中使用我们自定义属性 “Locale” 与后端交互。

如何开发 fork 的 Golang 项目

Thu, 21 Mar 2019 00:00:00 +0000

如何开发 fork 的 Golang 项目

问题

Go 基于位置的包导入机制，使得我们自己 fork 下来的项目进行二次开发时，会发现 fork 中导入的包路径依旧是源项目路径。于是我如果要正常运行的话就得把对应路径改成自己的 fork repo，接着开发完做 pull request 的时候又得修改回来，这显然是一个错误的做法。

解决方式

打开心仪的源 repo 地址，点击 fork 按钮
go get 源 repo
```
go get github.com/xx/xxxx
```
进入目录
```
cd $GOPATH/src/github.com/xx/xxxx
```

添加 fork 仓库源并更新

git remote add fork git@github.com:xx/xxxx.git

git fetch fork

设置当前分支跟踪远程的 fork 分支
```
git branch -u fork/master
```
在 ide 打开这个目录开始愉快地开发吧 :)

参考

Working with forks in Go

折腾之 Manjaro 安装使用指北

Sun, 03 Mar 2019 00:00:00 +0000

一、前言

记录一下使用 manjaro 的过程，一方面备忘，另一方面希望可以帮助到需要的人，内容持续更新。

二、安装

安装过程简单说，Manjaro 安装非常简单，基本上开箱即用，和其他系统区别不大。

下载 ISO 镜像，官网地址
制作 U 盘启动盘，强烈推荐 Ventoy
U 盘启动安装界面，时区设置为 Asia/Shanghai，语言选择 zh_CN，driver 选择 nonfree。选择 Boot 启动安装；
进入桌面（此时系统还在 U 盘中，可以体验桌面效果），双击桌面 Install Manjaro Linux 进入系统安装，然后一路按自己需求 next；
双系统情况下，注意分区选择自定义分区，然后分配 Manjaro 系统分区挂在为/（内存大不需要 swap 分区，一般使用不需要给/home 独立分区，后期调整系统大小也方便），启动分区选择已存在的 EFI system partition，挂在为/boot/efi，并选择保留（默认选项）。
安装完成后重启系统即可。

三、基本配置

3.1 软件包管理配置

#国内源，可多次尝试选择速度最快的
sudo pacman-mirrors -i -c China -m rank
#系统更新
sudo pacman -Syyu
# 配置 archlinux 软件仓库
sudo vim /etc/pacman.conf

  [archlinuxcn]
  Server = https://mirrors.cloud.tencent.com/archlinuxcn/$arch

  sudo pacman -Sy archlinuxcn-keyring
  # AUR 包管理工具
  sudo pacman -S yay
  # 必备工具
  sudo pacman -S git vim net-tools base-devel
  # 解决双系统时间不同步问题
  timedatectl set-local-rtc true

3.2 zsh/oh-my-zsh

  sudo pacman -S zsh
  # curl 使用代理: curl -x "127.0.0.1:7890"
  sh -c "$(curl -fsSL https://raw.github.com/robbyrussell/oh-my-zsh/master/tools/install.sh)"
  # chsh -s /bin/zsh

  # 必备插件安装
  git clone https://github.com/zsh-users/zsh-completions ${ZSH_CUSTOM:-~/.oh-my-zsh/custom}/plugins/zsh-completions

  git clone https://github.com/zsh-users/zsh-syntax-highlighting.git ${ZSH_CUSTOM:-~/.oh-my-zsh/custom}/plugins/zsh-syntax-highlighting

  git clone https://github.com/zsh-users/zsh-autosuggestions.git ${ZSH_CUSTOM:-~/.oh-my-zsh/custom}/plugins/zsh-autosuggestions

  vim ~/.zshrc
  # edit plugins & save
  plugins=(git zsh-syntax-highlighting docker docker-compose zsh-autosuggestions zsh-completions)

  autoload -U compinit && compinit

3.3 中文输入法

使用fcitx5即可。

配置使用 fcitx 输入法

 sudo vim /etc/profile

 export GTK_IM_MODULE=fcitx5
 export QT_IM_MODULE=fcitx5
 export XMODIFIERS=@im=fcitx5

安装输入法

 sudo pacman -S fcitx5 fcitx5-qt fcitx5-gtk fcitx5-configtool fcitx5-gtk fcitx5-qt
 #拼音输入法
 sudo pacman -S fcitx5-chinese-addons fcitx5-pinyin-zhwiki
 #主题
 sudo pacman -S fcitx5-pinyin-zhwiki fcitx5-material-color

主题设置：前往 Fcitx5设置 -> 配置附加组件 -> 经典用户界面 -> 主题

3.4 必备字体安装

  sudo pacman -S wqy-bitmapfont wqy-microhei \
  wqy-zenhei adobe-source-code-pro-fonts \
  adobe-source-sans-pro-fonts adobe-source-serif-pro-fonts \
  adobe-source-han-sans-cn-fonts ttf-monaco ttf-dejavu ttf-hanazono \
  noto-fonts noto-fonts-cjk noto-fonts-emoji

3.5 双显卡配置

更换默认驱动

 sudo pacman -S virtualgl lib32-virtualgl lib32-primus primus

 # 查看当前已安装驱动
 mhwd -li
 # 卸载不需要的驱动
 sudo mhwd -r pci video-hybrid-intel-nvidia-418xx-bumblebee
 # 安装最新闭源驱动
 sudo mhwd-tui # 选择4

 sudo systemctl enable bumblebeed

用户组设置

 #添加 bumblebee 用户组
 sudo groupadd bumblebee
 #添加当前用户到该组
 sudo gpasswd -a $USER bumblebee

重启电脑

3.6 VPN 客户端配置

系统默认未安装客户端，需要先行安装客户端支持。

L2TP 客户端安装

 # 安装 strongswan  原因：need strongswan (or libreswan) for IPSec support.
 sudo pacman -S strongswan
 # 安装 l2tp 依赖
 yay -S libnm-git
 # 安装 l2tp 客户端，先选 2 一遍安装一些依赖，再选 1 一遍编译安装
 yay -S networkmanager-l2tp

控制命令

 # 获取所有 vpn 连接列表
 nmcli con show
 # 连接一个标记为已断开的网络接口
 nmcli con up <uuid/name>
 # 断开一个网络连接
 nmcli con down <uuid/name>
 # 添加内网路由
 sudo route add -net 10.0.0.0 netmask 255.0.0.0 gw <gateway ip>

四、开发环境

4.1 Docker

  sudo pacman -S docker docker-compose

  # 设置普通用户使用 Docker 不需要使用 sudo
  sudo groupadd docker
  sudo usermod -aG docker $USER

4.2 IDE/编辑器

  # snap
  sudo pacman -S snapd
  sudo systemctl enable --now snapd.socket
  sudo ln -s /var/lib/snapd/snap /snap
  # IDEA
  sudo snap install intellij-idea-ultimate --classic
  # rider
  sudo snap install rider --classic
  # vscode
  sudo pacman -S vscode
  # datagrip 数据库管理
  yay -S datagrip
  sudo pacman -S mysql-workbench

4.3 Java 环境

  sudo pacman -S maven

4.4 Nodejs 环境

  sudo pacman -S nodejs npm

4.5 Ruby+Jekyll

  # Ruby
  sudo pacman -S ruby
  gem install jekyll bundler
  #项目依赖安装：bundle install/update

4.6 其他

  # pip
  yay -S python-pip

五、软件推荐

# 日常
  sudo pacman -S google-chrome

  sudo pacman -S netease-cloud-music
  sudo pacman -S filezilla  # FTP/SFTP

  sudo pacman -S virtualbox  virtualbox-guest-dkms # 选择当前内核对应版本

  sudo pacman -S goldendict # 翻译、取词
    # 不推荐有道词典 高分屏坐标偏移，屏幕取词不便
    # [英汉字典下载](https://github.com/skywind3000/ECDICT/releases)

  # 多平台笔记应用，替代印象笔记
  sudo pacman -S joplin

  sudo pacman -S linuxqq             #qq
  sudo pacman -S deepin-wine-wechat  # 微信

# 开发
  sudo pacman -S tmux

# 办公
  #字体切记采用这种方式安装
  sudo pacman -S ttf-wps-fonts wps-office wps-office-mui-zh-cn

# 装 X
  sudo pacman -S neofetch
    #配合食用：neofetch --ascii_distro arch
  sudo pacman -S screenfetch
    #配合食用：screenfetch -A 'Arch Linux'

# 其他
  sudo pacman -S light # 命令调节亮度
  sudo pacman -S guake # 下拉终端，同类：tilda
  sudo pacman -S sshpass # 指定密码登录ssh： sshpass -p passwd ssh user@xx.xx.xx.xx

六、桌面环境

2019.12 更新： manjaro 官网 Deepin 环境已经消失，不建议继续使用

目前使用过 KDE、Gnome、Deepin 三种桌面环境。KDE 界面特效多、自定义程度高，Gnome 简洁直观，建议大家按需选择。

安装 KDE

 sudo pacman -S plasma kio-extras
 sudo pacman -S kdebase

 sudo pacman -S manjaro-kde-settings sddm-breath-theme manjaro-settings-manager-knotifier manjaro-settings-manager-kcm

 sudo systemctl enable sddm.service --force

七、其他记录

7.1 Hidpi 配置

xorg 配置缩放

参考文档： HiDPI （简体中文）
- 在设置 –> 设备 –> 显示器中，缩放设置为 200%（缩放倍率可以按整数倍率调整，但是容易出现 1 倍太小，2 倍太大的情况）
- 利用 xrandr 微调合适倍率： xrandr --output eDP1 --scale 1.2x1.2
- 命令启动时执行： vim /etc/profile，在文件最后添加上一条命令内容

chrome

 sudo vim /usr/share/applications/google-chrome.desktop

 # 这一行修改
 Exec=/usr/bin/google-chrome-stable %U
 # 添加启动命令参数
 Exec=/usr/bin/google-chrome-stable --force-device-scale-factor=1.7 %U

wine 安装的软件

 WINEPREFIX=~/.deepinwine/<你的 APP 目录> wine winecfg
 #或者
 WINEPREFIX=~/.deepinwine/<你的 APP 目录> deepin-wine winecfg

7.2 科学上网

和windows一样的GUI版本：

  yay -S clash-for-windows-bin
  #启动
  sudo cfw  --no-sandbox

使用 docker 启动 clash 的方式，由 clash 进行全局代理，根据自定义规则选择上网方式。

启动 clash 容器准备 docker-compose 文件：vim ~/.config/clash/docker-compose.yml

  version: '3'
  services:
    clash:
      image: dreamacro/clash
      volumes:
        - ~/.config/clash/config.yaml:/root/.config/clash/config.yaml
        # dashboard volume
        # - ./ui:/ui
      ports:
        - "7890:7890"
        - "7891:7891"
        # If you need external controller, you can export this port.
        # - "9090:9090"
      restart: always
      # When your system is Linux, you can use `network_mode: "host"` directly.
      network_mode: "host"
      container_name: clash

启动： docker-compose -f ~/.config/clash/docker-compose.yml up -d

准备配置文件

vim ~/.config/clash/config.yaml

配置文件模板请参考：Hackl0us/SS-Rule-Snippet/clash.yaml

根据模板，添加代理服务器配置，策略组需要增加一个名称为Proxy的配置。
配置全局代理

进入系统设置 –> 网络 –> 网络代理 –> 手动。
- http(s) 配置： 127.0.0.1:7890
- socket 配置： 127.0.0.1:7891

7.3 常用命令

  lspci|grep -i net #查看网卡信息

  systemctl list-unit-files --state=enabled #查看已经启用的服务
  systemd-analyze critical-chain xxx.service #查看关联性服务启动耗费时间
  systemd-analyze blame #按时间排序，查看服务启动耗费时间

  # git 代理设置，推荐放到 .zshrc 中作为常用命令
  git-proxy(){
    git config --global http.proxy socks5://127.0.0.1:1080
    git config --global https.proxy socks5://127.0.0.1:1080
  }
  git-noproxy(){
    git config --global --unset http.proxy
    git config --global --unset https.proxy
  }

我的 Markdown 写作最佳实践

Mon, 11 Feb 2019 00:00:00 +0000

我的 Markdown 使用方式记录

Markdown 为广大群众喜爱的原因有许多，最关键的就是其文本格式可以随处发布，并保持原始排版。但是五花八门的 Markdown 编辑器实现各异，不规范地使用语法容易导致迁移平台时排版混乱。

以下都是基于个人喜爱，仅供参考。

各平台使用 印象笔记、Joplin 同步素材以及没有完成的文章
写作使用 Visual Studio Code 软件
插件安装 Markdown All in One

根据需要配置想要的版本和功能支持，快捷键丰富，效率神器。预览效果也不错。
语法检查安装 markdownlint ，实时语法检查对于 IDE 来说是必备的
使用 Pangu-Markdown 插件检查中文排版

检查中英文混排效果是否符合通用实践。
导出 pdf 安装 Markdown PDF 插件
图床使用七牛云

译 | 揭秘 Docker 镜像

Tue, 29 Jan 2019 00:00:00 +0000

原文：What’s in a Docker image?

Docker 镜像里有什么？这是一个非常好的问题，在知道答案之前，Docker 镜像看起来似乎非常神秘。现在我不仅仅将告诉你答案，并且还会告诉你我是如何得到这个答案的。

从 Dockerfile 到镜像

在开始之前，我假设你对于 Dockerfile 已经非常熟悉：Docker 通过 Dockerfile 说明如何构建一个镜像。下面是一个例子。

FROM ubuntu:15.04
COPY app.py /app
CMD python /app/app.py

Dockerfile 里的每一行都是 Docker 如何构建镜像的说明。它将使用ubuntu:15.04作为基础，然后复制一个 python 脚本。CMD指令是关于运行容器时要做什么的指令（将镜像转换为正在运行的进程），暂时按下不表。

然后我们运行docker build . 并检查输出。

$ docker build -t my_test_image .
Sending build context to Docker daemon  364.2MB
Step 1/3 : FROM ubuntu:15.04
 ---> d1b55fd07600
Step 2/3 : COPY app.py /app/
 ---> 44ab3f1d4cd6
Step 3/3 : CMD python /app/app.py
 ---> Running in c037c981012e
Removing intermediate container c037c981012e
 ---> 174b1e992617
Successfully built 174b1e992617
Successfully tagged my_test_image:latest

首先看最后两行，我们已经成功构建了一个 Docker 镜像，可以通过标识符174b1e992617（这个值是镜像内容的 SHA256 哈希片段）找到对应镜像。

我们已经得到了最终镜像，但是控制台输出独立步骤的 ID 又代表了什么？d1b55fd07600 和44ab3f1d4cd6? 它们也是镜像吗？确实如此。如果我们从 Dockerfile 中删除第 2 步（COPY app.py / app），Docker 仍然可以成功构建它作为镜像。所以镜像构建过程中的每一步，我们都得到一个镜像。

这告诉我们镜像可以建立在彼此之上！当考虑Dockerfile中的FROM指令只是说明要在哪个镜像上构建时，这是有道理的。

一个镜像的结构必须以这样一种方式来组织，但是如何组织呢？接下来我们将把 docker 镜像拆开来看看。

导出镜像并解压缩

为了简化使用，镜像可以作为独立文件导出，这便于我们看到镜像里面的内容。

docker save my_test_image > my_test_image

查看导出的文件。

$ file my_test_image
my_test_image: POSIX tar archive

一个压缩包！我们解压看看。

$ mkdir unpacked_image
$ tar -xvf my_test_image -C unpacked_image
x 174b1e9926177b5dfd22981ddfab78629a9ce2f05412ccb1a4fa72f0db21197b.json
x 28441336175b9374d04ee75fdb974539e9b8cad8fec5bf0ff8cea6f8571d0114/
x 28441336175b9374d04ee75fdb974539e9b8cad8fec5bf0ff8cea6f8571d0114/VERSION
x 28441336175b9374d04ee75fdb974539e9b8cad8fec5bf0ff8cea6f8571d0114/json
x 28441336175b9374d04ee75fdb974539e9b8cad8fec5bf0ff8cea6f8571d0114/layer.tar
x 4631663ba627c9724cd701eff98381cb500d2c09ec78a8c58213f3225877198e/
x 4631663ba627c9724cd701eff98381cb500d2c09ec78a8c58213f3225877198e/VERSION
x 4631663ba627c9724cd701eff98381cb500d2c09ec78a8c58213f3225877198e/json
x 4631663ba627c9724cd701eff98381cb500d2c09ec78a8c58213f3225877198e/layer.tar
x 6c91b695f2ed98362f511f2490c16dae0dcf8119bcfe2fe9af50305e2173f373/
x 6c91b695f2ed98362f511f2490c16dae0dcf8119bcfe2fe9af50305e2173f373/VERSION
x 6c91b695f2ed98362f511f2490c16dae0dcf8119bcfe2fe9af50305e2173f373/json
x 6c91b695f2ed98362f511f2490c16dae0dcf8119bcfe2fe9af50305e2173f373/layer.tar
x c4f8838502da6456ebfcb3f755f8600d79552d1e30beea0ccc62c13a2556da9c/
x c4f8838502da6456ebfcb3f755f8600d79552d1e30beea0ccc62c13a2556da9c/VERSION
x c4f8838502da6456ebfcb3f755f8600d79552d1e30beea0ccc62c13a2556da9c/json
x c4f8838502da6456ebfcb3f755f8600d79552d1e30beea0ccc62c13a2556da9c/layer.tar
x cac0b96b79417d5163fbd402369f74e3fe4ff8223b655e0b603a8b570bcc76eb/
x cac0b96b79417d5163fbd402369f74e3fe4ff8223b655e0b603a8b570bcc76eb/VERSION
x cac0b96b79417d5163fbd402369f74e3fe4ff8223b655e0b603a8b570bcc76eb/json
x cac0b96b79417d5163fbd402369f74e3fe4ff8223b655e0b603a8b570bcc76eb/layer.tar
x manifest.json
x repositories

我们从manifest.json文件开始研究。

[
  {
    "Config": "174b1e9926177b5dfd22981ddfab78629a9ce2f05412ccb1a4fa72f0db21197b.json",
    "RepoTags": [
      "my_test_image:latest"
    ],
    "Layers": [
      "cac0b96b79417d5163fbd402369f74e3fe4ff8223b655e0b603a8b570bcc76eb/layer.tar",
      "28441336175b9374d04ee75fdb974539e9b8cad8fec5bf0ff8cea6f8571d0114/layer.tar",
      "4631663ba627c9724cd701eff98381cb500d2c09ec78a8c58213f3225877198e/layer.tar",
      "c4f8838502da6456ebfcb3f755f8600d79552d1e30beea0ccc62c13a2556da9c/layer.tar",
      "6c91b695f2ed98362f511f2490c16dae0dcf8119bcfe2fe9af50305e2173f373/layer.tar"
    ]
  }
]

清单（manifest）文件是一段元数据，它准确描述了该镜像中的内容。我们可以看到该镜像被标记为my_test_image，并且还有一些叫做Layers和Config的内容（层与配置）。

JSON 配置文件的前 12 个字符正好与我们构建过程中看到的镜像 ID 相同，这可不是巧合哦。

$ cat 174b1e9926177b5dfd22981ddfab78629a9ce2f05412ccb1a4fa72f0db21197b.json
{
  "architecture": "amd64",
  "config": {
    "Hostname": "d2d404286fc4",
    "Domainname": "",
    "User": "",
    "AttachStdin": false,
    "AttachStdout": false,
    "AttachStderr": false,
    "Tty": false,
    "OpenStdin": false,
    "StdinOnce": false,
    "Env": [
      "PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
    ],
    "Cmd": [
      "/bin/sh",
      "-c",
      "python /app/app.py"
    ],
    "ArgsEscaped": true,
    "Image": "sha256:44ab3f1d4cd69d84c9c67187b378b1d1322b5fddf4068c11e8b11856ced7efc0",
    "Volumes": null,
    "WorkingDir": "",
    "Entrypoint": null,
    "OnBuild": null,
    "Labels": null
  },
  "container": "c037c981012e8f03ac5466fcdda8f78a14fb9bb5ee517028c66915624a5616fa",
  "container_config": {
    "Hostname": "d2d404286fc4",
    "Domainname": "",
    "User": "",
    "AttachStdin": false,
    "AttachStdout": false,
    "AttachStderr": false,
    "Tty": false,
    "OpenStdin": false,
    "StdinOnce": false,
    "Env": [
      "PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
    ],
    "Cmd": [
      "/bin/sh",
      "-c",
      "#(nop) ",
      "CMD [\"/bin/sh\" \"-c\" \"python /app/app.py\"]"
    ],
    "ArgsEscaped": true,
    "Image": "sha256:44ab3f1d4cd69d84c9c67187b378b1d1322b5fddf4068c11e8b11856ced7efc0",
    "Volumes": null,
    "WorkingDir": "",
    "Entrypoint": null,
    "OnBuild": null,
    "Labels": {}
  },
  "created": "2018-11-01T03:19:16.8517953Z",
  "docker_version": "18.09.0-ce-beta1",
  "history": [
    {
      "created": "2016-01-26T17:48:17.324409116Z",
      "created_by": "/bin/sh -c #(nop) ADD file:3f4708cf445dc1b537b8e9f400cb02bef84660811ecdb7c98930f68fee876ec4 in /"
    },
    {
      "created": "2016-01-26T17:48:31.377192721Z",
      "created_by": "/bin/sh -c echo '#!/bin/sh' > /usr/sbin/policy-rc.d \t&& echo 'exit 101' >> /usr/sbin/policy-rc.d \t&& chmod +x /usr/sbin/policy-rc.d \t\t&& dpkg-divert --local --rename --add /sbin/initctl \t&& cp -a /usr/sbin/policy-rc.d /sbin/initctl \t&& sed -i 's/^exit.*/exit 0/' /sbin/initctl \t\t&& echo 'force-unsafe-io' > /etc/dpkg/dpkg.cfg.d/docker-apt-speedup \t\t&& echo 'DPkg::Post-Invoke { \"rm -f /var/cache/apt/archives/*.deb /var/cache/apt/archives/partial/*.deb /var/cache/apt/*.bin || true\"; };' > /etc/apt/apt.conf.d/docker-clean \t&& echo 'APT::Update::Post-Invoke { \"rm -f /var/cache/apt/archives/*.deb /var/cache/apt/archives/partial/*.deb /var/cache/apt/*.bin || true\"; };' >> /etc/apt/apt.conf.d/docker-clean \t&& echo 'Dir::Cache::pkgcache \"\"; Dir::Cache::srcpkgcache \"\";' >> /etc/apt/apt.conf.d/docker-clean \t\t&& echo 'Acquire::Languages \"none\";' > /etc/apt/apt.conf.d/docker-no-languages \t\t&& echo 'Acquire::GzipIndexes \"true\"; Acquire::CompressionTypes::Order:: \"gz\";' > /etc/apt/apt.conf.d/docker-gzip-indexes"
    },
    {
      "created": "2016-01-26T17:48:33.59869621Z",
      "created_by": "/bin/sh -c sed -i 's/^#\\s*\\(deb.*universe\\)$/\\1/g' /etc/apt/sources.list"
    },
    {
      "created": "2016-01-26T17:48:34.465253028Z",
      "created_by": "/bin/sh -c #(nop) CMD [\"/bin/bash\"]"
    },
    {
      "created": "2018-11-01T03:19:16.4562755Z",
      "created_by": "/bin/sh -c #(nop) COPY file:8069dbb6bfc301562a8581e7bbe2b7675c2f96108903c0889d258cd1e11a12f6 in /app/ "
    },
    {
      "created": "2018-11-01T03:19:16.8517953Z",
      "created_by": "/bin/sh -c #(nop)  CMD [\"/bin/sh\" \"-c\" \"python /app/app.py\"]",
      "empty_layer": true
    }
  ],
  "os": "linux",
  "rootfs": {
    "type": "layers",
    "diff_ids": [
      "sha256:3cbe18655eb617bf6a146dbd75a63f33c191bf8c7761bd6a8d68d53549af334b",
      "sha256:84cc3d400b0d610447fbdea63436bad60fb8361493a32db380bd5c5a79f92ef4",
      "sha256:ed58a6b8d8d6a4e2ecb4da7d1bf17ae8006dac65917c6a050109ef0a5d7199e6",
      "sha256:5f70bf18a086007016e948b04aed3b82103a36bea41755b6cddfaf10ace3c6ef",
      "sha256:9720cebfd814895bf5dc4c1c55d54146719e2aaa06a458fece786bf590cea9d4"
    ]
  }
}

这是一个非常大的 JSON 文件，但通过这个文件你可以看到这里有很多不同的元数据。尤其重要的是，这关乎如何将此镜像转换为可以运行的容器的元数据（要运行的命令和要添加的环境变量）。

镜像如洋葱

镜像与洋葱都有很多层。但是什么是层？接下来我选取cac0b96b79417d5163fbd402369f74e3fe4ff8223b655e0b603a8b570bcc76eb一探究竟，因为这是『层』列表中的第一个。

$ ls cac0b96b79417d5163fbd402369f74e3fe4ff8223b655e0b603a8b570bcc76eb
VERSION   json      layer.tar

又有一个压缩文件 (tarfile)，继续解压并打开看看。

$ tree -L 1
.
├── bin
├── boot
├── dev
├── etc
├── home
├── lib
├── lib64
├── media
├── mnt
├── opt
├── proc
├── root
├── run
├── sbin
├── srv
├── sys
├── tmp
├── usr
└── var

这就是 Docker 镜像的最大秘密，它由文件系统的不同视图组成！这一层有很多内容，用户空间二进制文件在/bin, 共享函数库在/usr/lib，你可以在一个标准 Ubuntu 文件系统中看到的几乎一切内容。那么每个层究竟包含什么？通过它可以知道哪些层来自基本镜像，以及哪些层是由我们添加的。

使用我们之前做的相同的过程，但在ubuntu:15.04我可以看到这些层。

cac0b96b79417d5163fbd402369f74e3fe4ff8223b655e0b603a8b570bcc76eb
28441336175b9374d04ee75fdb974539e9b8cad8fec5bf0ff8cea6f8571d0114
4631663ba627c9724cd701eff98381cb500d2c09ec78a8c58213f3225877198e
c4f8838502da6456ebfcb3f755f8600d79552d1e30beea0ccc62c13a2556da9c

这些都属于 ubuntu 基本镜像，也就是来自FROM ubuntu:15.04命令。由此我们预测my_test_image图像的最顶层6c91b695f2ed98362f511f2490c16dae0dcf8119bcfe2fe9af50305e2173f373应该来自命令COPY app.py / app /。

$ tree
.
└── app
    └── app.py

果不其然，所有内容都是我们对文件系统所做的更改，仅仅添加了 app.py 文件。

视图展示

从视觉上看，我们的图像是这样的。

加分回合

手动完成这项工作需要付出相当大的时间，但至少这样做一次是有益的。如果您希望将来分析镜像，可以使用开源工具 dive。

容器是如何运行的

现在我们已经理解了一个 Docker 镜像是什么，那么 Docker 是如何把它变成一个运行中的容器呢？

文件系统

每个容器都有它们自己的文件系统视图，Docker 获取镜像所有的层，并使它们层叠在一起，以呈现为文件系统的一个视图。这个技术称为 Union Mounting，Docker 支持 Linux 上的几个 Union Mount 文件系统，主要是 OverlayFS 和 AUFS。

但是这并非全部，容器是短暂的，容器运行时对文件系统的更改不应该在容器停止时保存。一种方法是将整个镜像复制到其他地方，这样更改不会影响原始文件。这不是非常高效，替代方法（以及 Docker 所做的）是在容器中的文件系统的最顶部添加一个瘦读/写层，进行更改。如果您需要对下面某个层中的文件进行更改，则需要将该文件复制到进行更改的顶层。这称为 Copy-On-Write。当容器停止运行时，将丢弃最顶层的文件系统层。

来自 Docker 文档的下图显示了最顶层。

其他

启动容器的完整过程超出了本文的范围。在文件系统之后，镜像除了用于配置接下来的一些步骤的元数据之外，没有许多其他用途。完整而言，要创建一个正在运行的容器，我们需要使用命名空间 Namespaces 来控制进程可以看到的内容（文件系统，进程，网络，用户等）；使用 cgroups 来控制进程可以使用的资源（内存，CPU，网络等）；安全功能来控制进程可以执行的操作（Capabilities, AppArmor, SELinux, Seccomp）。

n2n-v2 局域网穿透指南

Sun, 30 Dec 2018 00:00:00 +0000

日前，由于项目需要一部分人驻场外地开发，于是项目组之前在同一局域网内开发的协作模式受到影响，导致注册中心、网关等公共服务无法连接各业务服务端点。最直接的解决方式就是再造局域网环境，之前接触过花生壳，也了解 udp 打洞基本概念，于是想到可以两地远程连入一个自建局域网。

经过一番了解，了解到相关实现工具选择不少，如n2n、softether、frp、ZeroTier等。

鉴于 n2n 多平台、p2p 通信以及部署简单等特性，选择使用 n2n。最终实现效果是各地电脑 vpn 拨入指定 n2n 服务器，即可处于同一局域网，实现内网穿透效果。

Linux 安装

编译安装

环境

 yum install -y openssl-devel
 yum install -y cmake
 yum install -y net-tools
 yum install -y gcc gcc-c++

 git clone https://github.com/meyerd/n2n.git

 cd n2n/n2n_v2

编译

 mkdir build
 cd build
 cmake ..
 make && make install

服务端启动（supernode）

服务端运行，需要开放对应 UDP 端口 7654

supernode -l 7654

将服务端也作为客户端启动，加入到虚拟网络中。

edge -a 192.168.10.11 -c group -k password -l server-ip:port

客户端启动（edgenode）

edge -a 192.168.10.21 -c group -k password -l server-ip:port

查看状态

查看 edge 或者 supernode 进程

ps -ef | grep supernode

ps -ef | grep edge

macOS 安装

截止目前 Mojave 10.14.2 版本可用。

安装 n2n

brew install openssl
brew install cmake

git clone https://github.com/meyerd/n2n.git
cd n2n/n2n_v2
#编辑 n2n_v2/CMakeLists.txt 文件，找到 set(CMAKE_C_FLAGS 和 set(CMAKE_CXX_FLAGS 两行，在这两行的里面括号里面的部分，加入编译参数：
vi CMakeLists.txt

-I/usr/local/opt/openssl/include -L/usr/local/opt/openssl/lib

#在 n2n_v2 创建 build 文件夹，cmake .. 来创建 Makefile, 然后 make

sudo make install
sudo chmod -R 777 /usr/local/sbin

安装虚拟网卡

brew cask install tuntap

#查看是否有如下两个内核扩展
ls /Library/Extensions/tap.kext
ls /Library/Extensions/tun.kext
#校验内核扩展的参数
find /Library/Extensions/{tap,tun}.kext/ -type f | xargs shasum
#加载内核扩展
sudo /sbin/kextload /Library/Extensions/tap.kext
sudo /sbin/kextload /Library/Extensions/tun.kext

客户端启动

sudo edge -a 192.168.10.31 -c group -k password -l server-ip:port

Windows 安装

windows 版说明

n2n_v2 版本 windows 客户端需要自己编译，编译出来的 edge.exe 替换安装软件里的 edge2.exe 即可。

以下提供个人编译出的客户端程序：

windows 版 n2n: n2n-gui 安装包
最新 windows 版编译 (2018-12-30)：edge2

编译环境 windows10-64 位，各位也可参考下文自行编译。

windows 版本编译

参考：P2P 网络-n2n 穿墙-全平台

过程：

安装 cmake
安装 Mingw
编译 exe 文件
重命名并替换软件安装中的 edg2.exe 文件

参考

P2P 网络-n2n 穿墙-全平台

n2n 内网穿透打洞部署全过程

Mac OS High Sierra 上编译 N2N 通过

Spring Security OAuth2 表单登录 refresh token 未生成问题

Tue, 25 Dec 2018 00:00:00 +0000

之前集成 OAuth2 后，一直用默认的登录路径/oauth/token，但是需要把客户端和客户端密钥明文传输，且登录成功后，后端后续处理不方便。于是打算使用自定义 formLogin 路径方式提供登录。

过程

配置 AuthorizationServerConfig，使用 redisTokenStore 配置 DefaultTokenServices，使用 JdbcClientDetailsService 配置 ClientDetailsService。
新建 FormAuthenticationConfig，配置 HttpSecurity http 访问 formLogin 方法，并自定义登录路径 loginProcessingUrl 为/oauth/form，再自定义 successHandler 类（继承 SavedRequestAwareAuthenticationSuccessHandler），处理登录成功后手动生成 token 并返回给前端。
问题出现：使用 TokenServices.createAccessToken，手动创建出来的 token 无 refreshToken，而使用/oauth/token 端点则正常。

问题定位

追踪 TokenServices.createAccessToken 方法，发现其中生成 refresh_token 的方法，是通过判断 ClientDetail 里的认证方式是否包含 refresh_token 来确定：

protected boolean isSupportRefreshToken(OAuth2Request clientAuth) {
        if (this.clientDetailsService != null) {
            ClientDetails client = this.clientDetailsService.loadClientByClientId(clientAuth.getClientId());
            return client.getAuthorizedGrantTypes().contains("refresh_token");
        } else {
            return this.supportRefreshToken;
        }
    }

确认项目中 ClientDetail 中确实包含 refresh_token 后，再断点追踪，才知道 DefaultTokenServices 里面的 clientDetailsService 为空，导致无法获取客户端详情 clientDetails。

解决方式

配置 DefaultTokenServices 时

设置 clientDetailsService
设置 supportRefreshToken 为 true（默认 false)，如此所有 token 都需要创建 refreshToken

@Bean
@Primary
public DefaultTokenServices tokenServices() {
    DefaultTokenServices defaultTokenServices = new DefaultTokenServices();
    defaultTokenServices.setTokenStore(redisTokenStore);
    //1
    defaultTokenServices.setClientDetailsService(this.clientDetails());
    //2
    defaultTokenServices.setSupportRefreshToken(true);
    return defaultTokenServices;
}

1 和 2 都不可缺少，因为调用刷新 token 方法的时候，DefaultTokenServices 是直接取 supportRefreshToken 值判断，而非调用 isSupportRefreshToken 方法判断，而 supportRefreshToken 默认 false。这算是一个 bug 吧。

总结

直接拿开源项目并不十分可靠，需要仔细理解细节；
有 BUG，看源码。