Googleが毎年やっているSanta Trackerを使ってサンタさんが今どこでプレゼントを配っているかを逐次報告してくれるようにしてみました。

https://github.com/usk81/til/tree/master/go/santa-stalker

Santa TrackerのAPI

• 自分の現在地
• サンタの目的地一覧
  • URLの2019を変えればその年のデータになるようです
  • enをjaに変えれば地名を英語から日本語に変更できます

色々諦めたこと

• 緯度経度と距離から近くにいるよとかしたかった
  • 近くの定義が難しかったのでやめました
• 住んでいるエリアにサンタさんが来たら、santa claus is comin to townをSpotifyでながす
  • Google Assistant APIの実装が必要そうなので1日では無理だったのでやめました

コード

main.go

package main

import (
    "context"
    "fmt"
    "time"

    "github.com/ikasamah/homecast"
)

const (
    // 自分の住んでいる場所に一番近いエリア
    myID     = "tokyo"
    santaURL = "https://firebasestorage.googleapis.com/v0/b/santa-tracker-firebase.appspot.com/o/route%2Fsanta_en.json?alt=media&2019b"
)

var jst *time.Location

func init() {
    var err error
    jst, err = time.LoadLocation("Asia/Tokyo")
    if err != nil {
        jst = time.FixedZone("Asia/Tokyo", 9*60*60)
    }
}

func main() {
    tk, err := GetTracker(santaURL)
    if err != nil {
        panic(err)
    }

    fmt.Println("Start stalking")
    for {
        r := tk.Current(time.Now())
        // なんかも同じメッセージを喋り続けられるとうざいので、ステータスが変わるまでキャッシュする 
        // キャッシュされてない場合のみメッセージを話させる
        if !r.IsCache {
            if r.Destination.ID == myID {
                // サンタさん キタ━━━(ﾟ∀ﾟ)━━━!! 
                googlehome("Santa Claus is coming to town!! Santa Claus is coming to town!! Santa Claus is coming to town!!")
                // 自分の街についたら通知をやめる
                break
            } else {
                if r.Status == statusDeliver {
                    // 今サンタさんがプレゼントを配っている場所を通知
                    googlehome(fmt.Sprintf("Santa Claus is in %s, %s\n", r.Destination.City, r.Destination.Region))
                }
            }
        }
        // ループを繰り返す感覚が短すぎるのでちょっとスリープ
        time.Sleep(5 * time.Second)
    }
    fmt.Println("finish")
}

// Google Homeデバイスに任意のメッセージ話させる
func googlehome(msg string) {
    fmt.Println(msg)
    ctx := context.Background()
    devices := homecast.LookupAndConnect(ctx)
    for _, device := range devices {
        device.Speak(ctx, msg, "en")
    }
}

tracker.go

package main

import (
    "encoding/json"
    "net/http"
    "time"
)

const (
    statusTakeOff = "Takeoff"
    statusMove    = "Move"
    statusDeliver = "Deliver"
    statusFinsish = "Finsish"
)

type APIResponse struct {
    Status       string        `json:"status"`
    Language     string        `json:"language"`
    TimeOffset   int           `json:"timeOffset"`
    Fingerprint  string        `json:"fingerprint"`
    Destinations []Destination `json:"destinations"`
}

type Destination struct {
    ID                string   `json:"id"`
    Arrival           int64    `json:"arrival"`
    Departure         int64    `json:"departure"`
    Population        int      `json:"population"`
    PresentsDelivered int      `json:"presentsDelivered"`
    City              string   `json:"city"`
    Region            string   `json:"region"`
    Location          Location `json:"location"`
}

type Location struct {
    Lat float64 `json:"lat"`
    Lng float64 `json:"lng"`
}

type Tracker struct {
    Destinations []Destination
    Cache        Cache
}

type Cache struct {
    ExpiredAt   int64
    Status      string
    Destination Destination
}

type Result struct {
    IsCache     bool
    Status      string
    Destination Destination
}

func GetTracker(uri string) (result *Tracker, err error) {
    resp, err := http.Get(uri)
    if err != nil {
        return
    }
    defer resp.Body.Close()

    var r APIResponse
    if err = json.NewDecoder(resp.Body).Decode(&r); err != nil {
        return
    }

    return &Tracker{
        Destinations: r.Destinations,
    }, nil
}

func (tk *Tracker) SetCache(dest Destination, status string, expiredAt int64) {
    tk.Cache = Cache{
        Destination: dest,
        Status:      status,
        ExpiredAt:   expiredAt,
    }
}

func (tk *Tracker) Current(tt time.Time) Result {
    ts := tt.Unix() * 1000

    c := tk.Cache
    if c.Status != "" && c.ExpiredAt >= ts {
        return Result{
            Status:      c.Status,
            Destination: c.Destination,
            IsCache:     true,
        }
    }

    home := tk.Destinations[0]
    if home.Departure > ts {
        return Result{
            Status:      statusTakeOff,
            Destination: home,
        }
    }

    landing := tk.Destinations[len(tk.Destinations)-1]
    if landing.Arrival < ts {
        return Result{
            Status:      statusFinsish,
            Destination: landing,
        }
    }

    ds := tk.Destinations[1:]
    for _, dest := range ds {
        if dest.Arrival > ts {
            tk.SetCache(dest, statusMove, dest.Arrival-1)
            return Result{
                Status:      statusMove,
                Destination: dest,
            }
        } else if dest.Arrival <= ts && dest.Departure >= ts {
            tk.SetCache(home, statusDeliver, dest.Departure)
            return Result{
                Status:      statusDeliver,
                Destination: dest,
            }
        }
    }
    return Result{
        Status:      statusFinsish,
        Destination: landing,
    }
}

テストをしている時点でサンタさんが日本に来てしまったので、やってみたい人は来年以降楽しんでください。

TL;DR

1. Go言語のgoroutineはdefaultではpreemptiveに動作するOS Threadが切り替わるのでOS Threadに強く紐づくlinuxのnamespace関連の操作を行うときはruntime.LockOSThread()しておく必要がある。¹
2. Go言語でLinuxのnetwork namespaceを操作したい場合はCNIのライブラリを使うのが便利

なんでこんな事してるの？

テナント（200~）毎にVMを用意してると管理やコストが大きいため、アドレス空間が衝突してるテナントに対してHTTP(S)リバースプロキシを提供する仕組みを作ってみようと思った。

Proof of Concept

試しに下記のコードを実行してみる。

package main

import (
        "log"
        "net"
        "net/http"
        "os"
        "runtime"

        "github.com/containernetworking/plugins/pkg/ns"
)

func main() {
        nspath := os.Args[1]
        addr := os.Args[2]
        var err error
        var l net.Listener
        ns.WithNetNSPath(nspath, func(_ ns.NetNS) error {
                l, err = net.Listen("tcp", addr)
                return nil
        })
        runtime.UnlockOSThread()
        if err != nil {
                log.Fatal(err)
        }
        if err := http.Serve(l, nil); err != nil {
                log.Fatal(err)
        }
}

このコード動かすには下記の様にネットワーク的に隔離されたコンテナを用意しておくとよい。

# build binary
go build -o nsproxy nsproxy.go
# setup environment
docker run -d --net none --name pause k8s.gcr.io/pause:3.1
ns=$(docker inspect --format '{{ .NetworkSettings.SandboxKey }}' pause)
# run program
sudo ./nsproxy "$ns" 127.0.0.1:8080 &

このバイナリを動かした場合、HTTPサーバーとして動作しているタイミングではコンテナのnetwork namaspace(以後netnsと表記)には存在していない。

# ls -l /proc/1/ns/net # hostの初期netnsの情報
lrwxrwxrwx 1 root root 0 Dec 24 21:42 /proc/1/ns/net -> 'net:[4026531984]'
# ls -l /proc/$(pgrep nsproxy)/task/*/ns/net # nsproxyプロセスはホストのnetnsに居る
lrwxrwxrwx 1 root root 0 Dec 24 21:42 /proc/4377/task/4377/ns/net -> 'net:[4026531984]'
lrwxrwxrwx 1 root root 0 Dec 24 21:47 /proc/4377/task/4378/ns/net -> 'net:[4026531984]'
lrwxrwxrwx 1 root root 0 Dec 24 21:47 /proc/4377/task/4379/ns/net -> 'net:[4026531984]'
lrwxrwxrwx 1 root root 0 Dec 24 21:47 /proc/4377/task/4380/ns/net -> 'net:[4026531984]'
lrwxrwxrwx 1 root root 0 Dec 24 21:47 /proc/4377/task/4381/ns/net -> 'net:[4026531984]'
lrwxrwxrwx 1 root root 0 Dec 24 21:47 /proc/4377/task/4382/ns/net -> 'net:[4026531984]'
lrwxrwxrwx 1 root root 0 Dec 24 21:47 /proc/4377/task/4393/ns/net -> 'net:[4026531984]'
# ls -l /proc/$(docker inspect --format '{{.State.Pid}}' pause)/task/*/ns/net # containerのnetnsの情報
lrwxrwxrwx 1 root root 0 Dec 24 21:50 /proc/3867/task/3867/ns/net -> 'net:[4026532117]'

しかしながらnsenterを用いてコンテナのnetnsの中に入ると127.0.0.1:8080でhttpサーバーが動作していることが分かる。

# nsenter --net=$(docker inspect --format '{{ .NetworkSettings.SandboxKey }}' pause) bash
# ip addr
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
    inet 127.0.0.1/8 scope host lo
       valid_lft forever preferred_lft forever
