タイトルの通りのことをやりたかったっぽいので。

例えば、現在のRubyのバージョンはREE 1.8.7だけど、次回リリースからは1.9.3にあげることになっている場合なんか、masterブランチはREE使うけどdevelopブランチは1.9.3で動作させる必要があるっぽいけど、checkoutするたびにrbenv localとかするのダルいしよく忘れるので全力回避したいっぽいです。

で、どうやるかというと、gitのhookでpost-checkoutというのがあり、そこに色々書くとふんわりとやってくれる風味っぽい。

gitリポジトリの.git/hooks/post-checkout をこんな風に書いておくとよいっぽい。

#!/bin/sh# Change ruby versionCURRENT_BRANCH=`git rev-parse --abbrev-ref HEAD`RUBY_VERSION=`git config branch.${CURRENT_BRANCH}.ruby.version`if [$?-ne0];thenRUBY_VERSION=`git config --global ruby.version`fiBUNDLE_GEMFILE=`git config branch.${CURRENT_BRANCH}.ruby.gemfile`if [$?-ne0];thenBUNDLE_GEMFILE=`git config --global ruby.gemfile`fiif [-n"${RUBY_VERSION}"];thenecho"  change local ruby version to ${RUBY_VERSION}"
  rbenv local${RUBY_VERSION}fiif [-n"${BUNDLE_GEMFILE}"];thenecho"  set gemfile to ${BUNDLE_GEMFILE}"export BUNDLE_GEMFILE=${BUNDLE_GEMFILE}fi

使用するRubyのバージョンは、こんな風にglobalな設定と、ブランチ毎の設定をそれぞれやっておく

# globalな設定(systemのrubyを使うっぽい)
git config --gobal ruby.version system

# developの設定
git config --gobal branch.my_cool_branch.ruby.version 1.9.3-p448
git config --gobal branch.my_cool_branch.ruby.gemfile ~/dev/awesome_rails_app/Gemfile.1.9.3

# my_cool_branchの設定
git config --gobal branch.my_cool_branch.ruby.version  2.0.0-p195
git config --gobal branch.my_cool_branch.ruby.gemfile ~/dev/awesome_rails_app/Gemfile.2.0.0

これで、git checkoutした時にpost-checkoutが走って、設定されたバージョンにrbenvで切り替えるっぽい

$ git checkout develop
Switched to branch 'develop'
  change local ruby version to 1.9.3-p448
  set gemfile to ~/dev/awesome_rails_app/Gemfile.1.9.3
$ ruby -v
ruby 1.9.3p448 (2013-06-27 revision 41675) [x86_64-linux]

Rubyのバージョン切替以外に、ブランチ毎になんかしたかったらpost-checkoutに書くとよいっぽい。

git remote rename origin 進捗
git commit -m '進捗ダメです'
git push 進捗

便利

前回から一年以上が経過しているけど、最近lambda_driver.gemに機能を追加したので、そのことについて書こうと思う。
Rubyで、モナ……っぽい関数合成を実装した話だ。

Rubyで関数合成とかしたいので lambda_driver.gem というのを作った - ( ꒪⌓꒪) ゆるよろ日記

(g ∘ f)(x) = g(f(x))

f = lambda{|x| x + 1 }
g = lambda{|x| x * x }

# 合成関数g ∘ f
h = lambda{|x| g.(f.(x)) }

# Proc#>>で合成
h = f >> g

h.(3) # => 16

classPrcodef>>(g)
   # 「自分の計算結果を引数の関数gへ渡す」Procオブジェクトを返すlambda{|x| g.call(self.call(x)) }
  endend

f = lambda{|arr| arr.first } # f: 引数のArrayの最初の要素を取り出す
g = lambda{|x| x + 1 }       # g: 引数に1を加算
h = lambda{|x| x * 2 }       # h: 引数を2倍# f, g, hを合成
i = f >> g >> i

i.([3,5]) # => 4

# []を渡すと
i.([])
# => NoMethodError: undefined method `+' for nil:NilClass

# g, hに引数がnilかチェックを追加した
g = lambda{|x| returnnilif x.nil?; x + 1 } 
h = lambda{|x| returnnilif x.nil?; x * 2 }

i = f >> g >> h

i.([]) # => nil

classProcdef>=(g)
    lambda{|x|
      res = self.call(x)
      # 計算結果がnilならば、後続の関数gを呼び出さずにnilを返すreturnnilif res.nil?
      g.call(res)
    }
  endend

f = lambda{|arr| arr.first }
g = lambda{|x| x + 1 }
h = lambda{|x| x * 2 }

# Proc#>=で合成する
i = f >= g >= h

i.([3,5]) # => 8
i.([])    # => nil

j = lambda{|x| x * 3 }

# 新たに関数jを合成
k = f >= g >= h >= j

k.([3,5]) # => 24

k.([]) # => nil

classProcdeflift(ctx)
    # 引数の「細工」を行うProcオブジェクトをインスタンス変数に設定しておく@ctx = ctx

    # 自身の>=メソッドを定義する(特異メソッド)defself.>=(g)
      lambda{|x|
        # ctxに、合成する関数gと、自身の計算結果を渡して処理を「細工」する@ctx.call(g, self.call(x))
      }.lift(@ctx) # liftの戻り値のProcオブジェクトも同様にliftしておくendselfendend

ctx = lambda{|g,x|
  # 引数の関数gを呼び出す
  res = g.call(x)  

  # 結果を出力する
  puts "g(#{x}) -> #{res}"

  res
}

# Proc#liftで関数合成に細工する
i = f.lift(ctx) >= g >= h

i.call([3,5])
# g(3) -> 4 # ctxから出力# g(4) -> 8 # ctxから出力# => 8

ctx = lambda{|g, x|
  # nilならばgを呼び出さずにnilを返して後続の計算を打ち切るreturn x if x.nil? 
  g.call(x)
}

i = f.lift(ctx) >= g >= h

i.call([4,8]) # => 10

i.call([]) # => nil

cgoとlibv8を使って、タイトルのとおりのものを作ってみた。頑張ればnodeみたいなのをgoで書けるかもﾅｰ。
ʕ　 ﾟ皿ﾟ ʔ cgo楽しいおｼｰｺﾞｫｰ

基本的な方法は以下の記事にあるとおりだが、v8のバージョンが上がっていたりするので、多少の手直しをしてある。

Embedding V8 Javascript Engine and Go | Brave New Method

コードはすべてGithubにある

yuroyoro/golang_v8_Embedding_sample · GitHub

まず、libv8を使う以下のようなwrapperをc++で用意して、cgoから使えるようにしておく。

v8warpper.h

#ifndef _V8WRAPPER_H#define _V8WRAPPER_H#ifdef __cplusplusextern"C" {
#endif// compiles and executes javascript and returns the script return value as stringchar * runv8(constchar *jssrc);

#ifdef __cplusplus
}
#endif#endif// _V8WRAPPER_H

v8warpper.cc

#include <v8.h>#include <string.h>#include "v8wrapper.h"usingnamespace v8;

char * runv8(constchar *jssrc)
{
    // Get the default Isolate created at startup.
    Isolate* isolate = Isolate::GetCurrent();

    // Create a stack-allocated handle scope.
    HandleScope handle_scope(isolate);

    // Create a new context.
    Handle<Context> context = Context::New(isolate);

    // Enter the context for compiling and running the hello world script.
    Context::Scope context_scope(context);

    // Create a string containing the JavaScript source code.
    Handle<String> source = String::New(jssrc);

    // Compile the source code.
    Handle<Script> script = Script::Compile(source);

    // Run the script to get the result.
    Handle<Value> result = script->Run();

    // The JSON.stringify function object
    Handle<Object> global = context->Global();
    Handle<Object> JSON = global->Get(String::New("JSON"))->ToObject();
    Handle<Function> JSON_stringify = Handle<Function>::Cast(JSON->Get(String::New("stringify")));

    Handle<Value> args[] = { result };
    // stringify result
    Local<Value> json = JSON_stringify->Call(JSON, 1, args);

    // Convert the result to an UTF8 string and print it.
    String::Utf8Value utf8(json);

    // return result as string, must be deallocated in cgo wrapperreturn strdup(*utf8);
}

runv8(char)は、引数の文字列のjavascriptをv8で実行し、結果の値をJSON.stringifyした結果の文字列を返す。
なお、サンプルなのでエラー処理はしていない( ;ﾟ皿ﾟ)。

で、こいつを適当にmakeする。以下のmakefileはosx用

Makefile.warpper

V8_INC=/usr/local/Cellar/v8/3.19.18.4/include
V8_LIBDIR=/usr/local/Cellar/v8/3.19.18.4/lib/libv8.dylib

CC=g++
CFLAGS= -I$(V8_INC) -I/usr/include -lv8 -dynamiclib -o $(TARGET)
SOURCES=v8wrapper.cc
OBJECTS=$(SOURCES:.cc=.o) $(V8_DYLIB)
TARGET=libv8wrapper.dylib

all: $(TARGET)


$(TARGET): $(OBJECTS)
	$(CC) $(CFLAGS) $< -o $@

