[Golang] Go 1.16 中關於go get和go install的變動

 

[前言]

其實Go 1.16已經 Release 很久了，但最近發現關於 go get 的行為跟以前不一樣並且多了 go install 這個 tool，所以本篇記錄一下需要注意的地方。

[關於go get和go install的變動]

我目前Golang的版本如下:

[React] 從無到有建立全新的 React 應用程式

[前言]

本篇內容將提供快速的指引，包含相關需安裝的套件，從無到有建立全新的 React 應用程式( single-page application, SPA)

[安裝]

請先下載 node.js 打包檔於 https://nodejs.org/en/

本次範例是使用 node version v16.17.0 (.tar.gz file) 

安裝步驟如下:

[Tracee] Tracee 研究筆記 (一)

 [前言]

Tracee 是一個用 於 Linux 的執行時安全和取證工具。它使用 Linux eBPF 技術在執行時跟蹤系統和應用程式，並分析收集的事件以檢測可疑的行為模式。本篇對於Tracee這open source project進行了編譯與初步測試，在此做個筆記以防忘記。後續將針對源碼進行分析。

Github 位置為: https://github.com/aquasecurity/tracee

[Tracee相關文件資源]

網路上已經有不少的相關文件資源可以參考，在此不重覆贅述，如下所示：

eBPF 安全專案 Tracee 初探

深入浅出 eBPF 安全项目 Tracee

falco和tracee的实践

• 裡面有提到 tracee 這種僅使用ebpf系統調用做入侵檢測的技術路線還不夠成熟~

[Golang] Pointer Performance 指標傳遞性能

Pointer Performance 