# ss -ltn
State           Recv-Q          Send-Q                   Local Address:Port                     Peer Address:Port
LISTEN          0               128                          127.0.0.1:8080                          0.0.0.0:*
# curl http://127.0.0.1:8080 -v
* Expire in 0 ms for 6 (transfer 0x5627619e7f50)
*   Trying 127.0.0.1...
* TCP_NODELAY set
* Expire in 200 ms for 4 (transfer 0x5627619e7f50)
* Connected to 127.0.0.1 (127.0.0.1) port 8080 (#0)
> GET / HTTP/1.1
> Host: 127.0.0.1:8080
> User-Agent: curl/7.64.0
> Accept: */*
>
< HTTP/1.1 404 Not Found
< Content-Type: text/plain; charset=utf-8
< X-Content-Type-Options: nosniff
< Date: Tue, 24 Dec 2019 12:58:10 GMT
< Content-Length: 19
<
404 page not found
* Connection #0 to host 127.0.0.1 left intact

たくさんのコンテナからアクセスできるようにしてみる

この方法がどれだけスケールすのか試してみる。
Listenするポートを複数になるように拡張する。

package main

import (
        "log"
        "net"
        "net/http"
        "os"
        "runtime"
        "sync"

        "github.com/containernetworking/plugins/pkg/ns"
)

func main() {
        addr := os.Args[1]
        var ls []net.Listener
        for _, nspath := range os.Args[2:] {
                ns.WithNetNSPath(nspath, func(_ ns.NetNS) error {
                        l, err := net.Listen("tcp", addr)
                        if err != nil {
                                log.Fatal(err)
                        }
                        ls = append(ls, l)
                        return nil
                })
        }
        runtime.UnlockOSThread()
        var wg sync.WaitGroup
        for _, l := range ls {
                wg.Add(1)
                go func(l net.Listener){
                        err := http.Serve(l, nil)
                        if err != nil {
                                log.Print(err)
                        }
                        wg.Done()
                }(l)
        }
        wg.Wait()
}

下記の様に100個ほどコンテナを用意する

# 100個のコンテナを作成する
seq 1000 1999 | xargs -I '{}' -exec docker run -d --net none --name 'pause{}' k8s.gcr.io/pause:3.1
# 100個のコンテナに対してListenする
sudo ./nsproxy 127.0.0.1:8080 $(docker inspect --format '{{.NetworkSettings.SandboxKey}}' pause{100..199} ) &

プロセスの稼働開始直後の状態

$ sudo cat /proc/$(pgrep nsproxy)/status
Name:   nsproxy
Umask:  0022
State:  S (sleeping)
Tgid:   17082
Ngid:   0
Pid:    17082
PPid:   17068
TracerPid:      0
Uid:    0       0       0       0
Gid:    0       0       0       0
FDSize: 128
Groups: 0
NStgid: 17082
NSpid:  17082
NSpgid: 17068
NSsid:  3567
VmPeak:   618548 kB
VmSize:   561720 kB
VmLck:         0 kB
VmPin:         0 kB
VmHWM:     10980 kB
VmRSS:     10980 kB
RssAnon:            6608 kB
RssFile:            4372 kB
RssShmem:              0 kB
VmData:   161968 kB
VmStk:       140 kB
VmExe:      2444 kB
VmLib:      1500 kB
VmPTE:       140 kB
VmSwap:        0 kB
HugetlbPages:          0 kB
CoreDumping:    0
Threads:        7
SigQ:   0/15453
SigPnd: 0000000000000000
ShdPnd: 0000000000000000
SigBlk: 0000000000000000
SigIgn: 0000000000000000
SigCgt: ffffffffffc1feff
CapInh: 0000000000000000
CapPrm: 0000003fffffffff
CapEff: 0000003fffffffff
CapBnd: 0000003fffffffff
CapAmb: 0000000000000000
NoNewPrivs:     0
Seccomp:        0
Speculation_Store_Bypass:       thread vulnerable
Cpus_allowed:   ffff,ffffffff,ffffffff,ffffffff,ffffffff,ffffffff,ffffffff,ffffffff
Cpus_allowed_list:      0-239
Mems_allowed:   00000000,00000001
Mems_allowed_list:      0
voluntary_ctxt_switches:        6
nonvoluntary_ctxt_switches:     0

開始直後ではRSSが10980 kB程度とかなり軽量であることが分かる。

まとめ

network namespaceを触るのは怖くないので皆さんも触ってみてください。CNIのライブラリ自体は軽量なのでぜひとも実装自体を覗いてみてください。

---

1. https://github.com/golang/go/wiki/LockOSThread ↩

はじめに

こちらは、Go4 Advent Calendar 2019 の24日目の記事です。

こんにちは、最近Go言語にはまっているエンジニアです。

この前は別のアドベントカレンダーでGobotを使ってドローンを飛ばす記事を作成しました。
Go言語のフレームワークGobotでドローンを制御してみた。

今回は、最近入門したgRPCについて書いていきたいと思います。

gRPCとは

Googleが開発したRPC呼出プロトコルで、Protocol Buffersを使うことで、REST APIより高速で堅牢な通信を実現できる点が特長です。メッセージはProtocolBuffersを用いて通信を行い、HTTP/2を用いて並列呼出、双方向呼出、ストリーミングなどが可能となっています。

.protoファイルでサーバー側、クライアント側の雛形コードを作成し、それを元に様々な言語のコードを自動生成することができます（今回はGo言語）。この雛形からの自動生成によってAPIの仕様を半ば強制に明文化することが可能になっています。

https://grpc.io/

さらにgRPCでは、クライアントアプリケーションは別のマシン上のサーバーアプリケーションのメソッドをローカルオブジェクトのように直接呼び出すことができるため、分散型のアプリケーションやサービスを簡単に作成できます。

また、別々の言語を持ったシステム同士をつなぐことも容易です。

gRPCのRPC方式

gRPCは通信方法にHTTP/2を使用いるので、一般的なRPCにおける1Request-1Responseだけでなく、1つのTCPコネクションの中で複数のRequest/Responseをやり取りすることが可能となっており、下記の四つの方式に分かれます

• Unary(Simple)
 1 request-1 response
• ServerStreaming
 1 request- N response
• ClientStreaming
 N request-1 response
• BidirectionalStreaming
 N request-N response

では今回は基本的な1req-1res方式と、1req-Nresを用いてCRUD+α機能を実装していきます。

環境構築

Go言語の環境が整っている前提でいきます。
gRPCの環境自体はこの2つをインストールするのみです。

gRPCの環境構築

#grpcのインストール
$ go get -u google.golang.org/grpc

#Protocol Bufferのインストール
$ go get -u github.com/golang/protobuf/protoc-gen-go

また、今回はDBとしてMongoDBを利用するので、MongoDBをインストールします。

MongoDBのインストール

https://www.mongodb.com/jp
こちらのサイトからダウンロードとインストールをしてください。

また下記のgithubよりmogo-go-driverをインストールし、パッケージを取得します。(depを使います。)
https://github.com/mongodb/mongo-go-driver

下記コマンドを実行すルコとでインストールが可能です。

dep ensure -add "go.mongodb.org/mongo-driver/mongo"

まずprotoファイルを作成し、APIの基礎となるコードを実装していきます。
今回は簡易ツイッターのようなid,user_id,contentを持ったGweetをCreate,Read,Delete,Updateとgweet全取得の機能を作成していきます。

protoファイル

基本的には型を設定してそれを用いて、リクエストとレスポンスの方式を決めていくため、シンプルなコードになっています。

syntax = "proto3";

package gwitter;

option go_package = "gwitterpb";

//Gweetの型を決めます。各フィールドは型と名称を持ちます。
message Gweet {
    string id = 1;
    string user_id = 2;
    string content = 3;
}

message PostGwitterRequest{
    Gweet gweet = 1;
}

message PostGwitterResponse{
    Gweet gweet = 1;
}

message ReadGwitterRequest{
    string gweet_id = 1;
}

message ReadGwitterResponse {
    Gweet gweet = 1;
}

message UpdateGwitterRequest{
    Gweet gweet = 1;
}

message UpdateGwitterResponse {
    Gweet gweet = 1;
}

message DeleteGwitterRequest {
    string gweet_id = 1;
}

message DeleteGwitterResponse {
    string gweet_id = 1;
}

//全取得の時は特に何も指定しない
message ListGwitterRequest {

}

message ListGwitterResponse {
    Gweet gweet = 1;
}


service GweetService{
    rpc PostGwitter (PostGwitterRequest) returns (PostGwitterResponse);
    rpc ReadGwitter (ReadGwitterRequest) returns (ReadGwitterResponse);
    rpc UpdateGwitter (UpdateGwitterRequest) returns (UpdateGwitterResponse);
    rpc DeleteGwitter (DeleteGwitterRequest) returns (DeleteGwitterResponse); // return NOT_FOUND if not found
    rpc ListGwitter (ListGwitterRequest) returns (stream ListGwitterResponse);
}

protoファイルを作成後、下記コマンドを叩くだけで、各メッセージ型に対する型を含んだ .pb.go ファイルが作成されます。

protoファイルから雛形コードの生成

次に上記のprotoファイルからコードを生成していきます。
以下のコマンドを叩いてください。

protoc calculator/proto/calculator.proto --go_out=plugins=grpc:.

長いのでここでは割愛しますが、ファイルが作成されます。文頭にコメントで「DO NOT EDIT」と書かれているように、このファイルには絶対に手を加えてはいけません。これを基本として、Client&Server側を実装していきます。

コードを見たい方はこちら
https://github.com/waytkheming/gwitter-proto/blob/master/gwitterpb/gwitter.pb.go

土台となるServer,Clientのコードを実装

• Server側

package main

import (
    "context"
    "fmt"
    "log"
    "net"
    "os"

    "os/signal"

    "github.com/waytkheming/grpc-go-course/gwitter/gwitterpb"
    "go.mongodb.org/mongo-driver/bson"
    "go.mongodb.org/mongo-driver/bson/primitive"
    "go.mongodb.org/mongo-driver/mongo"
    "go.mongodb.org/mongo-driver/mongo/options"
    "google.golang.org/grpc"
    "google.golang.org/grpc/codes"
    "google.golang.org/grpc/status"
)

var collection *mongo.Collection

type server struct {
}

func main() {
    //if crash the code, get the file name and line number
    log.SetFlags(log.LstdFlags | log.Lshortfile)
    // client, err := mongo.NewClient(options.Client().ApplyURI("mongodb://localhost:27017"))

    // connect to database
    client, err := mongo.NewClient(options.Client().ApplyURI("mongodb://localhost:27017"))
    if err != nil {
        log.Fatal(err)
    }
    err = client.Connect(context.TODO())
    if err != nil {
        log.Fatal(err)
    }

    fmt.Println("Blog Service Started")
    collection = client.Database("mydb").Collection("gwitter")

    lis, err := net.Listen("tcp", "0.0.0.0:50051")
    if err != nil {
        log.Fatalf("Failed to listen: %v", err)
    }

    opts := []grpc.ServerOption{}
    s := grpc.NewServer(opts...)

    gwitterpb.RegisterGweetServiceServer(s, &server{})
    go func() {
        fmt.Println("Starting server ....")
        if err := s.Serve(lis); err != nil {
            log.Fatalf("Failed to serve: %v", err)
        }
    }()
    //Wait for Control C to Exit
    ch := make(chan os.Signal, 1)
    signal.Notify(ch, os.Interrupt)

    <-ch
    fmt.Println("Stopping the server")
    s.Stop()
    fmt.Println("Close the listener")
    lis.Close()
    fmt.Println("Closeing connection")
    client.Disconnect(context.TODO())
    fmt.Println("end of program")
}

• Client側

package main
import (
    "fmt"
    "io"
    "log"
    "context"
    "github.com/waytkheming/grpc-go-course/gwitter/gwitterpb"
    "google.golang.org/grpc"
)

func main() {
    fmt.Println("Hello from Gwitter client")
    conn, err := grpc.Dial("localhost:50051", grpc.WithInsecure())
    if err != nil {
        log.Fatalf("could not connect:%v", err)
    }

    defer conn.Close()
}

Create

まずはCreate機能から作成して行きます。

• Server側

//型を定義（bsonはMongoDB特有のフォーマットです。）
type gwitterItem struct {
    ID      primitive.ObjectID `bson:"_id,omitempty"`
    UserID  string             `bson:"user_id"`
    Content string             `bson:"content"`
}

//Post(Create)メソッドです。
func (*server) PostGwitter(ctx context.Context, req *gwitterpb.PostGwitterRequest) (*gwitterpb.PostGwitterResponse, error) {
    fmt.Println("Post Gweet invoked")

    gweet := req.GetGweet()

    data := gwitterItem{
        UserID:  gweet.GetUserId(),
        Content: gweet.GetContent(),
    }
        //MongoDBへ保存
    res, err := collection.InsertOne(context.Background(), data)
    if err != nil {
        return nil, status.Errorf(
            codes.Internal,
            fmt.Sprintf("Internal error: %v", err),
        )
    }

    oid, ok := res.InsertedID.(primitive.ObjectID)
    if !ok {
        return nil, status.Errorf(
            codes.Internal,
            fmt.Sprintf("Cannnot convert to OID "),
        )
    }

    return &gwitterpb.PostGwitterResponse{
        Gweet: &gwitterpb.Gweet{
            Id:      oid.Hex(),
            UserId:  gweet.GetUserId(),
            Content: gweet.GetContent(),
        },
    }, nil
}

• Client側

    c := gwitterpb.NewGweetServiceClient(conn)

    gweet := &gwitterpb.Gweet{
        UserId:  "waytkheming",
        Content: "First Gweet",
    }

    createGweetRes, err := c.PostGwitter(context.Background(), &gwitterpb.PostGwitterRequest{Gweet: gweet})
    if err != nil {
        log.Fatalf("Unexpected Error %v: \n", err)
    }

    fmt.Printf("Gweet has been gweeted: %v \n", createGweetRes)

Read

• Server側

func (*server) ReadGwitter(ctx context.Context, req *gwitterpb.ReadGwitterRequest) (*gwitterpb.ReadGwitterResponse, error) {
    fmt.Println("Read Gweet invoked")
    gweetID := req.GetGweetId()

    oid, err := primitive.ObjectIDFromHex(gweetID)
    if err != nil {
        return nil, status.Error(codes.InvalidArgument, fmt.Sprintf("Cannot parse ID"))
    }

    // create empty struct
    data := &gwitterItem{}

    filter := bson.M{"_id": oid}
    res := collection.FindOne(context.Background(), filter)
    if err := res.Decode(data); err != nil {
        return nil, status.Errorf(
            codes.NotFound,
            fmt.Sprintf("cannnot fing gweet with this id: %v", err),
        )
    }

    return &gwitterpb.ReadGwitterResponse{
        Gweet: dataToGweetPb(data),
    }, nil
}

func dataToGweetPb(data *gwitterItem) *gwitterpb.Gweet {
    return &gwitterpb.Gweet{
        Id:      data.ID.Hex(),
        UserId:  data.UserID,
        Content: data.Content,
    }
}

• Client側

    gweetID := createGweetRes.GetGweet().GetId()
    // read gwitter
    fmt.Println("Reading the gwitter")
    _, err2 := c.ReadGwitter(context.Background(), &gwitterpb.ReadGwitterRequest{GweetId: "waytkheming"})
    if err2 != nil {
        fmt.Printf("Error happened WHILE READING: %v \n", err2)
    }

    readGweetReq := &gwitterpb.ReadGwitterRequest{GweetId: gweetID}
    readGweetRes, readGweetError := c.ReadGwitter(context.Background(), readGweetReq)
    if readGweetError != nil {
        fmt.Printf("Error happened WHILE READING: %v \n", readGweetError)
    }
    fmt.Printf("Gweet was read: %v \n", readGweetRes)

Update

• Server側

func (*server) UpdateGwitter(ctx context.Context, req *gwitterpb.UpdateGwitterRequest) (*gwitterpb.UpdateGwitterResponse, error) {
    fmt.Println("Update Gweet invoked")
    gweet := req.GetGweet()
    oid, err := primitive.ObjectIDFromHex(gweet.GetId())
    if err != nil {
        return nil, status.Error(codes.InvalidArgument, fmt.Sprintf("Cannot parse ID"))
    }
    // create empty struct
    data := &gwitterItem{}
    filter := bson.M{"_id": oid}

    res := collection.FindOne(context.Background(), filter)
    if err := res.Decode(data); err != nil {
        return nil, status.Errorf(
            codes.NotFound,
            fmt.Sprintf("cannnot fing gweet with this id: %v", err),
        )
    }

    data.UserID = gweet.GetUserId()
    data.Content = gweet.GetContent()

    _, updateErr := collection.ReplaceOne(context.Background(), filter, data)
    if updateErr != nil {
        return nil, status.Errorf(
            codes.Internal,
            fmt.Sprintf("Cannot update object in MongoDB: %v", updateErr),
        )
    }

    return &gwitterpb.UpdateGwitterResponse{
        Gweet: dataToGweetPb(data),
    }, nil
}

• Client側

    newGweet := &gwitterpb.Gweet{
        Id:      gweetID,
        UserId:  "changeMan",
        Content: "Editted content",
    }
    updateRes, updateErr := c.UpdateGwitter(context.Background(), &gwitterpb.UpdateGwitterRequest{Gweet: newGweet})
    if updateErr != nil {
        fmt.Printf("Error happened WHILE updateting: %v \n", readGweetError)
    }
    fmt.Printf("Gweet was updated: %v \n", updateRes)

Delete

• Server側

func (*server) DeleteGwitter(ctx context.Context, req *gwitterpb.DeleteGwitterRequest) (*gwitterpb.DeleteGwitterResponse, error) {
    fmt.Println("Delete Gweet invoked")
    oid, err := primitive.ObjectIDFromHex(req.GetGweetId())
    if err != nil {
        return nil,
            status.Error(
                codes.InvalidArgument,
                fmt.Sprintf("Cannnot parse your gweet id"))
    }

    filter := bson.M{"_id": oid}
    res, err := collection.DeleteOne(context.Background(), filter)
    if err != nil {
        return nil, status.Errorf(
            codes.Internal,
            fmt.Sprintf("Internal error: %v", err),
        )
    }

    if res.DeletedCount == 0 {
        return nil, status.Errorf(
            codes.Internal,
            fmt.Sprintf("Internal error: %v", err),
        )
    }

    return &gwitterpb.DeleteGwitterResponse{GweetId: req.GetGweetId()}, nil
}

• Client側

    fmt.Println("Deleting the gwitter")
    deleteGweetRes, deleteGweetError := c.DeleteGwitter(context.Background(), &gwitterpb.DeleteGwitterRequest{GweetId: gweetID})
    if deleteGweetError != nil {
        fmt.Printf("Error happened WHILE READING: %v \n", deleteGweetError)
    }
    fmt.Printf("Gweet was deleted: %v \n", deleteGweetRes)

List

ここではServer Streaming方式を用いることになります。

• Server側

//引数であるstreamがNつのレスポンスを返す役割を担います。
func (*server) ListGwitter(req *gwitterpb.ListGwitterRequest, stream gwitterpb.GweetService_ListGwitterServer) error {
    fmt.Println("List gwitter request")

    list, err := collection.Find(context.Background(), primitive.D{{}})
    if err != nil {
        return status.Errorf(
            codes.Internal,
            fmt.Sprintf("Unknown internal error: %v", err),
        )
    }
    defer list.Close(context.Background())
        //for文を回して一つ一つ項目を取得して行きます。
    for list.Next(context.Background()) {
        data := &gwitterItem{}
        err := list.Decode(data)
        if err != nil {
            return status.Errorf(codes.Internal,
                fmt.Sprintf("Error while decoding data from MongoDB: %v", err),
            )
        }

        stream.Send(&gwitterpb.ListGwitterResponse{Gweet: dataToGweetPb(data)})
        if err := list.Err(); err != nil {
            return status.Errorf(codes.Internal,
                fmt.Sprintf("Error while decoding data from MongoDB: %v", err),
            )
        }
    }
    return nil

}

• Client側

    stream, err := c.ListGwitter(context.Background(), &gwitterpb.ListGwitterRequest{})
    for {
        res, err := stream.Recv()
        if err == io.EOF {
            break
        }
        if err != nil {
            log.Fatalf("somethig wrong things happened: %v", err)
        }
        fmt.Println(res.GetGweet())
    }

終わりに

ここで実装は終わりです。実際に動作を行うのは、Server側、Client側それぞれでrunさせてみてください。
MongoDBへデータのやり取りが行われるはずです。

長い記事でしたが最後まで読んでくださりありがとうございました。

想定よりもコード量が多くなってしまいましたので、今回記載したコードはまとめてこちらに掲載します。
https://github.com/waytkheming/gwitter-proto

よろしければ参考にしてみてください。

参考サイト

https://grpc.io/
https://qiita.com/muroon/items/1c9ad59653c00d8d5e3d
https://www.udemy.com/course/grpc-golang/

はじめに

こんにちはRIN1208です。
本日はクリスマスイブですね!!自分は特に予定がなく部屋で過ごしてチキンを食べました！悲しい....
この記事は画像のサイズ圧縮をかなりの量をしなくてはいけなくなったのでその制作の途中経過です（深刻なアドベントカレンダーのネタ不足....）

またこの記事はITRCアドベントカレンダーの24日目の記事になります。

開発環境

• mac
• goの実行環境

今回使用したパッケージ

• github.com/google/uuid
  uuidを使うために使用しました
  GitHub
• github.com/nfnt/resize
  画像のサイズを変更するのに使用しました
  GitHub

インストール

$ go get github.com/google/uuid
$ go get github.com/nfnt/resize

今回のコード（下で順々に解説します）

package main

import (
    "image"
    "image/jpeg"
    "image/png"
    "io/ioutil"
    "log"
    "os"

    "github.com/google/uuid"
    "github.com/nfnt/resize"
)

func main() {

    files, _ := ioutil.ReadDir("./image")
    for _, f := range files {
        save_image("./image/" + f.Name())
    }

}

func save_image(filename string) {

    path := "./datas/"  //保存先のディレクトリ名になります。現時点のコードでは既に作成していないとエラーが出ます


    uuid := create_uuid() //こちらの部分は後ほど解説します

    file, err := os.Open(filename)
    if err != nil {
        log.Fatal(err)
    }
    img, data, err := image.Decode(file)
    if err != nil {
        log.Fatal(err)
    }
    file.Close()
    m := resize.Resize(1000, 0, img, resize.Lanczos3)

    if data == "png" {
        out, err := os.Create(path + uuid + ".png")
        if err != nil {
            log.Fatal(err)
        }
        defer out.Close()
        png.Encode(out, m)
    } else if data == "jpeg" {
        out, err := os.Create(path + uuid + ".jpeg")
        if err != nil {
            log.Fatal(err)
        }
        defer out.Close()
        jpeg.Encode(out, m, nil)
    }

}

func create_uuid() string {
    u, _ := uuid.NewRandom()
    uuid := u.String()
    return uuid
}

特に難しいことはしてないでです

コードの解説

main()の部分

    files, _ := ioutil.ReadDir("./image")
    for _, f := range files {
        save_image("./image/" + f.Name())
    }

ここではimageディレクト下の画像のファイル名を取得しsave_image()関数に画像ファイルのパスを渡しています。

save_image()の部分は下で説明します。

save_image()の部分

画像のリサイズは以下の部分でしています。数値を変更するとサイズも変更されます。

m := resize.Resize(1000, 0, img, resize.Lanczos3)

こちらの部分は取得した画像がpngならpng、jpegならjpegで保存するようにしています

    if data == "png" {
        out, err := os.Create(path + uuid + ".png")
        if err != nil {
            log.Fatal(err)
        }
        defer out.Close()
        png.Encode(out, m)
    } else if data == "jpeg" {
        out, err := os.Create(path + uuid + ".jpeg")
        if err != nil {
            log.Fatal(err)
        }
        defer out.Close()
        jpeg.Encode(out, m, nil)
    }

create_uuid()の部分

ここに関しては特に説明するとがないですが今回使用した理由としては大量の画像のためファイル名がかぶらないようにしたかったので使用しました。（名前は適当でよかったので）

終わりに

ここまで読んでいただきありがとうございます。今回ここに書いてあるのは制作途中にの物でありこれから並列処理を使用して大量の画像を処理していく予定です。

この記事は、Go Advent Calendarに、代打で出そうとして、クリスマスイブの夜から書き始めて、無事埋まったので野良記事として公開するものです。

TL;DR

• mackerel-container-agent とは、Mackerel社がコンテナ監視のために用意している監視エージェントである
• mackerel-container-agent は、Go言語で実装されており、監視ツールの性質上、リトライ処理が用意されている
• Exponential backoff というリトライのアルゴリズムを実装している

背景

筆者は、業務でAmazon ECS(Elastic Container Service）というAWSのコンテナオーケストレーションサービスを利用したサービスを運用しています。そのサービスで稼働しているコンテナの監視のため、監視SaaSであるMackerelを使用しています。メインのコンテナのサイドカーとして、mackerel-container-agentというコンテナ用の監視エージェントを置くことで、監視を実現する仕組みです。普段、ユーザーとして使っている中でふとその中の実装がどうなっているのだろうと気になったので調べたことをここに記します。

特に、気になった点が、「いかにリトライを実現しているか」というポイントだったので、失敗時のリトライ処理にフォーカスして書きます。

mackerel-container-agentとは

上記で紹介したこちらは、GitHubにOSSとして公開されています。

https://github.com/mackerelio/mackerel-container-agent

調査の起点は、こちらのエラーログからたどっていきます（2019年12月19日当時、メンテナンス中でその際どういう動きをしてるんだろうと気になって調べたのがきっかけのきっかけです）。

2019/12/19 06:04:31 INFO <agent> retry to find host: failed to create a new host: API request failed: Site is under maintenance.

※ 内部実装がGoだと、おそらく errors.Wrap()でエラーがくるまれた結果、このような階層的なエラーメッセージが生成されているのだろう、という推測からです。

エラーメッセージの階層をたどる

まずは、エラーの文字列 retry to find host から、ここでログ出力されているのがわかります。

https://github.com/mackerelio/mackerel-container-agent/blob/697ce4a13eea5e614d4b72fa7ef7fa5374add839/agent/run.go#L78

            case <-time.After(duration):
                host, retryHostID, err := hostResolver.getHost(hostParam)
                if retryHostID {
                    logger.Infof("retry to find host: %s", err)
                    if duration *= 2; duration > 10*time.Minute {
                        duration = 10 * time.Minute
                    }
                    continue
                }       

hostResolver.getHostのなかをたどると、更に続きの階層のエラー failed to create a new host を見つけることが出来ます。

https://github.com/mackerelio/mackerel-container-agent/blob/69372758402f6388019adff2b5662a8e1a21ce31/agent/host_resolver.go#L61

            // create a new host
            hostID, err := r.client.CreateHost(hostParam)
            if err != nil {
                return nil, retryFromError(err), errors.Wrap(err, "failed to create a new host")
            }

r.client.CreateHostを続けて見つけると、Interfaceにたどり着きました。

https://github.com/mackerelio/mackerel-container-agent/blob/36cf0bb103d1645fb733c214fe142207b1318838/api/client.go#L9

package api

import mackerel "github.com/mackerelio/mackerel-client-go"

// Client represents a client of Mackerel API
type Client interface {
    FindHost(id string) (*mackerel.Host, error)
    FindHosts(param *mackerel.FindHostsParam) ([]*mackerel.Host, error)
    CreateHost(param *mackerel.CreateHostParam) (string, error)
    UpdateHost(hostID string, param *mackerel.UpdateHostParam) (string, error)
    UpdateHostStatus(hostID string, status string) error
    RetireHost(id string) error
    PostHostMetricValuesByHostID(hostID string, metricValues []*mackerel.MetricValue) error
    CreateGraphDefs([]*mackerel.GraphDefsParam) error
    PostCheckReports(reports *mackerel.CheckReports) error
}

このInterfaceの実装先は依存関係を解決している上位をたどるとわかりますが、github.com/mackerelio/mackerel-client-goが具象として使用されています。

https://github.com/mackerelio/mackerel-container-agent/blob/90e89ad9946df6dc89dad90f4b7f09528444054f/agent/agent.go#L97

    mackerel "github.com/mackerelio/mackerel-client-go"

mackerel-container-agent内の責務として具体的なAPI Clientとしての役割は持たせず別ライブラリを利用する戦略をとっていることがわかりました。

retry処理がどうなっているか眺める

表題にあげた、リトライ処理はどうなってるんでしょうか。その中身は、以下のコードから読み解くことが出来ます。

https://github.com/mackerelio/mackerel-container-agent/blob/697ce4a13eea5e614d4b72fa7ef7fa5374add839/agent/run.go#L73

        for {
            select {
            case <-time.After(duration):
                host, retryHostID, err := hostResolver.getHost(hostParam)
                if retryHostID {
                    logger.Infof("retry to find host: %s", err)
                    if duration *= 2; duration > 10*time.Minute {
                        duration = 10 * time.Minute
                    }
                    continue
                }

実装にfor-selectパターンという並行処理の実装パターンが使われています。
この中でtime.Afterを用いて一定期間時間が経過するのを待ち受けています。
引数で渡されているdurationですが、現在のリトライ時間を2倍ずつしていって、10分以上であれば10分にする実装となっています。

この手法は、Exponetial backoffという有名なリトライのアルゴリズムと知られています。

https://en.wikipedia.org/wiki/Exponential_backoff

Exponential backoff is an algorithm that uses feedback to multiplicatively decrease the rate of some process, in order to gradually find an acceptable rate.

Microsoftの「アプリケーション回復性パターン」というドキュメントにも、再思考パターンとして紹介されています。

https://docs.microsoft.com/ja-jp/dotnet/architecture/cloud-native/application-resiliency-patterns#retry-pattern

まとめ

簡単でしたが、コードリーディングの一端をご紹介させていただきました。

はじめに

この時期はネタに走った面白い記事が多くあるとは思うのですが、私は自分の知識の確認のためにgoでのjsonの扱い方について書いていこうと思います！

https://golang.org/pkg/encoding/json/

jsonを構造体(struct)にする

まずはjson -> structにする方法です。これをするにはgoの標準パッケージであるjson(encoding/json)のjson.Unmarshalを使います。

json-->struct

type Person struct {
    Name       string
    Age        int
    Belongings []string
}

func main() {
    b := []byte(`{"name":"mike","age":20,"belongings":["apple","banana","orange"]}`)

    var p Person
    if err := json.Unmarshal(b, &p); err != nil {
        fmt.Println(err)
    }
    fmt.Println(p)
        // => {mike 20 [apple banana orange]}
}

まずは予め構造体を作っておきます。次にjsonのデータbyteに突っ込みます。
最後にそれをjson.Unmarshalで処理すればめでたくjsonが構造体になります！

また、structで宣言されていてもjson側に対応するものがない時は無視されます！

json-->struct

// Hogeを追加
type Person struct {
    Name       string
    Age        int
    Hoge       string
    Belongings []string
}

func main() {
    b := []byte(`{"name":"mike","age":20,"belongings":["apple","banana","orange"]}`)
    var p Person
    if err := json.Unmarshal(b, &p); err != nil {
        fmt.Println(err)
    }
    fmt.Println(p)
        // => {mike 20 [apple banana orange]}
}

構造体(struct)をjsonにする

今度は構造体(struct)をjsonに変換するやり方です。これも先ほどとやり方はほとんど同じでjson.Marshalを使用する事で変換できます！

struct-->json

type Person struct {
    Name       string   
    Age        int      
    Belongings []string 
}

func main() {
    b := []byte(`{"name":"mike","age":20,"belongings":["apple","banana","orange"]}`)

    var p Person
    if err := json.Unmarshal(b, &p); err != nil {
        fmt.Println(err)
    }

/* ~~~~~~~~~~ここまでさっきと同じ~~~~~~~~~~ */ 

    v, _ := json.Marshal(p)
    fmt.Println(string(v))
        // => {"Name":"mike","Age":20,"Belongings":["apple","banana","orange"]}
}