clean:
	rm $(TARGET) $(OBJECTS)

あとは、cgoでこのv8warpperをlinkして使えばいい。

v8runner.go

package main

// #cgo LDFLAGS: -L. -lv8wrapper -lv8  -lstdc++// #include <stdlib.h>// #include "v8wrapper.h"import"C"import (
	"encoding/json""fmt""unsafe"
)

func RunV8(script string, result interface{}) error {

	// convert Go string to nul terminated C-string
	cstr := C.CString(script)
	defer C.free(unsafe.Pointer(cstr))

	// run script and convert returned C-string to Go string
	rcstr := C.runv8(cstr)
	defer C.free(unsafe.Pointer(rcstr))

	jsonstr := C.GoString(rcstr)

	fmt.Printf("Runv8 json -> %s\n", jsonstr)
	// unmarshal result
	err := json.Unmarshal([]byte(jsonstr), result)
	if err != nil {
		return err
	}

	fmt.Printf("Runv8 Result -> %T: %#+v\n", result, result)
	returnnil
}

RunV8では、'encoding/json'を利用して、runv8の戻り値である文字列のJSONを、goの値にunmarshalする。
以下のように文字列でscriptをRunV8関数に渡せばinterface型で結果を取得できる。

package main

import (
	"fmt"
)
func main() {

	scripts := []string{
		"null",
		"true",
		"123",
		"457.78",
		"[10, 20, 30]",
		"'Hello, World'",
		"new Date()",
		`obj = {"foo": [1, 2], "bar": {"baz": true, "hoge": "fuga"}}`,
	}

	for _, s := range scripts {
		fmt.Printf("Script -> %s\n", s)

		var res interface{}
		RunV8(s, &res)
		fmt.Printf("Result -> %T: %#+v\n\n", res, res)
	}
}

実行結果

Script -> null
Result -> <nil>: <nil>

Script -> true
Result -> bool: true

Script -> 123
Result -> float64: 123

Script -> 457.78
Result -> float64: 457.78

Script -> [10, 20, 30]
Result -> []interface {}: []interface {}{10, 20, 30}

Script -> 'Hello, World'
Result -> string: "Hello, World"

Script -> new Date()
Result -> string: "2014-06-11T08:58:43.951Z"

Script -> obj = {"foo": [1, 2], "bar": {"baz": true, "hoge": "fuga"}}
Result -> map[string]interface {}: map[string]interface {}{"foo":[]interface {}{1, 2}, "bar":map[string]interface {}{"baz":true, "hoge":"fuga"}}

このように、JSONをstructにmappingさせることもできる。

package main

import (
	"fmt"
)

type Foo struct {
	Foo []int`json:"foo"`
	Bar Bar   `json:"bar"`
}

type Bar struct {
	Baz  bool`json:"baz"`
	Hoge string`json:"hoge"`
}

func main() {

	script := `obj = {"foo": [1, 2], "bar": {"baz": true, "hoge": "fuga"}}`var result Foo

	fmt.Printf("Script -> %s\n", script)
	RunV8(string(script), &result)
	fmt.Printf("Result -> %T: %#+v\n", result, result)

}

実行結果

Script -> obj = {"foo": [1, 2], "bar": {"baz": true, "hoge": "fuga"}}
Result -> main.Foo: main.Foo{Foo:[]int{1, 2}, Bar:main.Bar{Baz:true, Hoge:"fuga"}}

cgoとLevelDBを使って、タイトルのとおりのものを作ってみた。頑張ればRiakとかInfluxdbみたいなのを書けるかもﾅｰ。
ʕ　 ﾟ皿ﾟ ʔ cgo楽しいおｼｰｺﾞｫｰ

コードはすべてGithubにある。

yuroyoro/leveldb-go-sample · GitHub

なお、この実装はあくまで個人的な練習で作ったものなので、まともにLevelDBをGoから使うならばInfluxdbでも使ってるlevigoがおすすめ。
LevelDBはあらかじめinstallしてある想定。 mac osxなのでbrew install leveldbで入った。

package main

// #cgo LDFLAGS: -lleveldb// #include <stdlib.h>// #include "leveldb/c.h"import"C"import (
	"errors""unsafe"
)

// C Level pointer holdertype LevelDB struct {
	CLevelDB *C.leveldb_t
	Name     string
}

// Open LevelDB with given namefunc OpenLevelDB(path string) (leveldb *LevelDB, err error) {

	cpath := C.CString(path) // convert path to c stringdefer C.leveldb_free(unsafe.Pointer(cpath))

	// allocate LevelDB Option struct to open
	opt := C.leveldb_options_create()
	defer C.leveldb_free(unsafe.Pointer(opt))

	// set open option
	C.leveldb_options_set_create_if_missing(opt, C.uchar(1))

	// open leveldbvar cerr *C.char
	cleveldb := C.leveldb_open(opt, cpath, &cerr)

	if cerr != nil {
		defer C.leveldb_free(unsafe.Pointer(cerr))
		returnnil, errors.New(C.GoString(cerr))
	}

	return&LevelDB{cleveldb, path}, nil
}

// Put key, value to databasefunc (db *LevelDB) Put(key, value string) (err error) {

	opt := C.leveldb_writeoptions_create() // write optiondefer C.leveldb_free(unsafe.Pointer(opt))

	k := C.CString(key) // copydefer C.leveldb_free(unsafe.Pointer(k))

	v := C.CString(value)
	defer C.leveldb_free(unsafe.Pointer(v))

	var cerr *C.char
	C.leveldb_put(db.CLevelDB, opt, k, C.size_t(len(key)), v, C.size_t(len(value)), &cerr)

	if cerr != nil {
		defer C.leveldb_free(unsafe.Pointer(cerr))
		return errors.New(C.GoString(cerr))
	}

	return
}

func (db *LevelDB) Get(key string) (value string, err error) {

	opt := C.leveldb_readoptions_create() // write optiondefer C.leveldb_free(unsafe.Pointer(opt))

	k := C.CString(key) // copydefer C.leveldb_free(unsafe.Pointer(k))

	var vallen C.size_t
	var cerr *C.char
	cvalue := C.leveldb_get(db.CLevelDB, opt, k, C.size_t(len(key)), &vallen, &cerr)

	if cerr != nil {
		defer C.leveldb_free(unsafe.Pointer(cerr))
		return"", errors.New(C.GoString(cerr))
	}

	if cvalue == nil {
		return"", nil
	}

	defer C.leveldb_free(unsafe.Pointer(cvalue))
	return C.GoString(cvalue), nil
}

package main

import (
	"log"
)

type Backend struct {
	db     *LevelDB
	putch  chan putRequest
	delch  chan delRequest
	quitch chanbool
}

type putRequest struct {
	key string
	val string
}

type delRequest struct {
	key string
}

func NewBackend(dbname string) (backend *Backend, err error) {
	db, err := OpenLevelDB(dbname)

	if err != nil {
		return
	}

	log.Printf("LevelDB opened : name -> %s", dbname)

	backend = &Backend{
		db,
		make(chan putRequest),
		make(chan delRequest),
		make(chanbool),
	}

	return
}

func (backend *Backend) Start() {
	gofunc() {
		for {
			select {
			case putreq := <-backend.putch:
				backend.db.Put(putreq.key, putreq.val)
				log.Printf("Backend.Put(%s, %v)\n", putreq.key, putreq.val)
			case delreq := <-backend.delch:
				backend.db.Delete(delreq.key)
				log.Printf("Backend.Delete(%s)\n", delreq.key)
			case<-backend.quitch:
				close(backend.putch)
				close(backend.delch)
				close(backend.quitch)

				log.Printf("Backend stoped")
				return
			}
		}
	}()

	log.Printf("Backend started")
}

func (backend *Backend) Shutdown() {
	backend.quitch <- true
}

func (backend *Backend) Get(key string) (val string, err error) {
	return backend.db.Get(key)
}

func (backend *Backend) Put(key, val string) {
	backend.putch <- putRequest{key, val}

}

func (backend *Backend) Delete(key string) {
	backend.delch <- delRequest{key}
}

package main

import (
	"flag""io/ioutil""log""net/http"
)

func main() {

	// parse command line arguments
	dbname := flag.String("name", "./testdb", "Open the database with the specified name")
	addr := flag.String("addr", ":5050", "listen address")

	flag.Parse()

	// open database and start backend
	backend, err := NewBackend(*dbname)
	if err != nil {
		log.Fatal("can't open database", err)
	}

	backend.Start()
	defer backend.Shutdown()

	// listen and serve http
	http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {

		switch r.Method {
		case"GET":
			HandleGet(w, r, backend)
		case"POST", "PUT":
			HandlePut(w, r, backend)
		case"DELETE":
			HandleDelete(w, r, backend)
		}
	})

	log.Printf("Server listening on : %s", *addr)
	http.ListenAndServe(*addr, nil)
}