我在O`REILLY出的一本書 "Go學習手冊"內有看到一個很有趣的段落: 指標傳遞性能 ( Pointer Performance )

我把這段的重點直接整理下來(因為很重要) 如下:

• 無論資料的大小為何，將指標傳入函式的時間都是固定的，大約是1 nanosecond。

• 如果struct夠大，將struct的指標當成輸入參數或是回傳值可以改善性能。

• 回傳指標 vs. 回傳值的行為比較有意思。如果資料結構小於1MB，回傳指標型別其實比回傳值更慢。例如: 100-byte的資料結構大約要花10 nanosecond 來回傳，但是那個資料結構的指標大約要花30 nanosecond。當資料結構超過1MB，性能優勢就會逆轉，回傳10MB的資料大約要花2 millisecond，但是回傳它的指標大約是0.5millisecond再多一些。

[Fun] 重溫DoS時期的遊戲: 殖民帝國 Colonization

重溫DoS時期的遊戲: 殖民帝國 Colonization

這套遊戲盒裝內的說明書、磁碟片(3 1/2吋)等等的相關的東西都有很完整保存下來，不信的話請看下圖:

由於這遊戲是執行在DoS 作業系統上的，所以我們需要在Windows 10上安裝DOS模擬器，並用此模擬器玩遊戲，執行步驟如下:

[用Golang寫小遊戲教學] 第八章 指標

 [前言]

指標語法在C/C++程式語言中是非常重要的用法與功能，它可以讓程式更快速且更高效。Golang保有了指標語法，之後的章節在寫小遊戲時也會用到，所以我們需要了解如何正確地使用它。

[指標快速入手]

透過變數宣告時，需要在型別前面加上 * 符號，代表是指標型態，用來告訴編譯器這變數是某種型別的指標變數。

給值時也要給值的位置，我們在值前面加上 & 符號(位址運算子)。請看下面例子:

[Kubernetes] 如何把 Master Node 改成有 Worker的屬性 (可分配Pods)

使用命令 kubectl taint 可以給節點(Node)增加一個污點。

比如:

kubectl taint nodes node1 key1=value1:NoSchedule

說明: 

給節點 node1 增加一個污點，它的鍵名是 key1，鍵值是 value1，效果是 NoSchedule。這表示只有擁有和這個污點相匹配的容忍度的 Pod 才能夠被分配到 node1 這個節點。

若要移除上述命令所添加的污點，你可以執行：

kubectl taint nodes node1 key1=value1:NoSchedule-

最常用的例子就是把 Master Node 改成有 Worker的屬性

kubectl taint nodes k8s1 node-role.kubernetes.io/master:NoSchedule-

[更新]

在K8S v1.24之後默認kubeadm取消taint，之前版本使用node-role.kubernetes.io/master標籤，在Kubernetes 1.24版本中，label標籤已經修改為node-role.kubernetes.io/control-plane

查看node節點所有標籤

kubectl get nodes --show-labels

我們可以直接查看master節點污點情況

kubectl describe node <node_name> | grep Taints

生成污點

kubectl taint nodes <node_name> node-role.kubernetes.io/control-plane:NoSchedule

取消污點

kubectl taint nodes <node_name> node-role.kubernetes.io/control-plane:NoSchedule-

Reference: 

kubectl 備忘單

https://kubernetes.io/zh/docs/reference/kubectl/cheatsheet/

[Kubernetes] How to use Informer to avoid frequently getting Pod and Service List via clientset.CoreV1()?

How to use Informer to avoid frequently getting Pod and Service List via clientset.CoreV1()?

 [情境]

之前開發Kubernetes相關的系統有遇過這種情況: 

需要不斷的輪詢(Pooling) Kubernetes API 去獲得最新的 Pods 與 Services List，例如是每2秒。但輪詢是比較沒有效率的做法，因為很有極大的可能是，大部分的輪詢結果都是沒有變化的。

 [解決方法]

使用Informer來解決此問題。

[用Golang寫小遊戲教學] 第九章 超簡化的碰撞檢測遊戲

[前言]

我們在 [用Golang寫小遊戲教學] 第三章 初探Ebiten (A dead simple 2D game library for Go)  這章的內容有提到一個連結: 

Golang 简单的碰撞检测游戏（ebiten）

這是一個簡單的碰撞檢測遊戲，遊戲功能如下：

1、空格鍵發射紅色塊，紅色塊遇到左、右、上邊界反彈，遇到下邊界遊戲結束。

2、左右鍵移動白色塊接紅色塊，每接到一次加一分。

3、每5秒鐘隨機生成一個黃色塊，紅色塊觸碰到黃色塊時，黃色塊消失並加十分，黃色塊同時最多存在5個

但，這對於初學者來說還是太難理解其運作方式，我把這個小遊戲再精簡成超簡化的碰撞檢測遊戲，遊戲功能如下：

1、空格鍵發射紅色塊，紅色塊遇到左、右、上與下邊界反彈，遊戲不會自動結束。

2、左上角會顯示紅色塊目前的座標

3、在遊戲中按下空格鍵可以暫停，再按一次繼續。

[超簡化的碰撞檢測遊戲]

這邊會需要將Golang執行環境先準備好，請參考:

[用Golang寫小遊戲教學] 第七章 控制結構

[前言]

車輛需要依照交通規則、號誌與標誌來行駛，紅燈時停止、等待，綠燈直行或是轉彎，行駛速度也須遵守時速上限。在程式的世界中，執行程式的電腦也會遵守程式碼內所撰寫的控制結構來執行。在Golang的控制結構包含: If、Switch與For。

注意: goto 這個控制結構我們先不研究歐!

[ If 陳述式]

Golang的if 陳述式用來控制程式執行符合條件的區塊，以下是 語法：

if condition1 {

// 如果 condition1 是true, 則此區塊會被執行

} else if condition2 {

        // 如果 condition2 是true, 則此區塊會被執行

} else {

       // 如果 condition1 與 condition2 都不是true, 則此區塊會被執行

}

If陳述式內的條件(condition)，可以是產生 true / false 的運算式、變數的值等等。也可以利用 && (and) 或是 || (or) 去做交集或是聯集關係。

請看下列簡單的例子

[用Golang寫小遊戲教學] 第六章 結構 (Struct)

 

[前言]

我們在有些情況會希望把一些資料(有相關性)集結在一個結構內，舉例來說，一張身分證內包含了: 姓名、身份證字號、戶籍地、出生日期、配偶等等的資料，如果我們可以用一種型別可以包含上述這些資料，對於管理資料來說就會方便許多。如果大家有學過C語言的話，就會知道struct 這個複合資料型別。在Golang，就是把在C語言內的struct搬過來使用，並稱之為結構 (Struct)型別。而且，還可以賦予它擁有函數的做法，稱之為Receiver。

注意: 我們暫時不提interface，因為會太複雜ㄡ!

[定義結構(Struct)]

在Golang的定義結構 (Struct) 是使用 type 關鍵字基於 struct 來定義一個新的型別，語法用下列例子說明:

type IdentityCard struct {

myID string

myAge int

}

上述我們定義了一個新的struct型別，名稱是IdentityCard，裡面包含了兩個變數:myID與myAge。但，只是定義新的struct型別還不夠，我們需要宣告變數與初始化它才能使用。關於變數宣告可參考之前的文章: 

[用Golang寫小遊戲教學] 第五章 函式(Function)

 

[前言]

函式(Function) 指的是將一或多段程式碼包裝起來，並且可以定義不給或是給定帶入的參數值，並可以重複使用。在程式開發中，是非常重要且經常使用的特性。因為它可以讓你的程式碼更方便維護與容易理解。

在之前的文章內有一些練習的連結，大家如果有注意到的話，每個練習都有一個func main() 的主程式函式定義，這也是Golang程式開始執行的進入點。

[函式(Function)之定義]

Golang 定義函式時，利用關鍵字func 放在前面，後面接著函式名稱，而需要輸入的參數型別宣告，則是放在名稱之後的小括號內。如果多個參數有同樣的型別，那麼只要最右邊同型別的名別右方加上型別就可以了。所需要回傳的變數前面須加上return關鍵字。

例如: 

[用Golang寫小遊戲教學] 第四章 陣列(Array)與切片(Slice)

[前言]

陣列(Array)就好比是單排座位的列車，座位編號從0開始，共有N個座位且不可增加座位數量。
切片(Slice)很像陣列(Array)，但它是可以增加座位數量。 Slice細節還有關於容量與長度的問題，我們就先忽略它~
所以，這兩種資料結構可以存放一長串的資料，這是在寫小遊戲中非常常使用到的功能。

[陣列(Array)]

陣列(Array)：它的長度是固定的（fixed length），使用語法: " [數量] 型別" 定義。例如: [100]int

它比較沒有彈性，內部存放的資料都必須要有相同的型別(像是整數、字串等等)。

已經學習過變數宣告，我們舉兩個例子(變數宣告與變數短宣告)來宣告變數型別為陣列:

[用Golang寫小遊戲教學] 第一章 Golang開發環境設定

[前言]

工欲善其事，必先利其器。

Golang是個跨作業系統(像是: Windows、Linux、Mac OS等等)與支援多CPU架構(x86、ARM64等等)的程式語言，換句話說，Golang的程式可以透過go command直接在眾多的作業系統與幾種不同的CPU架構下執行。

進一步來說，也可以把Golang程式編譯/或交叉編譯 到不同的作業系統與不同的CPU架構下成為執行檔案，即可直接執行。其內涵不了解沒有關係，這不防礙接下來安裝的步驟。

[安裝Golang]

我這邊只先舉Windows 10的安裝範例，對於Linux或是Mac的作業系統，網路上應該有很多安裝教學可以參考ㄡ~

首先請用點擊下列Golang官方下載網頁:

https://go.dev/dl/

[用Golang寫小遊戲教學] 第二章 基本型別、變數宣告與常數宣告

[前言]

了解"基本型別"與"變數宣告"是開始學習程式語言的第一步。我們其實不需要一次把所有的觀念與知識都學到位，這對於初學者或是小朋友來說太過於複雜，這裡就先介紹比較常見的部分。

這篇的教學還不需要用到本機上安裝的Go來執行，我們會用 The Go Playground (網頁版)來練習。

[變數宣告]

在電腦的世界中，每個程式都需要在記憶體中儲存一些資料，資料被儲存在特定的記憶體位置，變數只是為儲存資料的記憶體位置所取的一個方便的名稱。除了名稱外，每個變數還有關聯的型別。型別用來定義存放的資料是屬於何種型態，像是整數或是字串等等，在後面的段落將說明何為資料型別。

    我們先看一個例子: var myScore int = 100，並參考下圖

[用Golang寫小遊戲教學] 第零章 大綱

[前言]

曾經有位朋友與我討論軟體工程師如何寫好程式(或是開發出好的軟體)，我依稀記得是這樣回答:

"木匠製作椅子為例子來說，他(木匠)本身需要具備身為木匠的能力，例如: 鋸木、裁切、刨木、鑽孔、拋光、上漆等等功夫，接下來透過不斷的實作成品的鍛鍊，可以學習到製作越來越複雜的木工成品，當累積一段時間之後，會有自己的風格與設計架構對於擅長的木工項目。

同理可推，在軟體工程師的角度來說，是須要懂得電腦基本概念、了解作業系統的運行、與熟悉某種程式語言，這是基本功。在不斷的實作過程中累積出自己的實力，才有可能寫出好的程式。"

這樣的回答可能沒有完全說服那位朋友，但是基本功對於一般人來說，會是個門檻與障礙。

對於像是不具備相關背景的大朋友們，可能會有心理障礙而不敢學習寫程式，擔心學習門檻很高或是學不會。對於小朋友們來說，過早就進入複雜的背景知識或是學習太多程式語言的細節，不只無法理解其內容，並且會快速遇到瓶頸而備受打擊，或是失去學習程式的動力與興趣。

[教學內容列表]

[用Golang寫小遊戲教學] 第三章 初探Ebiten (A dead simple 2D game library for Go)

[前言]

Ebiten 官方網站 (The official website)

• Source code ( Github )
• API reference
• Tour (WIP)
• Documents
• Examples ( A lot of examples )
• Blog

用Golang寫小遊戲教學這一系列的內容，將會以一個基於Golang語言的 2D Game Library: Ebiten，對於製作小遊戲來說，感覺簡單又易於使用 。Ebiten 套件原作者是日本人，少量遊戲作品可在 wiki 中找到:　https://github.com/hajimehoshi/ebiten/wiki/Works

很多使用範例可以學習:　

[GCC] Using GCC to create static and shared library ( .so / .a )

[轉貼&修改] https://blog.xuite.net/csiewap/cc/23626229-Using+GCC+to+create+static+and+shared+library+.so 

Library可分成三種，static、shared與dynamically loaded。

1. Static libraries

Static 程式庫用於靜態連結，簡單講是把一堆object檔用ar(archiver)

包裝集合起來，檔名以 `.a' 結尾。優點是執行效能通常會比後兩者快，