指定した名前で構造体(struct)をjsonにする

先ほどの実行結果をみてもらえばお分かりになると思うのですが、最初はnameだったのにもかかわらずstructからjsonにしたあとではNameとなっています。では、structからjsonにした後もnameにしたい場合はどのようにすれば良いでしょか？

名前を指定

type Person struct {
    Name       string   `json:"name"`
    Age        int      `json:"age"`
    Belongings []string `json:"belongings"`
}

func main() {
    b := []byte(`{"name":"mike","age":20,"belongings":["apple","banana","orange"]}`)
    var p Person
    if err := json.Unmarshal(b, &p); err != nil {
        fmt.Println(err)
    }

    v, _ := json.Marshal(p)
    fmt.Println(string(v))
        // => {"name":"mike","age":20,"belongings":["apple","banana","orange"]}
}

上のコードでは構造体の型の後ろでjson:"~~"のように宣言していますこうする事でjsonに変換したあとの名前を指定できます！

いい感じに名前を付けてくれる: https://mholt.github.io/json-to-go/

いろいろ指定してみる

json:"~~"は名前だけでなく他にも指定できます。

• json:"-": structからjsonに変換した時に表示したくないものにはこれをしていする
• json:"name,omitempty": nameが０や文字がない時や、nilの時にstructからjsonに変換した際、表示させないようにする