func HandleGet(w http.ResponseWriter, r *http.Request, backend *Backend) {
	key := r.URL.Path[len("/"):]

	val, err := backend.Get(key)
	if err != nil {
		w.WriteHeader(http.StatusInternalServerError)
		return
	}

	if val == "" {
		w.WriteHeader(http.StatusNotFound)
		return
	}

	w.WriteHeader(http.StatusOK)
	w.Write([]byte(val))
}

func HandlePut(w http.ResponseWriter, r *http.Request, backend *Backend) {
	key := r.URL.Path[len("/"):]

	defer r.Body.Close()
	val, err := ioutil.ReadAll(r.Body)

	if err != nil {
		w.WriteHeader(http.StatusInternalServerError)
		return
	}

	backend.Put(key, string(val))

	w.WriteHeader(http.StatusCreated)
}

func HandleDelete(w http.ResponseWriter, r *http.Request, backend *Backend) {
	key := r.URL.Path[len("/"):]

	backend.Delete(key)

	w.WriteHeader(http.StatusNoContent)
}

うちのメロンちゃんはLv.117です。

Golangで、簡単なWebアプリケーションをいくつかのフレームワークを用いて作成してみた。
サンプルアプリケーションは、こんな感じのPhotoギャラリーアプリケーションで、画像URLを入力すると追加される。
PureというCSSフレームワークのサンプルから拝借した。

• Photo Gallery – Layout Examples – Pure

ソースコードはGithubで公開している。

yuroyoro/golang_webapp_framework_samples · GitHub

今回試したのは、net/httpパッケージ、Martini、 Revelの3つ。

func main() {
	http.Handle("/css/layouts/", http.StripPrefix("/css/layouts/", http.FileServer(http.Dir("views/css/layouts"))))
	http.HandleFunc("/", indexHandler)
	http.HandleFunc("/save", saveHandler)
	http.ListenAndServe(":5050", nil)
}