而且因為是靜態連結，所以不易發生執行時找不到library或版本錯置而

無法執行的問題。缺點則是檔案較大，維護度較低；例如library如果發

現bug需要更新，那麼就必須重新連結執行檔。

1.1 編譯

編譯方式很簡單，先例用 `-c' 編出 object 檔，再用 ar 包起來即可。

hello.c 

#include
void hello(){ printf("Hello "); }

world.c 

#include
void world(){ printf("world."); }

mylib.h 

void hello();
void world();

$ gcc -c hello.c world.c /* 編出 hello.o 與 world.o */

$ ar rcs libmylib.a hello.o world.o /* 包成 limylib.a */

這樣就可以建出一個檔名為 libmylib.a 的檔。輸出的檔名其實沒有硬性規定，

但如果想要配合 gcc 的 '-l' 參數來連結，一定要以 `lib' 開頭，中間是你要

的library名稱，然後緊接著 `.a' 結尾。

1.2 使用

 main.c 

#include "mylib.h"
int main() {
    hello();
    world();
}

使用上就像與一般的 object 檔連結沒有差別。

$ gcc main.c libmylib.a

也可以配合 gcc 的 `-l' 參數使用

$ gcc main.c -L. -lmylib

`-Ldir' 參數用來指定要搜尋程式庫的目錄，`.' 表示搜尋現在所在的目錄。