最後に

jsonをカスタマイズする方法もあったのですが、クリスマスに悲しく記事を書くのに疲れたので今回はここまでにしておきます（妥協）

はじめに

メリークリスマス！！

みなさんは Go のアプリケーション開発をどのような環境で行っていますか？
弊社ではゲームのアプリケーションサーバに Go を採用しており、開発は macOS で Docker for Mac を利用しています。開発当初はこの構成による不満は特に感じていませんでしたが、1年半ほど経ってプロジェクトの規模が大きくなったことで、無視できないレベルで開発スピードを低下させる要因となってしまいました。
弊社ではアプリケーション開発にソースコードの自動生成を多用しており、その影響もあってかコードベースの Go のコードは 150万行を超える規模になっています。 加えて、ビルドする際は cgo 経由で利用している C++ のコードもそれなりの量絡んでくることもあり、 Docker for Mac を使った Docker コンテナ上でのビルドに要する時間は、 メモリ8GB, 6CPUを割り当てたコンテナにも関わらず 5分を超える時間がかかっていました。 ( それでもまだ良い方で、他の方のマシンスペックでは 10分程かかる場合もあったようです )

実際はビルドキャッシュが効くので毎回 5 ~ 10 分かかるわけではありませんが、パッケージの依存関係によっては数珠つなぎ的に再ビルドが必要になってしまうケースもあるので、一文字編集したら 10 分待つという状況も起こり得ます。