func indexHandler(w http.ResponseWriter, r *http.Request) {
	w.WriteHeader(http.StatusOK)  // headerへ200 OKを設定
	io.WriteString(w, "hello, world!\n") // response bodyへwrite

type Body struct {
	First  models.Photo
	Photos []models.Photo
}

func indexHandler(w http.ResponseWriter, r *http.Request) {
	page, err := strconv.Atoi(r.URL.Path[1:])
	if err != nil {
		page = 0
	}

  // databaseから登録されているphotoを読み出す
	body, err := loadBody(page)
	if err != nil {
		panic(err)
	}

  // html/templateでレスポンスを生成して http.ResponseWriterで書き出す
	indexTemplate.Execute(w, body)
}

func init() {
	indexTemplate = template.Must(template.ParseFiles("views/index.html"))
}

{{range $index, $photo := .Photos }}
    {{with $photo}}
        {{if eq $index 4 5 }}
          <divclass="photo-box pure-u-1 pure-u-med-1-2 pure-u-lrg-2-3"><ahref="{{.URL}}"><imgsrc="{{.URL}}"></a><asideclass="photo-box-caption"><span>by <ahref="https://twitter.com/{{.Author}}">@{{.Author}}</a></span></aside></div>
        {{else}}
          <divclass="photo-box pure-u-1 pure-u-med-1-2 pure-u-lrg-1-3"><ahref="{{.URL}}"><imgsrc="{{.URL}}"></a><asideclass="photo-box-caption"><span>by <ahref="https://twitter.com/{{.Author}}">@{{.Author}}</a></span></aside></div>
        {{end}}
    {{end}}
{{end}}

go get github.com/mattn/go-sqlite3
go get github.com/coopernurse/gorp

package models

import (
	"database/sql""errors""github.com/coopernurse/gorp"
	_ "github.com/mattn/go-sqlite3"
)

var DatabaseFile = "photos.db"type Photo struct {
	Id     int64
	URL    string
	Author string
}

func InitDb() (*gorp.DbMap, error) {
	db, err := sql.Open("sqlite3", DatabaseFile)
	if err != nil {
		returnnil, err
	}

	dbmap := &gorp.DbMap{Db: db, Dialect: gorp.SqliteDialect{}}
	dbmap.AddTableWithName(Photo{}, "photos").SetKeys(true, "Id")

	err = dbmap.CreateTablesIfNotExists()
	if err != nil {
		returnnil, err
	}

	return dbmap, nil
}

func (p Photo) Save() error {
	dbmap, err := InitDb()
	if err != nil {
		return err
	}

	defer dbmap.Db.Close()


	// Insert
	dbmap.Insert(&p)
	if err != nil {
		return err
	}

	returnnil
}

func LoadPhotos(page int) ([]Photo, error) {
	dbmap, err := InitDb()
	if err != nil {
		returnnil, err
	}

	defer dbmap.Db.Close()

	if page < 0 {
		returnnil, errors.New("invalid page number")
	}

	limit := 8
	offset := page * limit

	var photos []Photo

	_, err = dbmap.Select(&photos, "SELECT id, url, author FROM photos ORDER BY id DESC LIMIT ? OFFSET ?", limit, offset)
	if err != nil {
		returnnil, err
	}

	return photos, nil
}

package models

import (
	"fmt""testing"
)

func TestSave(t *testing.T) {
	DatabaseFile = "photos_test.db"
	dbmap, err := InitDb()

	if err != nil {
		t.FailNow()
	}

	defer dbmap.Db.Close()

	err = dbmap.TruncateTables()

	if err != nil {
		t.FailNow()
	}

	photo := Photo{
		URL:    "http://example.com",
		Author: "yuroyoro",
	}

	photo.Save()

	var photos []Photo

	_, err = dbmap.Select(&photos, "SELECT id, url, author FROM photos ORDER BY id ASC ")
	if err != nil {
		t.FailNow()
	}

	iflen(photos) != 1 {
		t.Error("Photo.Save() failed")
	}

	if photos[0].URL != photo.URL || photos[0].Author != photo.Author {
		t.Error("Photo.Save() failed")
	}

}

=== RUN TestSave
--- PASS: TestSave (0.01 seconds)
=== RUN TestLoadPhotos
--- PASS: TestLoadPhotos (0.02 seconds)
=== RUN TestModels
Running Suite: Models Suite
===========================
Random Seed: 1402814295
Will run 5 of 5 specs

    •
Ran 5 of 5 Specs in 0.061 seconds
SUCCESS! -- 5 Passed | 0 Failed | 0 Pending | 0 Skipped --- PASS: TestModels (0.06 seconds)
PASS
ok      github.com/yuroyoro/go_shugyo/nethttp/models    0.143s

package models

import (
	"fmt"
	. "github.com/smartystreets/goconvey/convey""testing"
)

func TestConverySave(t *testing.T) {
	Convey("Insert", t, func() {
		DatabaseFile = "photos_test.db"
		dbmap, err := InitDb()

		if err != nil {
			t.FailNow()
		}

		defer dbmap.Db.Close()

		err = dbmap.TruncateTables()

		if err != nil {
			t.FailNow()
		}

		photo := Photo{
			URL:    "http://example.com",
			Author: "yuroyoro",
		}

		photo.Save()

		var photos []Photo

		_, err = dbmap.Select(&photos, "SELECT id, url, author FROM photos ORDER BY id ASC ")
		if err != nil {
			t.FailNow()
		}

		So(len(photos), ShouldEqual, 1)
		So(photos[0].URL, ShouldEqual, photo.URL)
		So(photos[0].Author, ShouldEqual, photo.Author)
	})
}

go get github.com/onsi/ginkgo/ginkgo
go get github.com/onsi/gomega

package models_test

import (
	"fmt"
	. "github.com/onsi/ginkgo"
	. "github.com/onsi/gomega""github.com/coopernurse/gorp""github.com/yuroyoro/go_shugyo/nethttp/models""testing"
)

func TestModels(t *testing.T) {
	RegisterFailHandler(Fail)
	RunSpecs(t, "Models Suite")
}

var _ = Describe("Photo", func() {
	var (
		dbmap *gorp.DbMap
		err   error
	)

	BeforeEach(func() {
		models.DatabaseFile = "photos_test.db"
		dbmap, err = models.InitDb()
		if err != nil {
			panic(err)
		}

		err = dbmap.TruncateTables()
		if err != nil {
			panic(err)
		}
	})

	AfterEach(func() {
		dbmap.Db.Close()
	})

	Describe("Insert", func() {
		It("should inserts new record", func() {
			photo := models.Photo{
				URL:    "http://example.com",
				Author: "yuroyoro",
			}

			photo.Save()

			var photos []models.Photo

			_, err = dbmap.Select(&photos, "SELECT id, url, author FROM photos ORDER BY id ASC ")
			if err != nil {
				Fail("Failed to load records from database")
			}

			Expect(len(photos)).To(Equal(1))
			Expect(photos[0].URL).To(Equal(photo.URL))
			Expect(photos[0].Author).To(Equal(photo.Author))

		})
	})
})

ozaki@mbp-2 ( ꒪⌓꒪) $ ginkgo -v
............Running Suite: Models Suite
===========================
Random Seed: 1402820295
Will run 5 of 5 specs

Photo Insert
  should inserts new record
  /Users/ozaki/dev/go/src/github.com/yuroyoro/golang_webapp_framework_samples/nethttp/models/models_suite_test.go:61
•
------------------------------
Photo LoadPhotos when given page 0
  should returns first page
  /Users/ozaki/dev/go/src/github.com/yuroyoro/golang_webapp_framework_samples/nethttp/models/models_suite_test.go:87
•
------------------------------
Photo LoadPhotos when given page 2
  should returns last page
  /Users/ozaki/dev/go/src/github.com/yuroyoro/golang_webapp_framework_samples/nethttp/models/models_suite_test.go:101
•
------------------------------
Photo LoadPhotos when given page 99
  should returns empty
  /Users/ozaki/dev/go/src/github.com/yuroyoro/golang_webapp_framework_samples/nethttp/models/models_suite_test.go:110
•
------------------------------
Photo LoadPhotos when given page -1
  should returns error
  /Users/ozaki/dev/go/src/github.com/yuroyoro/golang_webapp_framework_samples/nethttp/models/models_suite_test.go:119
•
Ran 5 of 5 Specs in 0.054 seconds
SUCCESS! -- 5 Passed | 0 Failed | 0 Pending | 0 Skipped PASS

Ginkgo ran in 1.521415799s
Test Suite Passed

package main

import (
	"./models""fmt""github.com/codegangsta/martini""github.com/codegangsta/martini-contrib/render""net/http""strconv"
)

func main() {
	m := martini.Classic()

	m.Use(render.Renderer())
	m.Use(martini.Static("views"))

	m.Get("/", func(w http.ResponseWriter, r *http.Request, render render.Render) {
		page, err := strconv.Atoi(r.URL.Path[1:])
		if err != nil {
			page = 0
		}

		body, err := loadBody(page)
		if err != nil {
			panic(err)
		}

		render.HTML(200, "index", body)
	})

	m.Post("/", func(w http.ResponseWriter, r *http.Request, render render.Render) {
		url := r.FormValue("url")
		author := r.FormValue("author")

		if url == "" {
			render.Error(500)
			return
		}

		if author == "" {
			render.Error(500)
			return
		}

		fmt.Printf("Save Photo(%s, %s)", url, author)
		photo := models.Photo{
			URL:    url,
			Author: author,
		}
		photo.Save()

		render.Redirect("/", 302)
	})

	m.Run()
}

m.Get("/", func() (int, string) {
  return418, "i'm a teapot"// HTTP 418 : "i'm a teapot"
})

ozaki@mbp-2(꒪⌓꒪) $ revel
~
~ revel! http://revel.github.io
~
usage: revel command [arguments]

The commands are:

    new         create a skeleton Revel application
    run         run a Revel application
    build       build a Revel application (e.g. for deployment)
    package     package a Revel application (e.g. for deployment)
    clean       clean a Revel application's temp files    test        run all tests from the command-lineUse "revel help [command]" for more information.

ozaki@mbp-2(꒪⌓꒪) $ revel new myapp
~
~ revel! http://revel.github.io
~
Your application is ready:
   /Users/ozaki/dev/go/src/myapp

You can run it with:
   revel run myapp

ozaki@mbp-2(꒪⌓꒪) $ tree .
.
├── app
│   ├── controllers
│   │   └── app.go
│   ├── init.go
│   └── views
│       ├── App
│       │   └── Index.html
│       ├── debug.html
│       ├── errors
│       │   ├── 404.html
│       │   └── 500.html
│       ├── flash.html
│       ├── footer.html
│       └── header.html
├── conf
│   ├── app.conf
│   └── routes
├── messages
│   └── sample.en
├── public
│   ├── css
│   │   └── bootstrap.css
│   ├── img
│   │   ├── favicon.png
│   │   ├── glyphicons-halflings-white.png
│   │   └── glyphicons-halflings.png
│   └── js
│       └── jquery-1.9.1.min.js
└── tests
    └── apptest.go

ozaki@mbp-2(꒪⌓꒪) $ revel run myapp
~
~ revel! http://revel.github.io
~
INFO  2014/06/1516:34:46 revel.go:320: Loaded module static
INFO  2014/06/1516:34:46 revel.go:320: Loaded module testrunner
INFO  2014/06/1516:34:46 run.go:57: Running myapp (myapp)in dev mode
INFO  2014/06/1516:34:46 harness.go:165: Listening on :9000

# Routes
# This file defines all application routes (Higher priority routes first)
# ~~~~

module:testrunner

GET     /                                       App.Index
GET     /photos/*                               Photos.Index
POST    /photos                                 Photos.Save

# Ignore favicon requests
GET     /favicon.ico                            404

# Map static resources from the /app/public folder to the /public path
GET     /css/*filepath                       Static.Serve("public/css")

# Catch all
*       /:controller/:action                    :controller.:action

package controllers

import"github.com/revel/revel"type App struct {
	*revel.Controller
	GorpController
}

func (c App) Index() revel.Result {
	return c.Render()
}

package controllers

import (
	"database/sql""github.com/coopernurse/gorp"
	_ "github.com/mattn/go-sqlite3"
	r "github.com/revel/revel""github.com/revel/revel/modules/db/app"
	m "github.com/yuroyoro/go_shugyo/revel_sample/app/models"
)

var (
	Dbm *gorp.DbMap
)

func InitDB() {
	db.Init()
	Dbm = &gorp.DbMap{Db: db.Db, Dialect: gorp.SqliteDialect{}}

	Dbm.AddTableWithName(m.Photo{}, "photos").SetKeys(true, "Id")

	Dbm.TraceOn("[gorp]", r.INFO)

	err := Dbm.CreateTablesIfNotExists()
	if err != nil {
		panic(err)
	}

	photos := []*m.Photo{
		&m.Photo{URL: "http://24.media.tumblr.com/d6b9403c704c3e5aa1725c106e8a9430/tumblr_mvyxd9PUpZ1st5lhmo1_1280.jpg", Author: "Dillon McIntosh"},
	}

	for _, photo := range photos {
		if err := Dbm.Insert(photo); err != nil {
			panic(err)
		}
	}

}

type GorpController struct {
	*r.Controller
	Txn *gorp.Transaction
}

func (c *GorpController) Begin() r.Result {
	txn, err := Dbm.Begin()
	if err != nil {
		panic(err)
	}
	c.Txn = txn
	returnnil
}

func (c *GorpController) Commit() r.Result {
	if c.Txn == nil {
		returnnil
	}
	if err := c.Txn.Commit(); err != nil&& err != sql.ErrTxDone {
		panic(err)
	}
	c.Txn = nilreturnnil
}

func (c *GorpController) Rollback() r.Result {
	if c.Txn == nil {
		returnnil
	}
	if err := c.Txn.Rollback(); err != nil&& err != sql.ErrTxDone {
		panic(err)
	}
	c.Txn = nilreturnnil
}

package controllers

import (
	"fmt""github.com/revel/revel""github.com/yuroyoro/go_shugyo/revel_sample/app/models""github.com/yuroyoro/go_shugyo/revel_sample/app/routes"
)

type Photos struct {
	App
}

func (c Photos) Index(page int) revel.Result {

	records, err := models.LoadPhotos(c.Txn, page)

	if err != nil {
		panic(err)
	}

	fmt.Println(records)

	first := records[0]
	photos := records[1:]

	return c.Render(first, photos)
}

func (c Photos) Save(photo models.Photo) revel.Result {

	photo.Validate(c.Validation)

	if c.Validation.HasErrors() {
		c.Validation.Keep()
		c.FlashParams()
		return c.Redirect(routes.Photos.Index(0))
	}

	err := c.Txn.Insert(&photo)
	if err != nil {
		panic(err)
	}

	return c.Redirect(routes.Photos.Index(0))
}

  arr = [
    ["foo", "", "bar"], 
    nil,
  ].sample
  
  arr.try(:reject, &:blank?) #=> [“foo”, “bar”]

• Object#tryはnil-safeなcallとして使える
• blockを取るメソッドのsymbolを渡した場合に、第二引数にprocを渡しても動作する

要activesupport.gem
tryと関数合成は本体に入れて欲しい

はじめてのGo Runtime。
ということで、GoのAST(抽象構文木)を可視化するツールを書いた。

yuroyoro/goast-viewer · GitHub

goast.yuroyoro.netにデモがある。

go/astパッケージを使うと、GoのソースコードからAST(抽象構文木)を得ることができる。
あとはこれをAngulerJSとか使ってみて可視化してみただけ。

ソースコードをアップロードするか、入力してparseボタンを押すと、右側にASTが展開される。マウスオーバーするとASTのnodeに該当するコードが選択状態になる。

以下の手順でインストールできるます

$ go get -d github.com/yuroyoro/goast-viewer
$ cd $GOPATH/src/github.com/yuroyoro/goast-viewer
$ make install

GoよりAngulerJSの方が難しかったʕ　 ﾟ皿ﾟ ʔ

3年ほど前に、GitterbというGitリポジトリのコミットログを可視化するツールを作った。

• ぼくのかんがえたさいきょうのGit Repository Browser - ( ꒪⌓꒪) ゆるよろ日記
• Gitterb by yuroyoro
• yuroyoro/gitterb · GitHub

このアプリケーションはRuby1.9/Rails3.2 で書かれていて、今となってはもう動かないので、Ruby2.1/Rails4へupgradeした。

デモサイトはこちら http://gitterb.yuroyoro.net/

依存しているGritというRubyからGitリポジトリをホゲるGemがRuby2系では動かないので、libgit2のRubyバインディングであるRuggedに移行している。

あと、せっかくなのでCentOS7で動くDockerImageを作った。Docker Hubにおいてある。

• yuroyoro/gitterb Repository | Docker Hub Registry - Repositories of Docker Images

以下のようにdocker pullした後にrunすると、port3000でサンプルが起動する。

docker pull yuroyoro/gitterb
docker run -d-p3000:3000-t yuroyoro/gitterb

macでboot2dcoker使ってる人は、port forwardingしてくだされ。

ssh -N-L3000:127.0.0.1:3000 docker@localhost -p2022

( ꒪⌓꒪) あばばばばばばばば

Go lang勉強会 - connpassで発表してきた。
今までにblogに書いたcgoの話。

以下が資料とサンプルコード。

• 資料 : http://yuroyoro.net/trying_cgo/
• サンプルコード : https://github.com/yuroyoro/trying_cgo

久しぶりに人前で発表した気がする。
当日はdemoもやるとなると時間が足りなくなるだろうという予想通りになり、ブランクを感じた。
あと、ネタ成分が不足気味だったのでリハビリしなければならない。

他の人の発表も面白かった。特にライセンスの話など。皆さんお疲れ様でした。

こんな勉強会なら、また参加したいものです。

vimの人はこんな感じで

autocmd FileType go :highlight goErr cterm=bold ctermfg=214
autocmd FileType go :match goErr /\<err\>/

スライドです

本当は怖いオープンクラスとDuckTyping - 表参道.rb #4

まぁたいした話じゃないんですが、マッドマックスの画像をスクリーンに大写しできたのでその点だけで個人的には満足しています

「型を讃えよ」

http://commit-m.minamijoyo.com/:titeleという有名OSSのコミットメッセージを検索できるサービスがあって、英語のコミットメッセージを書くときに「あれ? これどういう風に書けばいいんﾀﾞｰ」ってときに例文を検索できて捗る。

commit-m.minamijoyo.com

が、自分の場合はコミットメッセージ書くときはvimとか git commit -mとかからなのでCLIで検索できたらより捗るかと思ってGolangで書いた。 APIとかは無いようなのでクロールしてる。 GoQuery使えばこの手のクローラーが一瞬でかけるのでよさがある。

github.com

go get github.com/yuroyoro/gommit-mで入れた後に gommit-m keyword [page]で検索できる。

最近Elixirが人気ですよね。ErlangVM上でOTPの恩恵を受けながら簡潔な記法で並行処理を書ける言語ということで話題になっていますな? Elixirは関数型プログラミングのエッセンスを取り入れていると言われており、そのひとつにPipe演算子(|>) がある。

• Enumerables and Streams - Elixir
• Kernel – Elixir v1.1.1

Pipe演算子(|>)とは何かというと、左辺の値を右辺の関数の第1引数に適用する演算子。

iex> [1, [2], 3] |> List.flatten()
  [1,  2,  3]

上記のコードは、左辺の[1, [2], 3]を 右辺の List.fatten(list)の引数として渡す。 このPipe演算子は、Streamモジュールなどと合わせて利用するとデータが左から右へ流れている模様をコードとし視覚化することができるという利点があるっぽい(感じろ)。

iex(16)> f = fn a -> IO.puts "f(#{a}) : #{a+1}"; a ; end
#Function<6.90072148/1 in :erl_eval.expr/5>

iex(17)> g = fn a -> IO.puts "g(#{a}) : #{a*2}"; a * 2 ; end
#Function<6.90072148/1 in :erl_eval.expr/5>

iex(18)> 1..10 |> Stream.map(f) |> Stream.map(g) |> Enum.take(3)
f(1) : 2
g(1) : 2
f(2) : 3
g(2) : 4
f(3) : 4
g(3) : 6
[2, 4, 6]

1..10 |> Stream.map(f) |> Stream.map(g) |> Enum.take(3)というコードで、1から10のStreamに対してlazyに関数fとgを順番に適用しながら3つの要素を取り出すという様を素直に表現できていますね?(思え)

さて、そんな便利なパイプ演算子ですが、実は2年ほど前に作ったlambda_driver.gemに既に実装されていたりする。

• Rubyで関数合成とかしたいので lambda_driver.gem というのを作った - ( ꒪⌓꒪) ゆるよろ日記
• lambda_driver/revapply.rb at master · yuroyoro/lambda_driver · GitHub
  

Rubyでは中置演算子を独自に定義することはできないので、 Objectクラスに ｜＞というメソッドを生やすことで実現しよう(全角ェ)。 素朴な実装はこうだ

classObjectdef｜＞(f = nil)
  puts f
    if block_given?
      yieldselfelse 
      f.call(self)
    endend

  alias_method "｜＞", :>=end

さて、この全角の ｜＞を使って、上記のElixirのコードをRubyで書いてみるとどうなるか?

irb(main):059:0> f = ->(a){ puts "f(#{a}) : #{a + 1}" ; a + 1}
=> #<Proc:0x007ffb8d8b2348@(irb):59 (lambda)>

irb(main):060:0> g = ->(a){ puts "g(#{a}) : #{a *2}" ; a * 2}
=> #<Proc:0x007ffb8d860a98@(irb):60 (lambda)>

irb(main):061:0>  (1..10).｜＞(&:lazy).｜＞{|x| x.map(&f) }.｜＞{|x| x.map(&g) }.｜＞{|x| x.take(3)}.｜＞(&:force)
f(1) : 2
g(2) : 4
f(2) : 3
g(3) : 6
f(3) : 4
g(4) : 8
=> [4, 6, 8]

なんというか、すごく……ダサいですね……。

というか、Rubyだったら素直にこう書いた方がいい

irb(main):143:0> (1..10).lazy.map(&f).map(&g).take(3).force
f(1) : 2
g(2) : 4
f(2) : 3
g(3) : 6
f(3) : 4
g(4) : 8
=> [4, 6, 8]

ごくごくまれに、左辺値がObjectとかでrevapplyを使いたくなることもなきにしもあらずだが、そういう場合でも大抵は Object#tryで事足りる。

結論 : Rubyには必要ないのでは?

Elixir、 |>の右辺が2引数以上の関数のときに、左辺が第一引数に埋め込まれるのが違和感。 1..10 |> Enum.map(&(&1 * 3)) だと、Enumの第一引数はlistなのにぱっと見で関数渡しているように見えてしまうのが気になる

— null (@yuroyoro) October 28, 2015

「関数合成は|>で代用できるよ！」って言ってるけどそうじゃないんだ。合成した後の関数をその場で適用するのではなく値として持ち回りたいんだよ…。あと|>につなげる関数をカリー化させたいんだよ

— null (@yuroyoro) August 26, 2015

Elixirのパイプライン(|>)ってようはOcamlのrevapplyってことか。これがあるのに関数合成やカリー化がないのは本当に惜しい

— null (@yuroyoro) August 26, 2015

カジュアルに関数がカリー化、部分適用できれば|>がもっと輝くのに…

— null (@yuroyoro) October 28, 2015

こんにちわ。しいたけです。今日はディスク使用量をFlameGraphにするツールの話です。

FlameGraphについては、 Flame Graphsや GolangでFlame Graphを描く | SOTAを読んでもらうのが手っ取り早いのですが、ようはプロファイル結果を可視化する方法です。縦軸が呼び出しの階層に、横軸がサンプル数や実行時間などに対応しており、どの関数が支配的かを直感的に見ることができる優れたグラフですよ。

で、このFlameGraph、別にプロファイル結果だけではなく、ツリー構造で各ノードが量を持つ場合に、枝毎の累積量を可視化するのに利用できます。プロファイル以外に、ツリー構造でノードが量を持つ例として、ディレクトリ階層毎のディスク使用量が考えられます。

というわけで、指定ディレクトリ以下のディスク使用量をFlameGraph化するツールを書きました。

GitHub - yuroyoro/du-flamegraph: visualize disk usage as flamegraph

こんな感じのグラフが出力されます

goで書かれており、使い方は、 `go get -u yuroyoro/du-flamegraph` でインストールできます。

このツールは、 FlameGraphの描画に `flamegraph.pl` というスクリプトが必要であり、これは GitHub - brendangregg/FlameGraph: Stack trace visualizerにあります。
これを git cloneなどで手元に入れて、 $PATHに追加するか、 `--flamegraph-script` で位置を指定するかしてやれば、FlameGraph がsvgとして出力されます。

NAME:
   du-flamegraph - visualize disk usage as flamegraph

USAGE:
   du-flamegraph [global options] [FILE]

VERSION:
   0.0.0

GLOBAL OPTIONS:
   --width value, -w value    width of image (default 1200) (default: 1200)
   --height value, -h value   height of each frame (default 16) (default: 16)
   --flamegraph-script value  path of flamegraph.pl. if not given, find the script from $PATH
   --out value                distination path of grenerated flamegraph. default is ./du-flamegraph.svg (default: "./du-flamegraph.svg")
   --verbose                  show verbose log
   --version, -v              print the version

FlameGraph、色々と応用がききそうですね。

こんにちわ。しいたけです。今日はgoroutineの実行状況をいいかんじに可視化するツールの話です。

goのプロファイリングツールと言えば、 runtime/pprofや net/http/pprofですよね。これらの使い方はググればすぐに出てくるのですが、 詳細なtraceを取得して可視化できる runtime/traceについては、日本語の情報が殆ど無いので書いてみましいたけ。

runtime/traceはgoroutineの実行状況やsystem callのイベント、Heapやnetworkの状況をこんな感じに可視化してくれるので便利です。

これは自作のクローラーを動かしている際のtraceを可視化したもので、横軸がタイムラインになっており、上段に Heapの使用状況やgoroutineとos threadの数が, 下段はnetworkやProccesor(GOMAXPROCSで指定するgoroutineの実行環境)毎にどのコードが実行されているか、が表示されます。

Heapやgoroutines数の増減と処理の関連を時系列で追えるので、大まかなボトルネックの特定に便利です。また、各goroutine毎の開始/終了とsystem callやunblockイベント(goroutineの切り替え)を細かく追えるので、goroutineが刺さっている箇所の特定にも役立ちます

右側のboxの↓アイコンをクリックした上で、グラフ上でドラッグするとzoomin/outできます。また、View Options で Flow Eventsをチェックすると矢印が描画されます

ここに、実際に動かせるサンプルを置いておきます。

• http://yuroyoro.net/gotrace01/trace.html
• http://yuroyoro.net/gotrace02/trace.html

これはとある自作Proxyのtraceの一部で、Proc3で実行されている皆さんおなじみの net/http.(*conn).serveがリクエストを受けて、 go 構文で新たなgoroutineを起動してProc2で実行される様子です。このように、どのタイミングでどのgoroutineが動いたのかが一目瞭然です。

これはGCが実行されている様子です。ほとんどのProcでGC関連の処理が動いた後に、上段のHeapのallocatedが減っている様子が見てとれます。

で、このtraceの可視化の方法ですが、 手っ取り早いのは runtime/traceパッケージをimportして、 trace.Start(w io.Writer)と trace.Stop()を呼び出す方法です

https://golang.org/pkg/runtime/trace/

package main

import (
    "log"
    "os"
    "runtime"
    "runtime/trace"
)

func main() {

    f, err := os.Create("trace.out")
    if err != nil {
        log.Fatal(err)
    }
    defer f.Close()

    trace.Start(f)
    defer trace.Stop()

  // do something ...
}

このように、traceを取得したい処理の前後で trace.Startを呼び出すと、結果がファイルに出力されます。 そのファイルを go tool traceコマンドの引数に渡すと、ブラウザで取得したtraceを分析できるようになります。

net/http/pprofパッケージを使っているウェブアプリケーションでも、簡単にtraceを取得することができます。

pprofがlistenしているなら、 /debug/pprof/trace?seconds=5にリクエストを送ると、5秒間のtraceを取得して結果をダウンロードできます。得られたファイルを go tool traceに渡せば、同様にブラウザ上で分析できます。

詳細なボトルネックの分析は、 pprofやgo-torchでのflamegraphの分析が有向ですが、 go tool traceでは時系列に対応しての分析が可能なので、それぞれ状況に合わせて使い分けると良いのではないかと思いましいたけ。

F.Y.I.

• Go Execution Tracer
• go tool trace - Making Pusher

ᕕ( ᐛ )ᕗ こんにちわ、しいたけです。

webのhttps化が推進される昨今ですね?
https通信は経路上での通信内容が盗聴・改竄されるのを防ぐことができますが、開発用途でhttps通信の内容を確認したい場合が稀にあります。
そのような場合は mitmproxyなどを導入すればよいのですが、せっかくなので実際にこのようなProxyをGoで実装してみて、 中間者攻撃(Man-in-The-Middle Attack)がどのような手法でhttps通信を盗聴・改竄するのか確かめてみました。

実際に書いたProxyのコードはこちらです

yuroyoro/mitm_proxy_sample

https proxy と HTTP CONNECT tunneling

まず、通常のhttps Proxyの動作を確認してみましょう。

httpsでは、ProxyはクライアントからのCONNECTメソッドを受信すると、クライアントに代わって対象ホストとのTCPコネクションを確立し、以降はクライアントと対象ホストのTCP通信を転送します。クライアント-ホスト間のTLS接続のhandshakeもproxyを経由して行わます。
この方式により、Proxyを経由しつつクライアント-ホスト間でTLSセッションが確立され、Proxyを経由しつつも経路上では暗号化された通信が可能となります。

図にするとこんな感じです

実装

では具体的な実装を見てましょう。
まずはおなじみ ServeHTTPです。クライアントから CONNECTメソッドが送信されたら、通信を転送する relayHTTPSRequestを呼び出します

https://github.com/yuroyoro/mitm_proxy_sample/blob/master/main.go#L34

func (proxy *MiTMProxy) ServeHTTP(w http.ResponseWriter, r *http.Request) {
  // CONNECT メソッドが来たらif r.Method == http.MethodConnect {
        if proxy.mitm {
            proxy.mitmRequest(w, r)  // Man in The Middleする
        } else {
            proxy.relayHTTPSRequest(w, r) // Tunnelingで通信を転送する
        }
        return
    }

    proxy.transportHTTPRequest(w, r)
}

実際に通信を転送しているコードは以下のとおりです。処理の流れはコメントを読んでもらえばわかると思いますが、やっていることは単純です。
CONNECTメソッドで指定されたホストにTCP接続を張って、クライアントからの通信をそのまま流し込むだけです

https://github.com/yuroyoro/mitm_proxy_sample/blob/master/https.go#L12

func (proxy *MiTMProxy) relayHTTPSRequest(w http.ResponseWriter, r *http.Request) {
    proxy.info("relayHTTPSRequest : %s %s", r.Method, r.URL.String())

    // CONNECT先のHostへTCPコネクションを張る
    dest, err := net.Dial("tcp", r.Host)
    if err != nil {
        http.Error(w, err.Error(), http.StatusServiceUnavailable)
        return
    }

    // http.Hicjacker を利用してクライアントとの生のTCPコネクションを取り出す
    conn := hijackConnect(w)
    // クライアントには200 OKを返す。これでクライアントはこのTCP接続にHTTPリクエストを送ってくる
    conn.Write([]byte("HTTP/1.0 200 OK\r\n\r\n"))

    proxy.info("relayHTTPSRequest : start relaying tcp packets %s %s", r.Method, r.URL.String())

    // クライアント-対象Host間のTCP通信をそのまま中継するgo transfer(dest, conn)
    go transfer(conn, dest)
}

func transfer(dest io.WriteCloser, source io.ReadCloser) {
    defer dest.Close()
    defer source.Close()
    io.Copy(dest, source)
}

Goには http.Hijackerという便利なインターフェースがあり、 http.ResponseWriterから生のクライアントとのTCP接続を取り出すことができます。
これを利用して、TCP通信の転送を行っています

func hijackConnect(w http.ResponseWriter) net.Conn {
    hj, ok := w.(http.Hijacker)
    if !ok {
        panic("httpserver does not support hijacking")
    }

    conn, _, err := hj.Hijack()
    if err != nil {
        panic("Cannot hijack connection " + err.Error())
    }

    return conn
}

実際はtimeoutなどを考慮した実装をすべきなのですが、これだけでも動きます。

Man in The Middel Proxyの仕組み

では、本題の中間者攻撃を行うProxyについてです。

通常のhttps proxyでは、クライアントからの CONNECTメソッドを契機に、対象HostとのTCP通信を中継していました。
Proxyを流れる通信内容はTLSによって暗号化されており、内容を盗聴・改竄することはできません。

しかし、対象Hostとクライアント間のTLS handshakeもProxyを経由するので、この段階でクライアントからのTLS handshakeを、対象ホストになりすましてProxyが行うとどうなるでしょうか？
つまり、Proxyは対象ホストのサーバー証明書をその場で生成して署名し、クライアントに提示します。
もちろん、Proxyが署名したサーバー証明書は信頼できないCAのものとしてブラウザには警告が出ますが、そのままユーザーが続行することでTLS handshakeが成功します。
クライアントは確立したTLS接続を対象ホストとのものだと思いこんで、Proxyがクライアントに送り込んだニセのサーバー証明書の公開鍵で通信を暗号化するので、Proxyはその内容を復号することができます。
あとは、復号したリクエストをそのまま対象のホストに転送すれば、httpsにも関わらずProxyは通信内容を把握しつつ、対象ホストとの通信を取り持つことができてしまいます。
これで中間者攻撃が成立しますʕ　 ﾟ皿ﾟ ʔ 。

図にすると以下の流れとなります

通常、このような攻撃はブラウザが警告を出すために成立しません。
まず、ユーザーが明示的にブラウザにProxyを指定する必要がありますし(port forwardを利用した透過Proxyはその限りではない)、Proxyが署名に使用するルート証明書(または中間証明書)がTrust Chainにないからです。
逆に言えば、信頼できないルート証明書をシステムにインストールしてしまうと、このような攻撃が成立する余地が生まれてしまいます。

実際に、一部のセキュリティアプライアンスやアンチウィルスソフトウェアは、このような手法でhttps通信の内容をチェックしています。
Avastを入れた状態でブラウザで証明書チェーンを確認すると、 「Avast trusted CA」という謎の認証局が出現するのはこのためです( ;ﾟ皿ﾟ)ﾉｼΣ ﾌｨﾝｷﾞｨｨｰｰｯ!!!

以前、LenovoのPCにプリインストールされたアドウェア「Superfish」がルート証明書をシステムにインストールした上に、全PCで共通のCA秘密鍵を使っていたことで大問題になりましたね。
Dellでも似たようなことがあったみたいです( ꒪⌓꒪)

LenovoのPC全機種にプレロードされているアドウェアが実は恐ろしいマルウェアだった！ | TechCrunch JapanDellのPCに不審なルート証明書、LenovoのSuperfishと同じ問題か - ITmedia エンタープライズ

実装

それでは具体的な実装の解説を行います。処理の流れは以下のとおりです。

1. CONNECTメソッドのリクエストから、http.Hijackerを使って生のTCPコネクションを取り出す
2. クライアントには200 okを返す
3. 接続先ホストの証明書を、予め用意してあるroot証明書でサインして生成する
4. 生成した証明書でクライアントとtls接続を確立する (root証明書が登録されていないとブラウザで警告が出る)
5. goroutine起こして、クライアントとのtls接続からhttp requestを読み込む
6. 受けたhttp requestをそのまま接続先hostに送信する
7. 接続先hostからのhttp responseを、クライアントtls接続に書き込む
8. EOFが来るまで 5-7繰り返し

https://github.com/yuroyoro/mitm_proxy_sample/blob/master/https.go#L57

func (proxy *MiTMProxy) mitmRequest(w http.ResponseWriter, r *http.Request) {
    // http.Hicjacker を利用してクライアントとの生のTCPコネクションを取り出す
    conn := hijackConnect(w)
    // クライアントに200 OKを返しておく
    conn.Write([]byte("HTTP/1.0 200 OK\r\n\r\n"))

    // 以降の処理はgoroutine上で行うgo proxy.transportHTTPSRequest(w, r, conn)
}

func (proxy *MiTMProxy) transportHTTPSRequest(w http.ResponseWriter, r *http.Request, conn net.Conn) {
    proxy.info("transportHTTPSRequest : %s %s", r.Method, r.URL.String())

    // 対象ホストのニセのサーバー証明書を生成して署名する
    host := r.Host
    tlsConfig, err := proxy.generateTLSConfig(host)
    if err != nil {
        if _, err := conn.Write([]byte("HTTP/1.0 500 Internal Server Error\r\n\r\n")); err != nil {
            proxy.error("Failed to write response : %v", err)
        }
        conn.Close()
    }

    // クライアントとのTCP接続上で、ニセのサーバー証明書を利用してTLS接続を待ち受ける
    tlsConn := tls.Server(conn, tlsConfig)
    if err := tlsConn.Handshake(); err != nil {
        proxy.error("Cannot handshake client %v %v", r.Host, err)
        return
    }
    defer tlsConn.Close()

    proxy.info("transportHTTPSRequest : established tls connection")

    // ニセの証明書で確立したTLS接続上でクライアントからのリクエストを読み込む
    tlsIn := bufio.NewReader(tlsConn)
    for !isEOF(tlsIn) {
        req, err := http.ReadRequest(tlsIn) // http.Requestオブジェクトとして通信を読み込むif err != nil {
            if err == io.EOF {
                proxy.error("EOF detected when read request from client: %v %v", r.Host, err)
            } else {
                proxy.error("Cannot read request from client: %v %v", r.Host, err)
            }
            return
        }

        proxy.info("transportHTTPSRequest : read request : %s %s", req.Method, req.URL.String())

        // 転送用にURLやヘッダーなどを設定
        req.URL.Scheme = "https"
        req.URL.Host = r.Host
        req.RequestURI = req.URL.String()
        req.RemoteAddr = r.RemoteAddr

        dumpRequest(req)
        removeProxyHeaders(req)

        // http.RoundTripper で受信したリクエストを対象ホストに転送し、レスポンスを受け取る
        resp, err := proxy.transport.RoundTrip(req)
        if err != nil {
            proxy.error("error read response %v %v", r.URL.Host, err.Error())
            if resp == nil {
                http.Error(w, err.Error(), 500)
                return
            }
        }

        proxy.info("transportHTTPSRequest : transport request: %s", resp.Status)

        dumpResponse(resp)

        // レスポンスをクライントへのTLS接続に書き込む
        resp.Write(tlsConn)
    }

    proxy.info("transportHTTPSRequest : finished ")
}

ポイントは、 リクエストを受けるとニセのサーバー証明書をその場で生成して、その証明書と http.Hijackerで取り出したクライントのTCPで tls.Serverを用いてTLS接続をなりすますことです(生成した証明書はキャッシュします)。
証明書の生成は長くなるのでここには載せませんが、 こちらを見てもらえばと思います。

クライントとのTLS接続を乗っ取れば、あとはその接続上でHttpリクエストを読み込み、対象ホストに転送すればOKです。Goでは、 http.RoundTripperを利用すれば http.Requestをそのまま転送できるので便利です。その際に、リクエスト・レスポンスの内容をdumpしています。
悪意があれば、この段階で改竄も可能でしょう。

まとめ

以上が、Man-in-The-Middle Attackを行う簡単なProxyの実装です。この攻撃が成功する条件としては、

• 経路上にこのようなProxyが存在する (https通信がport forwardされている場合もある)
• Proxyが署名に使うルート証明書がTrust Chainに存在する

の2点です。特に2点目はTLSの根幹をなす部分で、それゆえにルート証明書の管理は厳格に行う必要があり、GoogleはSymantecの証明書を無効にし、LenoveやDellは責められるべきなのです。Avastもちょっとどうかと思います。

実際に手を動かして実装してみると、Proxyの実装で注意スべき点や、TLSと認証局の仕組みとか色々と学びがあり、よかったとおもいました( ꒪⌓꒪)

こんにちは、しいたけです。

某所で関数型プログラミングとはリスト処理のことなのか、と燃えているのを見て、関数型プログラミングとは何か、ということを自分なりの考えを述べたいと思いました。春なので。

この資料は2年ほど前にSupershipの社内勉強会で使ったものですが、この中で関数とオブジェクトを対比している箇所があります。 関数もオブジェクトも、変数や関数の引数戻り値として扱える第1級の値であり、状態を持ち(メンバー変数/クロージャ)、組み合わせが可能(delegate, composition/関数合成)、である、と。

ではオブジェクト指向と関数型プログラミングで何が決定的に異なるかというと、設計・実装のアプローチに何を中心に据えるか、ということだと思います。

オブジェクト指向では、クラス・オブジェクトをモデリングし、各種のオブジェクト指向的デザインパターンを用いてオブジェクト同士を組み合わせながら設計・実装を行います。 関数型プログラミングでは、関数を細かな組み合わせ可能な単位に分解し、関数合成、再帰、クロージャなどを駆使しながら組み合わせることで設計・実装します。

こう書いてみると当たり前のことですが、コードの記述スタイルだけ議論しても意味がなくて、そのような記述はプログラム全体を貫く思想のなかでどのような位置づけにあるのかのコンテキストが重要なのではないでしょうか。 例えば、Goでは無理して無名関数を用いたリスト処理を書くより、forで書くほうがはるかに自然ですよね。 JavaScriptでは……どうでしょうか、色々なスタイルで書けるので議論が紛糾するのかも。

map/reduceを使ったリスト処理が関数型プログラミングの全てかというとそうではなく、あくまで関数を中心に据えた考えた方の一つとして、遅延評価 + 高階関数/クロージャの組み合わせによるストリームライクな実装がある、ということだと思います。 関数を中心に据えると、「何をフィルターするか」「要素をどのように変換するか」という処理の単位が関数として抽出され、その組み合わせ方法として遅延評価リストと高階関数を用いる方法がある、というだけです。 結果、関数を中心にすえたアプローチではmap/reduceを使う記述が自然と導かれます。 とはいえ、 リスト処理の実装としては再帰を使う方法もあるので、あくまで関数型プログラミングによるリスト処理の1アプローチにすぎません。

どちらのスタイルで書くのがよいか、というのに絶対的な正解はないと思いますが、関数を中心としたアプローチを知っていると、手続き型のプログラムを書いていても思わぬ場面で役に立つことがあります。 ちょうど最近役にたった実体験のひとつで、 ある rspecのパフォーマンスチューニングの際に遅延評価が役にたったことがあります。

error_msg = generate_error_message(actual_value, expected_value)
expect(actula_value).to have_content(expected_value),  error_msg

こんな感じのrspecのコードで、 assertのエラー時に表示する error_msgを生成する generate_error_messageが非常にコストの掛かる処理でした。 通常はassertに失敗する場合の方が稀なので、必要になるまで(assertに失敗するまで) この処理の呼び出しを遅延させることで性能が改善しそうです。

rspecの expectはエラーメッセージの代わりに Procを渡すことが可能です。 そこで、エラーメッセージを生成する処理をクロージャとして抽出し、 expectに渡すことで遅延評価させることができます。

error_msg_generator = ->() { generate_error_message(actual_value, expected_value) }
expect(actula_value).to have_content(expected_value),  error_msg_generator

関数型プログラミングの知識があると、 expectの引数が Procを取る、というシグニチャから、遅延評価による性能改善に利用する発想が導かれます。 このように、関数型プログラミングは通常の手続き型プログラミングでもおおいに役立ちますので、双方それぞれの手法を学んでおくとプログラミングの裾野が広がりま。 これが、ぼくが関数型プログラミングを学ぶことをオススメする理由です。

まとめ

• 関数型プログラミングとは「関数を中心としたアプローチ」
• リスト処理は関数型プログラミングの一側面
• どっちがよいかはケースバイケース
• 関数型プログラミングを知っているとプログラミングの裾野が広がるよ

しいたけおいしいです。

タイトルで全部言い切ってますが

// Optional container like maybe monad class Option {
  constructor(value){this.value = value
  }

  async promise() {returnnew Promise((resolve, reject) => {if (this.value) {
        resolve(this.value);
      }else{
        reject(undefined);
      }});
  }}

こんなMaybe とかOptionalっぽいやつを用意します。 promise()で Promiseを生成して返すようにします。もってる値に応じて resolve (JustやSome)したり reject (Nothing)したりします。

const o1 = new Option("foo");
const o2 = new Option("bar");
const o3 = new Option(null);

(async () => {try{const v1 = await o1.promise();
    const v2 = await o2.promise();

    console.log(v1, v2);
  }catch{}})(); // => foo bar

(async () => {try{const v1 = await o1.promise();
    const v2 = await o2.promise();
    const v3 = await o3.promise();

    console.log(v1, v2, v3);
  }catch{}})(); // do nothing// introduce doM emulates do-like syntax sugar 
async function doM(f1, f2) {try{return f1();
  }catch{if (f2) {return f2();
    }}}// => foo bar

asyncの中で、 promise()を awaitで呼び出すことで、 do記法っぽいあれ……に見えなくもなくないコードになりました。でも失敗系処理しない場合でも catch書く必要あるのダルいですね？ try..catchを変わりにやってくれるヘルパーを導入しましょう

// introduce doM emulates do-like syntax sugar 
async function doM(f1, f2) {try{return f1();
  }catch{if (f2) {return f2();
    }}}

この doMに asyncな無名関数を渡すと、その中でdo記法っぽいあれ……に見えなくもなくないコードを書けます。

doM(async () => {const v1 = await o1.promise();
  const v2 = await o2.promise();

  console.log(v1, v2);
}); // => foo bar

doM(async () => {const v1 = await o1.promise();
  const v2 = await o2.promise();
  const v3 = await o3.promise();

  console.log(v1, v2, v3);
}); // do nothing

だからどうしたって話ですが、いろいろなモナドを作って合成して扱う場合に便利かもしれないですがそもそもモナドとかJavaScriptで作るな。以上

こんにちわ、しいたけです。

今は夏休みで奥さんと子どもたちが帰省しているので、動物と2人で暮らしています。

で、外出すると動物だけを家に残していくことになります。 ペットモニターとか市販でもあるんですが、せっかくなので、 夏休みの自由研究として、ラズパイ+カメラモジュールとWebRTCを使って、外出先からでも動物の状態を確認できるやつを作ってみました。

↑ 死活監視される動物の様子です

用意したもの

• Pi3 B+ スターターキット V3 16GB 白
• Piカメラ Official V2 for 3/2/1/0
• Manfrotto ミニ三脚 PIXI ブラック MTPIXI-B カメラ用
• Manfrotto スマートフォン用三脚アダプター MCLAMP
• HAKUBA 自由雲台 BH-1

ラズパイ3とケースのセットとカメラモジュールは Raspberry Pi Shop by KSYで購入。期間限定セールでちょっと安かったです。 このセットについてるケースは、ラズパイのマークの穴にカメラモジュールを固定することができて便利。 時雨堂のmomoだと、Raspberry Piの GPUのH.264ハードウェアエンコーダー機能を利用できるらしいので、ラズパイzeroでも行けるらしいです。

で、ラズパイを三脚とスマホ用アダプタで固定します。こんな感じになる。

ラズパイの初期設定

まずはラズパイの初期設定でOSインストール。購入したキットのSDカードにすでにOSが用意されているので、電源入れて画面の通りにセットアップすれば終了。

Raspberry Pi 3 Model B+の初回セットアップ（購入から起動まで） - Qiita

あとは、sshとカメラモジュールをconfigから有効にしておく。

Raspberry Piカメラのセットアップ方法

最後に、mDNSとssh周りの設定を行って、GUIをオフにして完了。これで手元のmacbookからsshで接続して作業できるようになった。

手持ちのRaspberryPiをサクッとmDNSに対応させる - Qiita

WebRTC Native Client Momo

時雨堂の WebRTC Native Client Momoを使います。あっさり接続できて最高でした。

Githubのリリースページから最新のバイナリがtarで配布されているので、ダウンロードして解凍するだけです。

必要なライブラリを入れて、

$ sudo apt-get install libnspr4 libnss3

あとはバイナリを実行するだけで、ラズパイのカメラモジュールを利用したストリーミングが可能になります。

$ ./momo --no-audio ayame wss://ayame-lite.shiguredo.jp/signaling <your-github-id>@<your-room-name> --signaling-key <your-signaling-key>

起動時のオプションは、シグナリングサーバーにAyameとそのURL、そしてルームIDを指定します。また、次で説明するシグナリングキーもわたします。

時雨堂 WebRTC シグナリングサービス Ayame Lite

WebRTCにおいてNAT超えで通信を行うにあたって、シグナリングサーバを介してそれぞれのピアの接続の調整を行う必要がある。 時雨堂がWebRTC の P2P利用向けに無料で利用できるシグナリングサービスを提供してくれているので、ありがたく使わせていただきます。

WebRTC シグナリングサービス Ayame Lite 開発ログ

P2Pで接続できる場合には、特に登録も必要なく使えます。4G回線の場合などTURNサーバーを経由する必要がある場合は、ベータテスト中のシグナリングキーを利用してTURNサーバーの払い出しをしてもらう必要があります。 Githubアカウントでサインアップすると、シグナリングキーが発行されてTURN サーバの利用が可能になります。

STUN/TURNについてはこのあたり参照

• WebRTCの裏側
• 壁を越えろ！WebRTCでNAT/Firewallを越えて通信しよう | HTML5Experts.jp

4Gでつながらないとtwitterで囀っていたところ、 @voluntasにベータ版使ってみる? とお誘いを受けたので、ありがたく使わせてもらいました。 ちょうどオープンベータが始まったところでした。

Ayame Lite オープンベータテスト開始しました - shiguredo - Medium

こちらからGithubアカウントでサインアップできます。

Ayame Lite

時雨堂最高では?

クライアント側の実装

あとは、クライアントを準備して接続です。手っ取り早く試してみるのに、 OpenAyame/ayame-react-sample: Ayame React サンプルを利用しました。 上記のリポジトリを git cloneしたあと、 yarn installして yarn serveすると、localhostで動作確認ができます。

こんな感じで、AyameのURLと、自分で指定したルームID、シグナリングキーを入力して接続を押すと、ストリーミングでラズパイ側のカメラから配信されていることが確認できます。

iOSSafariの場合は再生ボタンを押す必要があるとのことで、videoタグに controlsを追加して対応しました。

<Videos>
  <RemoteVideo ref={remoteVideoRef} muted autoPlay controls/>
</Videos>

その他調整

まず、クライアントのアセット一式を適当な場所から配信できるようにします。 yarn buildしてできた成果物をさくらVPSにnginxを立ててﾚｯﾂをｴﾝｸﾘﾌﾟﾄしてhttpsで配信できるようにしました。 httpsで配信できる場所なら、cloudfrontとかNetlifyとかでもいいと思います。

あとは、ラズパイ側のmomoをsystemdのサービスとして設定して起動時に起きるようにすれば終わりです。

Raspberry Pi で systemd を使ってプログラムを自動実行する - Qiita

まとめ

ラズパイでWebRTCするにあたって、当初は NTTコムさんの提供する Skywayとそのsdkを試してみたのですが、どうもデモが上手く動作しませんでした。 時雨堂のmomoとOpenAyameを使ってみたところ、バイナリを落としてきてドキュメントの手順通りに進めるだけであっさり接続できてしまいました。

これで外出時でも動物の様子を死活監視ができて捗る。

時雨堂最高では?