通常預設會搜 /usr/lib 或 /lib 等目錄。

`-llibrary' 參數用來指定要連結的程式庫 ，'mylib' 表示要與mylib進行連結

，他會搜尋library名稱前加`lib'後接`.a'的檔案來連結。

$ ./a.out
Hello world.

此時可以用 nm <exe filename> 來顯示symbols (functions, etc.)
(To see which symbols come from static libraries requires running nm against those libraries to get a list of the symbols (functions, etc.) in them, then comparing them to what your list of symbols from nm <exefilename>.)

2. Shared libraries

Shared library 會在程式執行起始時才被自動載入。因為程式庫與執行檔

是分離的，所以維護彈性較好。有兩點要注意，shared library是在程式起始

時就要被載入，而不是執行中用到才載入，而且在連結階段需要有該程式庫

才能進行連結。

首先有一些名詞要弄懂，soname、real name與linker name。

soname 用來表示是一個特定 library 的名稱，像是 libmylib.so.1 。

前面以 `lib' 開頭，接著是該 library 的名稱，然後是 `.so' ，接著

是版號，用來表名他的介面；如果介面改變時，就會增加版號來維護相容度。

real name 是實際放有library程式的檔案名稱，後面會再加上 minor 版號與

release 版號，像是 libmylib.so.1.0.0 。