このままではとても開発していられないということで、ビルドを爆速にするツールを開発してみました。
この記事では、開発したツールの紹介と、ちょっとトリッキーな実装をしているので、どうやって実現したかという話にも触れたいと思います。

ホットリローディング

ウェブアプリケーションなどを開発する際、ファイルの追加・更新・削除といったイベントを契機に自動で再ビルド・実行する仕組みを利用することが多いと思います。これらはホットリローディングやライブリローディングなどと呼ばれたりしますが、もちろん Go にも存在します。
有名どころだと https://github.com/gravityblast/fresh や https://github.com/oxequa/realize が挙げられますが、どちらも現在メンテされてはおりません...。

弊社では、上で挙げた https://github.com/gravityblast/fresh を利用していました。
また、ホットリローディングを Dockerコンテナ 上で動作するアプリケーションで行うため、以下のような設定を行っていました。

docker-compose.yml

version: '2'
services:
  app:
    image: golang:1.13.5
    container_name: app
    volumes:
      - '.:/go/src/app'
    working_dir: /go/src/app
    environment:
      GO111MODULE: "on"
    command: |
      go get -u github.com/pilu/fresh && fresh

つまり、 volumes でビルドに必要なソースコードが置かれているディレクトリをまるっとコンテナにマウントし、ホットリローダ ( fresh ) をコンテナ上にインストールしてファイル監視を始めます。

これによって、ローカル上のファイルを編集した場合でも、その変更がコンテナにも伝わり、
コンテナ上で動作しているホットリローダがそれを検知してアプリケーションを再ビルドし、無事ビルドできたら現在動いているアプリケーションと入れ替えます(リスタート)。

仕組み自体はとてもシンプルなものなので、再実装も難しくはありません。
ただ今回改善したいのは ビルド時間 なので、コンテナの上でビルドしているうちは改善できません。
そこで次のようなツールを開発しました

rebirth

rebirth という Go のための ホットリローダを開発しました。
既存のホットリローダと大きく異なるのは、 Docker コンテナ上でのビルドを避けるために
ホスト上でクロスコンパイルしつつDockerコンテナで動くアプリケーションをホットリロードできる 機能を持っている点です。
これによって、 Docker for Mac に依存せずにホストマシンの力を使い切ってビルドできるようになります。
( ホスト上でビルドするようにした結果 5分かかっていたビルド時間が 30 秒ほどに減り、目に見えて高速化しました )

どのように使うかというと

.
├── docker-compose.yml
├── main.go
└── rebirth.yml

このような構成のワークスペースがあったとして、
docker-compose.yml が以下のような内容だとします。 ( 先に挙げた docker-compose.yml 中の fresh の部分が tail -f /dev/null になっているだけです )

docker-compose.yml

version: '2'
services:
  app:
    image: golang:1.13.5
    container_name: app
    volumes:
      - '.:/go/src/app'
    working_dir: /go/src/app
    environment:
      GO111MODULE: "on"
    command: tail -f /dev/null

ここで docker-compose up -d とすると、 app という名前のコンテナが立ち上がると思います。
ここで、 rebirth.yml を記述します。

rebirth.yml

host:
  docker: app

host.docker にホットリロードしたいアプリケーションのあるコンテナの名前を書きます。

次に、以下を実行して rebirth という CLI をインストールします。

$ GO111MODULE=on go get -u github.com/goccy/rebirth/cmd/rebirth

これで準備完了です。 macOS上で rebirth を実行します

$ rebirth
# ホットリローダが立ち上がる。
# ファイルを編集すると、 app コンテナ上のアプリケーションがビルド後のものに入れ替わる

以上になります。

...ここで

!?

と思っていただけたら嬉しいのですが

コンテナ上に何もインストールしていないのに、 macOSにインストールしたバイナリのみでコンテナ上のアプリケーションのホットリロードを実現する というのがこのツールを作った時のこだわりポイントでした。これによって、Docker を使わない場合と使い方を変えることなく利用することができるようになっています ( rebirth.yml の書き方を変えるだけ )

続いて、これをどう実現しているかについて触れていきます

実装

流れが少し複雑なので、図を使って説明していきます。
はじめに、下の図を見てください。

一番外の大きい枠が macOS 上だということを表現しています。
その上にあるグレーの linux と書かれている部分は、
Docker for Mac を使って動作している linux コンテナを表しています。

破線で囲われている中は、 volumes でマウントされていることを表しています。
( つまり、 workspace が ~/work/app という状況で docker-compose.yml の volumes に .:/go/src/app と書かれている状態になります )

1. rebirth をインストールする

まず、 GO111MODULE=on go get -u github.com/goccy/rebirth/cmd/rebirth で rebirth CLI をインストールします

2. rebirth 自身のクロスコンパイル

rebirth を実行した際にはじめに行うのは、ターゲットとなる Dockerコンテナのアーキテクチャ向けに自分自身をクロスコンパイルし、 __rebirth という名前で ~/work/app 直下の .rebirth ディレクトリ配下に置きます