一般來說，版號的改變規則是(印象中在 APress-Difinitive Guide to GCC中有

提到，但目前手邊沒這本書)，最尾碼的release版號用於程式內容的修正，

介面完全沒有改變。中間的minor用於有新增加介面，但相舊介面沒改變，所以

與舊版本相容。最前面的version版號用於原介面有移除或改變，與舊版不相容

時。

linker name是用於連結時的名稱，是不含版號的 soname ，如: libmylib.so。

通常 linker name與 real name是用 ln 指到對應的 real name ，用來提供

彈性與維護性。

2.1 編譯

shared library的製作過程較複雜。

$ gcc -c -fPIC hello.c world.c

編譯時要加上 -fPIC 用來產生 position-independent code。也可以用 -fpic

參數。 (不太清楚差異，只知道 -fPIC 較通用於不同平台，但產生的code較大

，而且編譯速度較慢)。

$ gcc -shared -Wl,-soname,libmylib.so.1 -o libmylib.so.1.0.0 \

hello.o world.o

-shared 表示要編譯成 shared library

-Wl 用於參遞參數給linker，因此-soname與libmylib.so.1會被傳給linker處理。

-soname用來指名 soname 為 limylib.so.1

library會被輸出成libmylib.so.1.0.0 (也就是real name)

若不指定 soname 的話，在編譯結連後的執行檔會以連時的library檔名為

soname，並載入他。否則是載入soname指定的library檔案。

可以利用 objdump 來看 library 的 soname。

$ objdump -p libmylib.so | grep SONAME

SONAME libmylib.so.1

若不指名-soname參數的話，則library不會有這個欄位資料。

在編譯後再用 ln 來建立 soname 與 linker name 兩個檔案。

$ ln -s libmylib.so.1.0.0 libmylib.so

$ ln -s libmylib.so.1.0.0 libmylib.so.1

2.2 使用

與使用 static library 同。

$ gcc main.c libmylib.so

以上直接指定與 libmylib.so 連結。

或用

$ gcc main.c -L. -lmylib

linker會搜尋 libmylib.so 來進行連結。

如果目錄下同時有static與shared library的話，會以shared為主。

使用 -static 參數可以避免使用shared連結。

$ gcc main.c -static -L. -lmylib

此時可以用 ldd 看編譯出的執行檔與shared程式庫的相依性

$ldd a.out

linux-gate.so.1 => (0xffffe000)

libmylib.so.1 => not found

libc.so.6 => /lib/libc.so.6 (0xb7dd6000)

/lib/ld-linux.so.2 (0xb7f07000)

輸出結果顯示出該執行檔需要 libmylib.so.1 這個shared library。

會顯示 not found 因為沒指定該library所在的目錄，所找不到該library。

因為編譯時有指定-soname參數為 libmylib.so.1 的關係，所以該執行檔會

載入libmylib.so.1。否則以libmylib.so連結，執行檔則會變成要求載入

libmylib.so

$ ./a.out

./a.out: error while loading shared libraries: libmylib.so.1:

cannot open shared object file: No such file or directory

因為找不到 libmylib.so.1 所以無法執行程式。

有幾個方式可以處理。

a. 把 libmylib.so.1 安裝到系統的library目錄，如/usr/lib下

b. 設定 /etc/ld.so.conf ，加入一個新的library搜尋目錄，並執行ldconfig

更新快取

c. 設定 LD_LIBRARY_PATH 環境變數來搜尋library

這個例子是加入目前的目錄來搜尋要載作的library

$ LD_LIBRARY_PATH=. ./a.out

Hello world.

3. Dynamically loaded libraries

Dynamicaaly loaded libraries 才是像 windows 所用的 DLL ，在使用到

時才載入，編譯連結時不需要相關的library。動態載入庫常被用於像plug-ins

的應用。

3.1 使用方式

動態載入是透過一套 dl function來處理。

#include

void *dlopen(const char *filename, int flag);

開啟載入 filename 指定的 library。

void *dlsym(void *handle, const char *symbol);

取得 symbol 指定的symbol name在library被載入的記憶體位址。

int dlclose(void *handle);

關閉dlopen開啟的handle。

char *dlerror(void);

傳回最近所發生的錯誤訊息。

dltest.c

#include
#include
#include
int main() {
    void *handle;
    void (*f)();
    char *error;

    /* 開啟之前所撰寫的 libmylib.so 程式庫 */
    handle = dlopen("./libmylib.so", RTLD_LAZY);
    if( !handle ) {
        fputs( dlerror(), stderr);
        exit(1);
    }

    /* 取得 hello function 的 address */
    f = dlsym(handle, "hello");
    if(( error=dlerror())!=NULL) {
        fputs(error, stderr);
        exit(1);
    }
  /* 呼叫該 function */
    f();
    dlclose(handle);
}

編譯時要加上 -ldl 參數來與 dl library 連結

$ gcc dltest.c -ldl

結果會印出 Hello 字串

$ ./a.out

Hello

關於dl的詳細內容請參閱 man dlopen

--

參考資料:

Creating a shared and static library with the gnu compiler [gcc]

Program Library HOWTO

Makefile

GCC=gcc  

CFLAGS=-Wall   -ggdb   -fPIC  

#CFLAGS=  

   

all:   libfunc  

   

libfunc:func.o   func1.o  

    $(GCC)   -shared   -Wl,-soname,libfunc.so.1   -o  libfunc.so.1.1   $<  

    ln   -sf   libfunc.so.1.1   libfunc.so.1  

    ln   -sf   libfunc.so.1   libfunc.so  

   

%.o:%.c  

    $(GCC)   -c   $(CFLAGS)   -o   $@   $<  

   

clean:  

    rm   -fr   *.o  

    rm   -fr   *.so*  

[xgo] The first phase of hacking xgo

 xgo is a great Go CGO cross compiler that can help users to build the application written in Golang to multi-platforms at the same time. 

For more information in details, please check out these URLs:

https://github.com/karalabe/xgo
https://www.jianshu.com/p/a6047d3f976e

But, without any further study, we probably cannot understand how it works well. So here I just give some information about it. I will use my Github repository as the example:

# Install xgo

$ go get github.com/karalabe/xgo

$ git clone https://github.com/teyenliu/win-shared-example

$ cd win-shared-example

# Use xgo to cross-compile to windows/amd64

$ xgo -targets windows/amd64 github.com/teyenliu/win-shared-example

Then, we finish the cross-compilation for my application
And actually, xgo, this tool, is based on its prebuilt docker image: "karalabe/xgo-latest" to complete the cross-compilation task. We can check the dockerhub for it as well: https://hub.docker.com/r/karalabe/xgo-latest/builds

So, we can directly run this Docker Image to cross-compile my application based on my case as follows:

$ docker run --rm -v /home/liudanny/git/xgo:/build \

-v /home/liudanny/.xgo-cache:/deps-cache:ro \

-e REPO_REMOTE= \

-e REPO_BRANCH= \

-e PACK= \

-e DEPS= \

-e ARGS= \

-e OUT= \

-e FLAG_V=false \

-e FLAG_X=false \

-e FLAG_RACE=false \