コンパイル対象のアーキテクチャを知るため、 https://godoc.org/github.com/docker/docker/client を利用して docker remote API 経由で go env GOOS と go env GOARCH を実行しています。

3. コンテナ上にクロスコンパイルした rebirth バイナリを配置する

.rebirth があるディレクトリは ~/work/app 直下なので、コンテナ上にマウントされています。
このため、自動でコンテナ上の /go/src/app/.rebirth 配下にコンテナ上で実行可能な __rebirth バイナリが配置されます。

( このあたりは、マウントを利用せずともバイナリを直接コンテナ上にコピーすれば同じことができますが、大抵の場合はマウントを前提としても問題ないと思っているので、処理を簡単にするためにこのようにしています )

4. アプリケーションのファイルを監視し始める

図では main.go のファイルイベントを監視し始めることを表しています
( 実装には fsnotify を使っています )

5. アプリケーションコードをクロスコンパイルする

rebirth 自身をクロスコンパイルしたときと同じ要領で、コンテナのアーキテクチャ向けにクロスコンパイルします。
少し違うのは、アプリケーションコードが cgo を利用したものであったとしてもコンパイルできるようにしなければらない点です。

このため GOOS や GOARCH の指定に加え、 CGO_ENABLED=1 を有効にします。
さらに、 C/C++ コードを macOS 上で linux 向けにコンパイルできるよう、クロスコンパイラを作らなければいけません。 https://github.com/FiloSottile/homebrew-musl-cross にあるように

$ brew install FiloSottile/musl-cross/musl-cross

でインストールをお願いします。 ( ビルドに30分程度かかります )