-e FLAG_TAGS= \

-e FLAG_LDFLAGS= \

-e FLAG_BUILDMODE=default \

-e TARGETS=windows/amd64 \

-e EXT_GOPATH= \

karalabe/xgo-latest \

github.com/teyenliu/win-shared-example

Furthermore, we can directly run xgo's build.sh to cross-compile my application in the host instead of in in the container:

$ sudo su

# set Golang path

export PATH=$PATH:/usr/local/go/bin

export GOPATH=$HOME/go

export PATH=$PATH:$GOPATH/bin

# rm /deps in advance

rm -rf /deps

# run build.sh

env GO111MODULE=off \

env REPO_REMOTE= \

env REPO_BRANCH= \

env PACK= \

env DEPS= \

env ARGS= \

env OUT= \

env FLAG_V=false \

env FLAG_X=false \

env FLAG_RACE=false \

env FLAG_TAGS= \

env FLAG_LDFLAGS= \

env FLAG_BUILDMODE=default \

env TARGETS=windows/amd64 \

env EXT_GOPATH= \

env BUILD_DEPS=/home/liudanny/git/xgo/docker/base/build_deps.sh \

env BOOTSTRAP_REPO=/home/liudanny/git/xgo/docker/base/bootstrap_repo.sh \

env BOOTSTRAP_PURE=/home/liudanny/git/xgo/docker/base/bootstrap_pure.sh \

env BOOTSTRAP=/home/liudanny/git/xgo/docker/base/bootstrap.sh \

env PATH=/usr/local/go/bin:$PATH \

./build.sh github.com/teyenliu/win-shared-example

Reference:
Golang 交叉编译
Golang交叉编译各个平台的二进制文件
Fyne Cross Compile

The following commands are not succesful to work for cross-compilation

$ CGO_ENABLED=1 CXX="x86_64-w64-mingw32-g++" CXX_FOR_TARGET="x86_64-w64-mingw32-g++" CC="x86_64-w64-mingw32-gcc" CC_FOR_TARGET="x86_64-w64-mingw32-gcc" GOOS=windows GOARCH=amd64 \

go build -ldflags -v -x -installsuffix cgo -o example.exe main.go

$ GOOS=windows GOARCH=amd64 CGO_ENABLED=1 CC=x86_64-w64-mingw32-gcc go build -ldflags -v -x -installsuffix cgo -o example.exe main.go

[Fun] Detecting the license plate and replacing with a given image

Propably two years ago, I studied a ECCV 2018 paper "License Plate Detection and Recognition in Unconstrained Scenarios", and  its GitHub (https://github.com/sergiomsilva/alpr-unconstrained) repository contains the author's implementation. During that time, I had an idea to leveraged its implementation for replacing the license plate with my image. After tryed a couple days, I successed and provided a Python script to detect and replace cars' license plate in the video with a specified image.

I recently commited my modification code and pushed it to my forked repository as follows:
https://github.com/teyenliu/alpr-unconstrained

In this repository, it contains 2 samples which are convenient for users to test.

The way to process a video which will replace any car license plate in the video with a given image content.

$ python license-plate-replacement.py --video cars_mountain_short.mov --replace src/hello.PNG --output output1.avi
$ python license-plate-replacement.py --video cars_mountain.mp4 --replace src/hello.PNG --output output2.avi

The result looks like this:

[Golang] Golang with Cgo 動態連結(dynamic linking) 與 靜態連結(static linking)函式庫範例與筆記 in Windows environment

This post is focusd on how to do dynamic/static linking using Golang with cgo on Windows environment. If you want to see it on Linux environment, please check out another post: 

[Golang] Golang with Cgo 動態連結(dynamic linking) 函式庫範例與筆記 in Linux environment

First of all, thanks to someone who had posted several useful articles describing how to do dynamic linking and static linking using Golang(Go) with Cgo in Windows environment as follows:

P.S: For using this example on Linux environment, you should deal with the build process for the static and dynamic libraries.

在 Windows 環境建置動態連結函式庫 (Dynamic-link library)，使用 MinGW gcc/g++ 以及 CodeBlock

Go with Cgo 靜態連結 (static linking) 函式庫建置範例與筆記
Go with Cgo 動態連結 (dynamic linking) 函式庫建置範例與筆記

[tmux] The most common used tmux commands

 This post can help you quickly learn how to use tmux in just a few minutes.

Get tmux session ready to start (new session)

# new session 

$ tmux new -s {session name}

# or new session without name

$ tmux

# list sessions
$ tmux ls

Split a tmux window into two panes

# <Ctrl+b> + %：split a tmux window into two panes vertically

# <Ctrl+b> + "：split a tmux window into two panes horizontally

# The way to switch to another pane

# <Ctrl + b> + <Arrow keys ← or → >

P.S: If you want to close one of the pane you created, 

you just switch on it and exit it by exit command.

For instance: split a tmux window into two panes vertically

Adjust a splitted pane size

You also are able to ajust  the splitted pane vertically or horizontally.

# The way to adjust a pane

# <Ctrl + b> + <Ctrl + Arrow keys ↔ or ↕ >

For instance: There are 5 panes in the window and I can adjust the currently focused pane.

Attach tmux session or detach it

# <Ctrl+b> + d：Put current session in the background running (detach)

# attach a background session

$ tmux attach-session -t {session name}

# Or

$ tmux a -t {session name}

Delete tmux session

$ tmux kill-session -t {session name}

$ tmux kill-session -t 0

[Golang] The example function of converting Struct or Map data to Map[string]interface{} Type

    I recently encountered a use case that I need to convert my struct or map value to the type of map[string]interface{}. After surveying and studying for a while, I figure out how to deal with this kind of task and the way to do it.

    The following function ConvertStructToMap()  is the example of converting Struct or Map data to Map[string]interface{} Type. It receives the argument as interface type and uses reflect function to check the receiver type is correct and what we want. But, it has a constrain, which if you give a map, and Map's key type must be string.

// ConvertStructToMap()

func ConvertStructToMap(message interface{}) (map[string]interface{}, error) {

msg := reflect.ValueOf(message)

msgtype := msg.Type()

// support Struct

if msgtype.Kind() == reflect.Struct {

// message should be tagged by "codec" or "msg"

kv := make(map[string]interface{})

fields := msgtype.NumField()

for i := 0; i < fields; i++ {

field := msgtype.Field(i)

name := field.Name

if n1 := field.Tag.Get("json"); n1 != "" {

name = n1

} else if n2 := field.Tag.Get("msg"); n2 != "" {

name = n2

}

kv[name] = msg.FieldByIndex(field.Index).Interface()

}

return kv, nil

}

// support map[string]interface{} or map[string]string

if msgtype.Kind() != reflect.Map {

return nil, errors.New("message must be a map")

} else if msgtype.Key().Kind() != reflect.String {

return nil, errors.New("map keys must be strings")

}

// Get the interface{}'s current value

kv := make(map[string]interface{})

for _, k := range msg.MapKeys() {

kv[k.String()] = msg.MapIndex(k).Interface()

}

return kv, nil

}

func main() {

fmt.Println("Hello, playground")

structData := struct { Name string `json:"JsonName"` 

                       Score int `msg:"MsgScore"`} { 

                       "john smith", 30, }

kv, err := ConvertStructToMap( structData )

if err != nil {

    fmt.Println(err)

}

fmt.Println(kv)

}

How to use it? Here we go! You can try it on the Go Playground:
https://play.golang.org/p/TLKBIbSxIQj

or just take a look at the sample as follows:

// The way to use ConvertStructToMap()

func main() {

structData := struct { Name string `json:"JsonName"` 

                       Score int `msg:"MsgScore"`} { 

                       "john smith", 30, }

kv, err := ConvertStructToMap( structData )

if err != nil {

    fmt.Println(err)

}

fmt.Println(kv)

        mapData := make(map[string]int)

        mapData["Score1"] = 100

        mapData["Score2"] = 60

        kv, err = ConvertStructToMap( mapData )

        if err != nil {

    fmt.Println(err)

}

fmt.Println(kv)

}

Run Result==>

map[JsonName:john smith MsgScore:30]
map[Score1:100 Score2:60]