( 参考 : https://qiita.com/keijidosha/items/5f4a68a3341a44a25ab9 )

また、今までコンテナ上のパスとして設定されていた GOPATH が、ホスト上で指定されたものに変わるため、
振る舞いを揃えるために、ワークスペースに作った .rebirth ディレクトリを GOPATH の起点として扱い、 go.mod のモジュール名を見ながら、アプリケーションコードを .rebirth 配下に配置し直してビルドを行っています。

例えば、 go.mod に module github.com/company/webapp と書かれていたとすると、

1. .rebirth/src/github.com/company というディレクトリを掘る
2. ワークスペース ( webapp ディレクトリ ) への symlink を 1 で作ったディレクトリの配下に作る
3. .rebirth/src/github.com/company/webapp へ移動する
4. GOPATH=/path/to/.rebirth go build ... のように GOPATH を変更してビルドする

というようなことを行います。これによって、依存モジュールなどをアプリケーションワイドにインストールすることが可能なので、
ローカルの GOPATH と混ざったりすることはなくなります。

上記をまとめると、以下のような環境変数やオプションをつけて go build を実行しています

$ GOPATH=.rebirth GOOS=linux GOARCH=amd64 CGO_ENABLED=1 CC=x86_64-linux-musl-cc CXX=x86_64-linux-musl-c++ go build --ldflags '-linkmode external -extldflags "-static"'

( ※ 実際には クロスコンパイラへのパスを通すために PATH に追加したり、 GOPATH も絶対パスで表現したりしています )

6. コンテナ上にクロスコンパイルしたアプリケーションバイナリを配置する

ビルドした結果は、 .rebirth 配下に program という名前で配置しています。
__rebirth のときと同様に、マウント先のコンテナ上に自動的に配置されます。

7. __rebirth の実行

コンテナ上で __rebirth バイナリを実行します。このとき、動作しているのが Dockerコンテナ上であり、
かつ rebirth.yml に host.docker の指定がある場合には、ファイル監視を行わない専用のモードで起動します。
起動時に、自身の PID を記録したファイルを .rebirth 配下に書き出します。

( 自身がDockerコンテナ上で起動しているかどうかは、 /.dockerenv が存在するかで判定することができます )

8. コンテナ上でアプリケーションを起動する

__rebirth から .rebirth/program を実行します

9. ファイルの変更

main.go をホスト上で編集します

10. ファイルの変更を検知

ホスト上の rebirth プロセスが main.go の更新を検知します

11. アプリケーションの再ビルド

5 で説明したことをもう一度行います

12. アプリケーションの配置

6 で説明したことをもう一度行います

13. アプリケーションの再起動要請

ホスト上の rebirth から コンテナ上の __rebirth へアプリケーションの再起動要請を行います。
実装には、事前に書き出しておいた __rebirth プロセスの PID をもとに、 SIGHUP を送ることで実現しています。

本当は PID をファイルを経由せずに取得したかったのですが、 docker remote API を経由して知ろうとすると、ホスト上のPID名前空間で表現された値しかとれないため実現できませんでした ( コンテナ上で ps したときとは別の PID が返ってくる )

14. アプリケーションの再起動

SIGHUP を受け取った __rebirth プロセスが、起動中のプロセスを停止して新しく配置された program を実行すれば再起動の完了です

おまけ

cgo を利用しているコードから、他の C ライブラリを参照している場合

例えば弊社では、 cgo で記述されたコードから、 zlib を利用していました。
こういった場合は、別途 libz.a をクロスコンパイルする必要があります。

ビルドした libz.a や zlib のヘッダファイルを参照可能な場所に移して ( たとえば ワークスペース配下 )
rebirth.yml に以下のように書けばそれを用いてシンボル解決してくれるようになります

host:
  docker: app
build:
  env:
    CGO_LDFLAGS: ./lib/libz.a # lib に置いたクロスコンパイル済みの libz.a を参照する
    CGO_CXXFLAGS: -I./include # include に置いた `zlib.h` などを参照する

( 相対パスは、適宜ツール内部で絶対パスに置き換えて参照します )

ホットリロード以外の機能

ホットリロードをクロスコンパイルで行うようになると、今までコンテナ上で行っていたテストやスクリプトの実行などなどを同じ手段で行いたくなると思います。

そこで rebirth では go build , go test, go run をクロスコンパイルしつつ実行してくれるコマンドを用意しています。それぞれ rebirth build , rebirth test , rebirth run をホスト上で実行していただければ、クロスコンパイルしつつ、必要であればその結果をコンテナ上で走らせてくれます。ぜひご活用ください

おわりに

macOS 上で Docker を利用しているときのビルドを高速化したい！というニーズから実装したツールですが、
普通にホットリローダとして使う場合においても fresh より使いやすくなっていると思いますので、ぜひお試しいただければ幸いです。

引き続き改善しながら弊社で使っていこうと思っていますので、
なにか要望やバグを見つけた場合も気軽に報告いただければと思います。

それではよいクリスマスをお過ごしください！！

https://github.com/goccy/rebirth

11. タブをスペースに置換

タブ1文字につきスペース1文字に置換せよ．確認にはsedコマンド，trコマンド，もしくはexpandコマンドを用いよ．

Go

package main

import (
    "bufio"
    "fmt"
    "os"
    "strings"
)

func main() {
    //  読み込みファイルを指定
    name := "../hightemp.txt"

    //  読み込むファイルを開く
    f, err := os.Open(name)
    if err != nil {
        fmt.Printf("os.Open: %#v\n",err)
        return
    }
    defer f.Close() //  終了時にクリーズ

    //  スキャナライブラリを作成
    scanner := bufio.NewScanner(f)

    //  データを１行読み込み
    for scanner.Scan() {
        //  TAB を 空白へ置換
        fmt.Println(strings.Replace(scanner.Text(),"\t"," ",-1))
    }

    //  エラーが有ったかチェック
    if err = scanner.Err(); err != nil {
        fmt.Printf("scanner.Err: %#v\n",err)
        return
    }
}

python

# ファイルを開く
with open("../hightemp.txt", "r") as f:
    # 一行ずつ読み込む
    for data in f:
        # TAB を 空白へ置換（strip で white space を除去）
        print(data.strip().replace("\t"," "))

Javascript

// モジュールの読み込み
var fs = require("fs");
var readline = require("readline");

//  ストリームを作成
var stream = fs.createReadStream("../hightemp.txt", "utf8");

//  readlineにStreamを渡す
var reader = readline.createInterface({ input: stream });

//  行読み込みコールバック
reader.on("line", (data) => {
    //  TAB を 空白へ変換（文字列 "\t" 指定ではうまく動作しないため正規表現で指定）
    console.log(data.replace(/\t/g," "))
});

まとめ

Javascirpt で置換元文字列に "\t" が指定出来ないのか？。
Python コード数の少なさに改めて驚く。

トップ

この記事は DeNA Advent Calendar 2019 の12/24(火)の記事です。

はじめに

普段は主にPerlを使っていますが、Goを覚えたいのとPythonを復習したいという目的でまとめました。
Pythonの文法はとてもシンプルなので、その差分でGoを覚えるのが早いのではないかと思いました。
なるべく多く書いたつもりですが、いろいろと不足はあると思います。ご留意ください。

コメント

まずはコメントの書き方です。
Pythonにはもともと複数行をコメントアウトする機能はありませんが、プログラム中に文字列を置いても影響がないため、それを利用して複数行コメントを記述することができます。
また、複数行コメントはドキュメンテーション文字列として残すことができます。

Python

# 1行コメント

'''
複数行コメント
'''
"""
複数行コメント
"""

def func():
   """
   プログラムの解説など
   """

help(func)
print(func.__doc__)

Go

// 1行コメント

/*
複数行コメント
*/

変数の定義

Pythonは動的型付け言語のため、変数の型を宣言する必要はありません。

Python

n = 10
name = "hoge"

# まとめて定義する
x, y, z = 1, 2, 3
a = b = c = 1

Goの場合は、まず変数名の1文字目に注意すべきです。

• 1文字目が大文字の場合はパッケージ外からアクセスできる
• 1文字目が小文字の場合はパッケージ外からアクセスできない

これは定数・関数にも言える事です。
Goは静的型付け言語だが、明示的な定義と暗黙的な定義が存在します。

明示的な定義

var [変数の名前] [変数の型]のように定義します。

Go

var n int
n = 1

// まとめて定義する
var x, y, z int
x, y, z = 1, 2, 3

var (
    x, y int
    name string
)
x, y, name = 1, 2, "hoge"

// 型の宣言と値の代入を同時に行う
var n int = 1

暗黙的な定義

[変数の名前] := [値]もしくはvar [変数の名前] = [値]のように定義します。値を代入すると変数の型は暗黙的に推論されます。

Go

n := 1

// varを用いた定義でも型が省略できる
var n = 1

// まとめて定義する
x, y, name := 1, 2, "hoge"

var (
    x = 1
    y = 2
    name = "hoge"
)

定数

Pythonには、定数を定義するためのキーワードはありません。慣例として大文字とアンダーバーのみで定数を表しています。

Python

PI = 3.14
MAX_NUM = 100

Goではconstを使用して定数を定義します。iotaという識別子を使えば、整数の連番を生成できます。
定数の値を変更しようとするとエラーになります。

Go

const Pi = 3.14
const MaxNum = 100

// ()でまとめて定義する
const (
    Pi = 3.14
    MaxNum = 100
)

const (
    X = iota  // 0
    Y         // 1
    Z         // 2
)

// 開始番号を指定する場合
const (
    X = iota + 10  // 10
    Y              // 11
    Z              // 12
)

配列

Pythonの配列(list)は非常にシンプルに書けます。以下は基本的な使い方です。

Python

# 定義
numbers = [1, 2, 3]

# 要素の追加
numbers.append(6)
numbers.insert(3, 5)  # numbers: [1, 2, 3, 5, 6]

# 要素数
print(len(numbers))

# 要素の削除
numbers.remove(3)  # numbers: [1, 2, 5, 6]
numbers.pop(1)  # numbers: [1, 5, 6]
del numbers[0]  # numbers: [5, 6]

# リストを結合
numbers += [3, 4]  # numbers: [5, 6, 3, 4]
numbers.extend([1, 2])  # numbers: [5, 6, 3, 4, 1, 2]

# 要素の検索
print(6 in numbers)  # True
print(numbers.index(6))  # 1

# リストをソート
numbers.sort()  # numbers: [1, 2, 3, 4, 5, 6]
numbers.sort(reverse=True)  # numbers: [6, 5, 4, 3, 2, 1]

Goの配列型(array)はサイズの拡張や縮小ができません。Pythonの配列(list)のようなデータ構造は、Goではスライス(slice)に相当します。
スライスの操作でappendがよく使われます。

Go

// 配列はサイズが変更できない
array := [3]int{1, 2, 3}
fmt.Println(array[0])  // 1
fmt.Println(array[1:3])  // [2 3]

// スライス
n1 := []int{}  // n1: []
n2 := make([]int, 0)  // n2: []
numbers := []int{1, 2, 3}

// 要素の追加
numbers = append(numbers, 6)  // numbers: [1 2 3 6]
numbers = append(numbers[0:3], append([]int{5}, numbers[3:]...)...)  // numbers: [1 2 3 5 6]

// 要素数
fmt.Println(len(numbers)) 

// 要素の削除
numbers = append(numbers[0:2], numbers[3:]...)  // numbers: [1 2 5 6]
numbers = numbers[2:]  // numbers: [5 6]

// 配列を結合
numbers = append(numbers, []int{3, 4, 1, 2}...)  // numbers: [5 6 3 4 1 2]

// 要素の検索
// Pythonのindexに相当するものはないので自分で書く
fmt.Println(IndexOf(numbers, 6))  // 1

func IndexOf(s []int, n int) int { 
    for i, v := range s { 
        if n == v { 
            return i 
        } 
    } 
    return -1
}

// 配列をソート
// sortパッケージを使う
sort.Ints(numbers)
fmt.Println(numbers)  // [1 2 3 4 5 6]
sort.Sort(sort.Reverse(sort.IntSlice(numbers)))
fmt.Println(numbers)  // [6 5 4 3 2 1]

連想配列

Pythonでは辞書(dictionary)と呼ばれるデータ構造を使います。

Python

# 定義
dic = {'hoge': 1, 'fuga': 2, 'piyo': 3}
list1 = [('hoge', 1), ('fuga', 2), ('piyo', 3)]
dic2 = dict(list1)  # dicの値と同じ
dic['hoge']
dic.get('hoge')

# 要素の追加と削除
dic['foo'] = 4
dic.setdefault('bar', 5)
dic.pop('hoge')  # {'fuga': 2, 'piyo': 3, 'foo': 4, 'bar': 5}
del dic['fuga'], dic['piyo']  # {'foo': 4, 'bar': 5}

# 要素数
len(dic)

# キーの存在確認
'foo' in dic

# キーと値の取り出し
list(dic.keys())  # ['foo', 'bar']
list(dic.values())  # [4, 5]
for k, v in dic.items():
    print(k, v)

Goのマップ(map)はPythonの辞書(dictionary)に相当します。以下の書式で定義します。
map[キーの型]要素の型

Go

// 定義
dic := map[string]int{"hoge": 1, "fuga": 2, "piyo": 3}
dic2 := make(map[string]int)
fmt.Println(dic)  // map[fuga:2 hoge:1 piyo:3]
fmt.Println(dic2)  // map[]

// 要素の追加と削除
dic["foo"] = 4
delete(dic, "hoge")
fmt.Println(dic)  // map[foo:4 fuga:2 piyo:3]

// 要素数
len(dic)

// キーの存在確認
_, exist := dic["foo"]
fmt.Println(exist)  // true
if value, exist := dic["foo"]; exist {
    fmt.Println(value)  // 4
}

// キーと値の取り出し
for k, v := range dic {
    fmt.Println(k, v)
}

条件分岐

Pythonには、条件式(三項演算子)と呼ばれる書き方があります。

6.12. 条件式 (Conditional Expressions)
https://docs.python.org/ja/3/reference/expressions.html#conditional-expressions

論理演算子はand,or,notを使用します。

Python

x, y = 1, 2
if x > y:
    print('x > y')
else:
    print('x <= y')

n = 10
# 条件式
result = "positive" if n > 0 else "negative or zero"

Goでは、簡易文付きifという書き方で、そのブロックだけで有効な変数が定義できます。
Goには三項演算子が存在しないが、mapでそれっぽい書き方ができます。
論理演算子は&&,||,!を使用します。

Go

x, y := 1, 2
if x > y {
    fmt.Println("x > y")
} else {
    fmt.Println("x <= y")
}

# 簡易文付きif
if x, y := 1, 2; x > y {
    fmt.Println("x > y")
} else {
    fmt.Println("x <= y")
}

n := 10
# 三項演算子っぽい書き方
result := map[bool]string{true: "positive", false: "negative"}[n > 0]

ループ

Python

sum = 0
for num in range(1, 11):
    sum += num

num, sum = 1, 0
while num <= 10:
    sum += num
    num += 1

# 無限ループ
num, sum = 1, 0
while True:
    sum += num
    num += 1
    if num > 10:
        break

Goのループはforしかないが、whileのような制御もできます。

Go

sum := 0
for num := 0 ; num <= 10 ; num++ {
    sum += num
}

// while
num, sum := 1, 0
for num <= 10 {
    sum += num
    num++
}

// 無限ループ
num, sum := 1, 0
for {
    sum += num
    num++
    if num > 10 {
        break
    }
}

関数

Pythonの関数はdefで定義します。関数の定義が関数呼び出しの実行よりも前に書かなければなりません。
以下のような使い方があります。

• 引数にデフォルト値を持たせることができる
• キーワード引数を使って関数を呼び出すことができる
• 可変長引数を指定することができる
• 複数の戻り値(タプル型)を返すことができる

Python

def greet(name="World"):
    print("Hello, " + name)

greet()
greet("Alice")
greet(name="Alice")

# 可変長変数
def greet(*names):
    for name in names:
        print("Hello, " + name)

greet("Alice", "Bob", "Carol")

# 複数の戻り値
def cal(a, b):
    add = a + b
    mul = a * b
    return add, mul

add, mul = cal(10, 5)

Goの関数はfuncで定義します。
func [関数名]( [引数の定義] ) [戻り値の型] { [関数の本体] }
デフォルト引数もキーワード引数も存在しませんが、以下のような特徴があります。

• Pythonと同様に複数の戻り値や可変長引数をサポートしている
• 戻り値に名前を予め付けることができる。その場合、returnの後ろに返す値を記述する必要がない
• deferキーワードを付けた文は、関数が終了する際に実行される。複数定義した場合は最後の方から呼ばれる

Go

func main() {
    add, mul := cal(10, 5)
    fmt.Println(add, mul) // 15 50
    add, mul = calc(10, 5)
    fmt.Println(add, mul) // 15 50
    greet("Alice", "Bob", "Carol")
    testDefer() // BDCA
}

// 基本形
func cal(a int, b int) (int, int) {
    add := a + b
    mul := a * b
    return add, mul
}

// 名前付き戻り値
// 引数の型が同じ場合はまとめて書ける
func calc(a, b int) (add int, mul int) {
    add = a + b
    mul = a * b
    return 
}

// 戻り値を持たない関数
// 可変長引数
func greet(names ...string) {
    for _, name := range names {
        fmt.Println("Hello,", name)
    }
}

// defer遅延実行
func testDefer() {
    defer fmt.Print("A")
    fmt.Print("B")
    defer fmt.Print("C")  // Aより先にCが出力される
    fmt.Print("D")
}

例外処理

Pythonは例外をキャッチして処理するにはtry-except構文を使用します。

Python

def doDivision(x, y):
    try:
        result = x / y
    except Exception as e:
        result = None
        print("except:" + e.args[0])
    else:  # 正常終了時に実行する
        print("else")
    finally:  # 終了時に常に実行する
        print("finally")
    return result

doDivision(10, 2)
# else
# finally
doDivision(10, 0)
# except:test exception
# finally

Goにはtry-exceptのような例外機構が存在しません。代わりに、関数の戻り値を複数返せる特性を利用して、エラーが発生したかどうか(errorインターフェース)を戻り値の一部として返却することによってエラーの検知を実現しています。
errorインターフェースは以下のように定義されています。
https://golang.org/pkg/builtin/#error

Goのerrorインターフェース

type error interface {
    Error() string
}

以下の例ではerrorsパッケージのNew関数を使ってerror型を生成しています。
また、deferを使うことでPythonのfinallyと同じような動きが実現できます。

Go

package main
import (
    "fmt"
    "errors"
)

func main() {
    _, err := doDivision(10, 2)
    if (err != nil) {
        // エラー処理
    }
    // defer

    _, err = doDivision(10, 0)
    if (err != nil) {
        // エラー処理
    }
    // error
    // defer
}

func doDivision(i, j int) (result int, err error) {
    defer fmt.Println("defer")  // 終了時に常に実行する

    if j == 0 {
        fmt.Println("error")
        err = errors.New("Divided by Zero")
        return
    }
    result = i / j
    return
}

その他、Goにはpanic/recoverというエラー処理の仕組みもありますが、ここでは割愛します。

クラス

以下は、簡単なPythonクラスの例です。

Python

class Player:
    def __init__(self, id, name):
        self.id = id
        self.name = name
        self.__hp = 100

    @property
    def hp(self):
        return self.__hp

    def consume_hp(self, num):
        self.__hp -= num

player = Player(10001, "Alice")
print(player.hp) # 100
player.consume_hp(10)
print(player.hp) # 90

GoにはPythonで言うところのclassに相当する構文は存在しませんが、同じような役割として関連のある変数をひとまとめに扱う構造体(struct)が使用されます。
構造体に対してメソッドを定義することができます。メソッドは関数と違ってレシーバーの型とその変数名が必要になります。
以下の例では*Playerというポインタ型に対してconsumeHpというメソッドを定義しています。

Go

// Player型の構造体
type Player struct{
    ID int
    Name string
    Hp int
}

// コンストラクタ
func newPlayer(id int, name string) Player {
    return Player{ID: id, Name: name, Hp: 100}
}

// *Player型のメソッド
func (p *Player) consumeHp(num int) {
    p.Hp -= num
}

func main() {
    p := newPlayer(10001, "Alice")
    fmt.Println(p.Hp) // 100
    p.consumeHp(10)
    fmt.Println(p.Hp) // 90
}

マルチスレッド

最後は少しだけマルチスレッドについて書きます。
以下はthreadingモジュールを使ってスレッドを生成し、キューでデータを受け渡す簡単な例です。

Python

import threading
import time
from queue import Queue

def worker(a, b, q):
    time.sleep(1)
    result = a + b
    q.put(result)  # キューに要素を入れる
    print("result:", result)

q = Queue()
thread = threading.Thread(target=worker, args=(2, 3, q))
thread.start()
thread.join()

print("main thread")
result = q.get()  # キューから要素を取り出す
q.task_done()
print("received:", result)  # received: 5

同じことをGoで実現してみます。
Goでは軽量スレッドであるゴルーチン(goroutine)が並行して動作するように実装されています。go f(x)と書くと、新たなゴルーチンを起動してその関数を実行します。
ゴルーチンとゴルーチンの間でデータを受け渡しを行うためにチャネル(channel）と呼ばれるデータ構造を使用します。チャネルの型名はchan [データ型]のように書きます。

Go

package main

import (
    "fmt"
    "time"
)

func newThread(a, b int, ch chan int) {
    time.Sleep(1000)
    result := a + b
    ch <- result  // チャネルにデータを送信
    fmt.Println("result:", result)
}

func main() {
    ch := make(chan int)  // チャネルを生成する
    go newThread(2, 3, ch)  // 新たなゴルーチンでnewThreadを実行する

    fmt.Println("main thread")
    result := <-ch  // チャネルからデータを受信
    close(ch)
    fmt.Println("received:", result)  // received: 5
}

最後に

Pythonと比較しながらGo言語の文法を見てきました。
Goは静的型付け言語でありながら、Pythonなど動的型付け言語のような書きやすさもあります。
Goは様々な言語から影響を受けていると言われているように、C言語が分かる人ならばGoにおけるポインタや構造体がすぐ理解できるのではないかと思います。
並行処理に重要な goroutine と channel について詳しく書けませんでしたが、また今度書いてみたいと思います。

この記事はtomowarkar ひとりAdvent Calendar 2019の23日目の記事です。

はじめに

中学で習う点と直線の距離を駆使して円や直線の描画を実装していこうという記事になります。

以下のような画像をフレームワークなどは使わずに生成していきましょう!!

コード

メイン関数(抜粋)

type canvas struct {
    height int
    width  int
    data   []int
}

type point struct {
    x, y, r float64
}

type line struct {
    begin, end point
}

func main() {
    width, height := 1200, 800
    cnv := canvas{height, width, make([]int, width*height)}
    dot1 := point{600, 400, 200}
    dot2 := point{200, 400, 100}
    dot3 := point{400, 200, 100}
    cnv.dot(dot1, blue)
    cnv.dot(dot2, green)
    cnv.dot(dot3, red)

    line1 := line{point{300, 300, 3}, point{550, 730, 1}}
    line2 := line{point{50, 730, 3}, point{550, 730, 1}}
    line3 := line{point{50, 730, 3}, point{300, 300, 1}}
    cnv.line(line1, black)
    cnv.line(line2, black)
    cnv.line(line3, black)
    toPng("name", width, height, 1, palette, cnv.data)
}

やっていることといえば描画範囲であるcanvasと点pointと直線lineをそれぞれ定義して、
任意のポイントにプロットするという作業です。

現状レイヤー分けはしないので、後から描画したものがどんどん上書きされていく形になります。

コード全文

package main

import (
    "image"
    "image/color"
    "image/png"
    "math"
    "os"
)

type canvas struct {
    height int
    width  int
    data   []int
}

type point struct {
    x, y, r float64
}

type line struct {
    begin, end point
}

const (
    white = 0
    black = 1
    blue  = 2
    green = 3
    red   = 4
)

var palette = []color.Color{
    color.RGBA{255, 255, 255, 255},
    color.RGBA{0, 0, 0, 255},
    color.RGBA{100, 100, 225, 255},
    color.RGBA{100, 225, 100, 255},
    color.RGBA{225, 100, 100, 255},
}

func main() {
    width, height := 1200, 800
    cnv := canvas{height, width, make([]int, width*height)}
    dot1 := point{600, 400, 200}
    dot2 := point{200, 400, 100}
    dot3 := point{400, 200, 100}
    cnv.dot(dot1, blue)
    cnv.dot(dot2, green)
    cnv.dot(dot3, red)

    line1 := line{point{300, 300, 3}, point{550, 730, 1}}
    line2 := line{point{50, 730, 3}, point{550, 730, 1}}
    line3 := line{point{50, 730, 3}, point{300, 300, 1}}
    cnv.line(line1, black)
    cnv.line(line2, black)
    cnv.line(line3, black)
    toPng("name", width, height, 1, palette, cnv.data)
}

func max(a, b float64) float64 {
    if a < b {
        return b
    }
    return a
}

func distL(x, y int, l line) bool {
    var xx, yy = float64(x), float64(y)
    var mx, my = (l.begin.x + l.end.x) / 2, (l.begin.y + l.end.y) / 2
    var dx, dy = l.end.x - l.begin.x, l.end.y - l.begin.y
    var b1, b2 = -dy / dx, dx / dy
    var c1, c2 = -(b1*mx + my), -(b2*mx + my)
    var r1, r2 = max(l.begin.r, l.end.r), math.Sqrt(dx*dx+dy*dy) / 2
    var d1, d2 float64
    if dx == 0 || dy == 0 {
        d1 = math.Abs(yy - my)
        d2 = math.Abs(xx - mx)
    } else {
        d1 = math.Abs(yy+b1*xx+c1) / math.Sqrt(1+b1*b1)
        d2 = math.Abs(yy+b2*xx+c2) / math.Sqrt(1+b2*b2)
    }
    if d1 < r1 && d2 < r2 {
        return true
    }
    return false
}

func (c canvas) line(l line, obj int) {
    for y := 0; y < c.height; y++ {
        for x := 0; x < c.width; x++ {
            if distL(x, y, l) {
                c.data[y*c.width+x] = obj
            }
        }
    }
}

func distP(x, y int, p point) bool {
    var dx, dy = p.x - float64(x), p.y - float64(y)
    d := math.Sqrt(dx*dx+dy*dy) / p.r
    if d < 1 {
        return true
    }
    return false
}

func (c canvas) dot(p point, obj int) {
    for y := 0; y < c.height; y++ {
        for x := 0; x < c.width; x++ {
            if distP(x, y, p) {
                c.data[y*c.width+x] = obj
            }
        }
    }
}

func toPng(filename string, width, height, scale int, palette []color.Color, data []int) {
    img := image.NewRGBA(image.Rect(0, 0, width*scale, height*scale))
    for x := 0; x < width*scale; x++ {
        for y := 0; y < height*scale; y++ {
            img.Set(x, y, palette[data[y/scale*width+x/scale]%len(palette)])
        }
    }
    encodePng(img, filename)
}

func encodePng(img *image.RGBA, path string) {
    f, err := os.Create(path + ".png")
    if err != nil {
        panic("encode failed")
    }
    defer f.Close()
    png.Encode(f, img)
}

所感

一番のハマりポイントはやはり線の描画です。

二点から接戦と法線を導出し、その距離によって描画定義をしたのですが、見ての通りに計算が細かくケアレスミスで小一時間詰まってしまいました。

もう少し粒度を細かく実装すればハマりにくくなるので詰まったら粒度を下げることを意識していきたいです。
(今回でいえば法線や接戦を導出する関数を作るなど)

終わりに

まだまだ甘い部分もありますが、もう少しGoでの画像生成で遊んでいけたらと思います。

以上明日も頑張ります！！
tomowarkar ひとりAdvent Calendar Advent Calendar 2019