lake log

Go Currency Patterns - Pooling

2021-05-09T00:00:00+00:00

버퍼가 있는 채널을 이용하여 공유가 가능한 리소스의 풀을 생성하고, 이 리소스들을 원하는 개수만큼의 고루틴에서 개별적으로 활용할 수 있는 기능을 작성한 코드가 모여있다. 이 패턴은 데이터베이스 연결이나 메모리 버퍼 등 공유되는 리소스의 정적인 집합을 관리할 때 특히 유용하다. 고루틴이 이런 리소스 중 하나를 사용해야 할 경우에는 리소스를 할당받고 사용한 후 다시 풀에 반환하는 구조로 동작한다.(풀 사이즈 초과시 생성&사용후 폐기)

일종의 컨텍스와 같은 성격의 공유 풀을 생성하고 풀내 팩토리 메서드를 두어 공유 객체를 생성/재사용 한다. 불필요한 전역객체(컨텍스트) 생성을 하지 않고 공유객체를 보다 우아하게 전달하고 관리 할 수 있다.

pool.go

// 사용자가 정의한 리소스의 집합을 관리하는 패키지
package pool

import (
	"errors"
	"io"
	"log"
	"sync"
)

// Pool 구조체는 여러 개의 고루틴에서 안전하게 공유학 위한 리소스의 집합을 관리한다.
// 이 풀에서 관리하가 위한 리소스는 io.Closer 인터페이스를 반드시 구현해야 한다.
type Pool struct {
	m         sync.Mutex
	resources chan io.Closer
	factory   func() (io.Closer, error)
	closed    bool
}

// ErrorPoolClosed 에러는 리소스를 획득하려 할 때 풀이 닫혀있는 경우에 발생한다.
var ErrPoolClosed = errors.New("풀이 닫혔습니다.")

// New 함수는 리소스 관리 풀을 생성한다.
// 풀은 새로운 리소스를 할당하기 위한 함수와 풀의 크기를 매개변수로 정의한다.
func New(fn func() (io.Closer, error), size uint) (*Pool, error) {
	if size <= 0 {
		return nil, errors.New("풀의 크기가 너무 작습니다.")
	}

	return &Pool{
		factory:   fn,
		resources: make(chan io.Closer, size),
	}, nil
}

// 풀에서 리소스를 획득하는 메서드
func (p *Pool) Acquire() (io.Closer, error) {
	select {
	// 사용 가능한 리소스가 있는지 검사한다.
	case r, ok := <-p.resources:
		log.Println("리소스 획득:", "공유된 리소스")
		if !ok {
			return nil, ErrPoolClosed
		}
		return r, nil

	// 사용 가능한 리소스가 없는 경우 새로운 리소스를 생성한다.
	default:
		log.Println("리소스 획득:", "새로운 리소스")
		return p.factory()
	}
}

// 풀에 리소스를 반환하는 메서드
func (p *Pool) Release(r io.Closer) {
	// 안전한 작업을 위해 잠금을 설정한다.
	p.m.Lock()
	defer p.m.Unlock()

	// 풀이 닫혔으면 리소스를 해제한다.
	if p.closed {
		r.Close()
		return
	}

	select {
	// 새로운 리소스를 큐에 추가한다
	case p.resources <- r:
		log.Println("리소스 반환:", "리소스 큐에 반환")

	// 리소스 큐가 가득 찬 경우 리소스를 해제한다.
	default:
		log.Println("리소스 반환:", "리소스 해제")
		r.Close()
	}
}

// 풀을 종료하고 생성된 모든 리소스를 해제하는 메서드
func (p *Pool) Close() {
	// 안전한 작업을 위해 잠금을 설정한다
	p.m.Lock()
	defer p.m.Unlock()

	// 풀이 이미 닫혔으면 아무런 작업도 수행하지 않는다.
	if p.closed {
		return
	}

	// 풀을 닫힌 상태로 전환한다.
	p.closed = true

	// 리소스를 해제하기에 앞서 채널을 먼저 닫는다.
	// 그렇지 않으면 데드락에 걸릴 수 있다.
	close(p.resources)

	// 리소스를 해제한다.
	for r := range p.resources {
		r.Close()
	}
}

main.go

// pool 패키지를 이용하여 데이터베이스 연결 풀을 생성하고 활용하는 예제
package main

import (
	"github.com/younghyun-ahn/go-currency-patterns/pooling/pool"
	"io"
	"log"
	"math/rand"
	"sync"
	"sync/atomic"
	"time"
)

const (
	maxGoroutines   = 50 // 실행할 수 있는 고루틴의 최대 개수
	pooledResources = 10  // 풀이 관리할 리소스의 개수
)

// 공유 자원을 표한한 구조체
type dbConnection struct {
	ID int32
}

// dbConnection 타입의 풀에 의해 관리될 수 있도록 io.Closer 인터페이스를 구현한다.
// Close 메서드는 자원의 해제를 담당한다.
func (dbConn *dbConnection) Close() error {
	log.Println("닫힘: 데이터베이스 연결", dbConn.ID)
	return nil
}

// 각 데이터베이스에 유일한 id를 할당하기 위한 변수
var idCounter int32

// 풀이 새로운 리소스가 필요할 때 호출할 팩토리 메서드
func createConnection() (io.Closer, error) {
	id := atomic.AddInt32(&idCounter, 1)
	log.Println("생성: 새 데이터베이스 연결", id)

	return &dbConnection{id}, nil
}

// 애플리케이션 진입점
func main() {
	var wg sync.WaitGroup
	wg.Add(maxGoroutines)

	// 데이터베이스 연결을 관리할 풀을 생성한다.
	p, err := pool.New(createConnection, pooledResources)
	if err != nil {
		log.Println(err)
	}

	// 풀에서 데이터베이스 연결을 가져와 질의를 실행한다.
	for query := 0; query < maxGoroutines; query++ {
		// 각 고루틴에는 질의 값의 복사본을 전달해야 한다.
		// 그렇지 않으면 고루틴들이 동일한 질의 값을 공유하게 된다.
		go func(q int) {
			performQueries(q, p)
			wg.Done()
		}(query)
	}

	// 고루틴의 실행이 종료될 때까지 대기한다.
	wg.Wait()

	// 풀을 닫는다.
	log.Println("프로그램을 종료합니다.")
	p.Close()
}

// 데이터베이스 연결 리소스 풀을 테스트한다.
func performQueries(query int, p *pool.Pool) {
	// 풀에서 데이터베이스 연결 리소스를 획득한다.
	conn, err := p.Acquire()
	if err != nil {
		log.Println(err)
		return
	}

	// 데이터베이스 연결 리소스를 다시 풀로 되돌린다.
	defer p.Release(conn)

	// 질의문이 실행되는 것처럼 얼마 동안 대기한다.
	time.Sleep(time.Duration(rand.Intn(5)) * time.Second)
	log.Printf("질의: QID[%d] CID[%d]\n", query, conn.(*dbConnection).ID)
}

실행 결과

❯ go build -race pooling/main.go
❯ main
2021/05/09 15:52:51 리소스 획득: 새로운 리소스
2021/05/09 15:52:51 생성: 새 데이터베이스 연결 1
2021/05/09 15:52:51 리소스 획득: 새로운 리소스
2021/05/09 15:52:51 리소스 획득: 새로운 리소스
2021/05/09 15:52:51 생성: 새 데이터베이스 연결 2
2021/05/09 15:52:51 리소스 획득: 새로운 리소스
2021/05/09 15:52:51 생성: 새 데이터베이스 연결 3
2021/05/09 15:52:51 리소스 획득: 새로운 리소스
2021/05/09 15:52:51 생성: 새 데이터베이스 연결 5
2021/05/09 15:52:51 리소스 획득: 새로운 리소스
2021/05/09 15:52:51 리소스 획득: 새로운 리소스
2021/05/09 15:52:51 리소스 획득: 새로운 리소스
2021/05/09 15:52:51 리소스 획득: 새로운 리소스
2021/05/09 15:52:51 리소스 획득: 새로운 리소스
2021/05/09 15:52:51 생성: 새 데이터베이스 연결 9
2021/05/09 15:52:51 리소스 획득: 새로운 리소스
2021/05/09 15:52:51 생성: 새 데이터베이스 연결 11
2021/05/09 15:52:51 리소스 획득: 새로운 리소스
2021/05/09 15:52:51 생성: 새 데이터베이스 연결 10
2021/05/09 15:52:51 리소스 획득: 새로운 리소스
2021/05/09 15:52:51 질의: QID[24] CID[10]
2021/05/09 15:52:51 생성: 새 데이터베이스 연결 13

2021/05/09 15:52:51 리소스 획득: 공유된 리소스

2021/05/09 15:52:51 리소스 획득: 새로운 리소스
2021/05/09 15:52:51 생성: 새 데이터베이스 연결 14
2021/05/09 15:52:51 질의: QID[38] CID[14]
2021/05/09 15:52:51 리소스 획득: 새로운 리소스
2021/05/09 15:52:51 리소스 획득: 새로운 리소스
2021/05/09 15:52:51 생성: 새 데이터베이스 연결 16
2021/05/09 15:52:51 리소스 획득: 새로운 리소스
2021/05/09 15:52:51 리소스 획득: 새로운 리소스
2021/05/09 15:52:51 생성: 새 데이터베이스 연결 18
2021/05/09 15:52:51 생성: 새 데이터베이스 연결 4
2021/05/09 15:52:51 리소스 획득: 새로운 리소스
2021/05/09 15:52:51 생성: 새 데이터베이스 연결 19
2021/05/09 15:52:51 리소스 획득: 새로운 리소스
2021/05/09 15:52:51 질의: QID[43] CID[13]
2021/05/09 15:52:51 생성: 새 데이터베이스 연결 7
2021/05/09 15:52:51 리소스 획득: 새로운 리소스
2021/05/09 15:52:51 생성: 새 데이터베이스 연결 20
2021/05/09 15:52:51 생성: 새 데이터베이스 연결 21
2021/05/09 15:52:51 리소스 획득: 새로운 리소스
2021/05/09 15:52:51 생성: 새 데이터베이스 연결 22
2021/05/09 15:52:51 리소스 획득: 새로운 리소스
2021/05/09 15:52:51 질의: QID[10] CID[22]
2021/05/09 15:52:51 생성: 새 데이터베이스 연결 23
2021/05/09 15:52:51 리소스 획득: 새로운 리소스
2021/05/09 15:52:51 생성: 새 데이터베이스 연결 17
2021/05/09 15:52:51 생성: 새 데이터베이스 연결 24
2021/05/09 15:52:51 리소스 획득: 새로운 리소스
2021/05/09 15:52:51 리소스 획득: 새로운 리소스
2021/05/09 15:52:51 생성: 새 데이터베이스 연결 26
2021/05/09 15:52:51 생성: 새 데이터베이스 연결 25
2021/05/09 15:52:51 리소스 획득: 새로운 리소스
2021/05/09 15:52:51 생성: 새 데이터베이스 연결 27
2021/05/09 15:52:51 리소스 획득: 새로운 리소스
2021/05/09 15:52:51 생성: 새 데이터베이스 연결 28
2021/05/09 15:52:51 리소스 획득: 새로운 리소스
2021/05/09 15:52:51 생성: 새 데이터베이스 연결 29
2021/05/09 15:52:51 리소스 획득: 새로운 리소스
2021/05/09 15:52:51 생성: 새 데이터베이스 연결 30
2021/05/09 15:52:51 리소스 획득: 새로운 리소스
2021/05/09 15:52:51 생성: 새 데이터베이스 연결 31
2021/05/09 15:52:51 리소스 획득: 새로운 리소스
2021/05/09 15:52:51 생성: 새 데이터베이스 연결 32
2021/05/09 15:52:51 질의: QID[17] CID[32]
2021/05/09 15:52:51 리소스 획득: 새로운 리소스
2021/05/09 15:52:51 생성: 새 데이터베이스 연결 33
2021/05/09 15:52:51 리소스 획득: 새로운 리소스
2021/05/09 15:52:51 질의: QID[18] CID[33]
2021/05/09 15:52:51 생성: 새 데이터베이스 연결 34
2021/05/09 15:52:51 리소스 획득: 새로운 리소스
2021/05/09 15:52:51 생성: 새 데이터베이스 연결 35
2021/05/09 15:52:51 리소스 획득: 새로운 리소스
2021/05/09 15:52:51 생성: 새 데이터베이스 연결 36
2021/05/09 15:52:51 리소스 획득: 새로운 리소스
2021/05/09 15:52:51 생성: 새 데이터베이스 연결 37
2021/05/09 15:52:51 리소스 획득: 새로운 리소스
2021/05/09 15:52:51 생성: 새 데이터베이스 연결 38
2021/05/09 15:52:51 리소스 획득: 새로운 리소스
2021/05/09 15:52:51 생성: 새 데이터베이스 연결 39
2021/05/09 15:52:51 생성: 새 데이터베이스 연결 6
2021/05/09 15:52:51 생성: 새 데이터베이스 연결 8
2021/05/09 15:52:51 리소스 획득: 새로운 리소스
2021/05/09 15:52:51 생성: 새 데이터베이스 연결 40
2021/05/09 15:52:51 질의: QID[28] CID[40]
2021/05/09 15:52:51 생성: 새 데이터베이스 연결 12
2021/05/09 15:52:51 리소스 반환: 리소스 큐에 반환
2021/05/09 15:52:51 리소스 반환: 리소스 큐에 반환
2021/05/09 15:52:51 리소스 반환: 리소스 큐에 반환
2021/05/09 15:52:51 리소스 반환: 리소스 큐에 반환
2021/05/09 15:52:51 리소스 반환: 리소스 큐에 반환
2021/05/09 15:52:51 리소스 반환: 리소스 큐에 반환
2021/05/09 15:52:51 리소스 반환: 리소스 큐에 반환
2021/05/09 15:52:51 생성: 새 데이터베이스 연결 15
2021/05/09 15:52:51 리소스 획득: 새로운 리소스
2021/05/09 15:52:51 생성: 새 데이터베이스 연결 41
2021/05/09 15:52:51 질의: QID[29] CID[41]
2021/05/09 15:52:51 리소스 반환: 리소스 큐에 반환
2021/05/09 15:52:51 리소스 획득: 새로운 리소스
2021/05/09 15:52:51 생성: 새 데이터베이스 연결 42
2021/05/09 15:52:51 리소스 획득: 새로운 리소스
2021/05/09 15:52:51 생성: 새 데이터베이스 연결 43
2021/05/09 15:52:51 리소스 획득: 새로운 리소스
2021/05/09 15:52:51 생성: 새 데이터베이스 연결 44
2021/05/09 15:52:51 리소스 획득: 새로운 리소스
2021/05/09 15:52:51 생성: 새 데이터베이스 연결 45
2021/05/09 15:52:51 리소스 획득: 새로운 리소스
2021/05/09 15:52:51 생성: 새 데이터베이스 연결 46
2021/05/09 15:52:51 리소스 획득: 새로운 리소스
2021/05/09 15:52:51 생성: 새 데이터베이스 연결 47
2021/05/09 15:52:51 리소스 획득: 새로운 리소스
2021/05/09 15:52:51 생성: 새 데이터베이스 연결 48
2021/05/09 15:52:51 질의: QID[12] CID[24]
2021/05/09 15:52:51 리소스 반환: 리소스 큐에 반환
2021/05/09 15:52:51 리소스 획득: 새로운 리소스
2021/05/09 15:52:51 생성: 새 데이터베이스 연결 49
2021/05/09 15:52:52 질의: QID[26] CID[12]
2021/05/09 15:52:52 질의: QID[14] CID[17]
2021/05/09 15:52:52 질의: QID[35] CID[8]
2021/05/09 15:52:52 리소스 반환: 리소스 큐에 반환
2021/05/09 15:52:52 리소스 반환: 리소스 큐에 반환
2021/05/09 15:52:52 질의: QID[4] CID[34]
2021/05/09 15:52:52 리소스 반환: 리소스 해제
2021/05/09 15:52:52 질의: QID[23] CID[39]
2021/05/09 15:52:52 닫힘: 데이터베이스 연결 8
2021/05/09 15:52:52 질의: QID[34] CID[37]
2021/05/09 15:52:52 리소스 반환: 리소스 해제
2021/05/09 15:52:52 질의: QID[49] CID[1]
2021/05/09 15:52:52 닫힘: 데이터베이스 연결 39
2021/05/09 15:52:52 질의: QID[44] CID[18]
2021/05/09 15:52:52 리소스 반환: 리소스 해제
2021/05/09 15:52:52 닫힘: 데이터베이스 연결 1
2021/05/09 15:52:52 질의: QID[21] CID[9]
2021/05/09 15:52:52 질의: QID[47] CID[10]
2021/05/09 15:52:52 리소스 반환: 리소스 해제
2021/05/09 15:52:52 닫힘: 데이터베이스 연결 18
2021/05/09 15:52:52 리소스 반환: 리소스 해제
2021/05/09 15:52:52 닫힘: 데이터베이스 연결 34
2021/05/09 15:52:52 질의: QID[46] CID[21]
2021/05/09 15:52:52 리소스 반환: 리소스 해제
2021/05/09 15:52:52 닫힘: 데이터베이스 연결 37
2021/05/09 15:52:52 질의: QID[9] CID[26]
2021/05/09 15:52:52 리소스 반환: 리소스 해제
2021/05/09 15:52:52 닫힘: 데이터베이스 연결 9
2021/05/09 15:52:52 리소스 반환: 리소스 해제
2021/05/09 15:52:52 닫힘: 데이터베이스 연결 26
2021/05/09 15:52:52 리소스 반환: 리소스 해제
2021/05/09 15:52:52 닫힘: 데이터베이스 연결 10
2021/05/09 15:52:52 리소스 반환: 리소스 해제
2021/05/09 15:52:52 닫힘: 데이터베이스 연결 21
2021/05/09 15:52:53 질의: QID[27] CID[6]
2021/05/09 15:52:53 질의: QID[5] CID[30]
2021/05/09 15:52:53 질의: QID[6] CID[29]
2021/05/09 15:52:53 질의: QID[25] CID[4]
2021/05/09 15:52:53 질의: QID[20] CID[2]
2021/05/09 15:52:53 질의: QID[22] CID[3]
2021/05/09 15:52:53 질의: QID[8] CID[28]
2021/05/09 15:52:53 질의: QID[11] CID[23]
2021/05/09 15:52:53 질의: QID[1] CID[36]
2021/05/09 15:52:53 리소스 반환: 리소스 해제
2021/05/09 15:52:53 닫힘: 데이터베이스 연결 6
2021/05/09 15:52:53 리소스 반환: 리소스 해제
2021/05/09 15:52:53 닫힘: 데이터베이스 연결 30
2021/05/09 15:52:53 리소스 반환: 리소스 해제
2021/05/09 15:52:53 닫힘: 데이터베이스 연결 29
2021/05/09 15:52:53 리소스 반환: 리소스 해제
2021/05/09 15:52:53 닫힘: 데이터베이스 연결 2
2021/05/09 15:52:53 리소스 반환: 리소스 해제
2021/05/09 15:52:53 닫힘: 데이터베이스 연결 3
2021/05/09 15:52:53 리소스 반환: 리소스 해제
2021/05/09 15:52:53 닫힘: 데이터베이스 연결 28
2021/05/09 15:52:53 리소스 반환: 리소스 해제
2021/05/09 15:52:53 닫힘: 데이터베이스 연결 4
2021/05/09 15:52:53 리소스 반환: 리소스 해제
2021/05/09 15:52:53 닫힘: 데이터베이스 연결 23
2021/05/09 15:52:53 리소스 반환: 리소스 해제
2021/05/09 15:52:53 닫힘: 데이터베이스 연결 36
2021/05/09 15:52:53 질의: QID[48] CID[45]
2021/05/09 15:52:53 리소스 반환: 리소스 해제
2021/05/09 15:52:53 닫힘: 데이터베이스 연결 45
2021/05/09 15:52:54 질의: QID[0] CID[7]
2021/05/09 15:52:54 질의: QID[31] CID[43]
2021/05/09 15:52:54 질의: QID[36] CID[11]
2021/05/09 15:52:54 질의: QID[13] CID[49]
2021/05/09 15:52:54 질의: QID[32] CID[31]
2021/05/09 15:52:54 질의: QID[15] CID[25]
2021/05/09 15:52:54 질의: QID[19] CID[35]
2021/05/09 15:52:54 질의: QID[7] CID[27]
2021/05/09 15:52:54 질의: QID[39] CID[15]
2021/05/09 15:52:54 질의: QID[42] CID[44]
2021/05/09 15:52:54 질의: QID[3] CID[46]
2021/05/09 15:52:54 리소스 반환: 리소스 해제
2021/05/09 15:52:54 닫힘: 데이터베이스 연결 7
2021/05/09 15:52:54 리소스 반환: 리소스 해제
2021/05/09 15:52:54 닫힘: 데이터베이스 연결 43
2021/05/09 15:52:54 리소스 반환: 리소스 해제
2021/05/09 15:52:54 닫힘: 데이터베이스 연결 11
2021/05/09 15:52:54 리소스 반환: 리소스 해제
2021/05/09 15:52:54 닫힘: 데이터베이스 연결 49
2021/05/09 15:52:54 리소스 반환: 리소스 해제
2021/05/09 15:52:54 닫힘: 데이터베이스 연결 31
2021/05/09 15:52:54 리소스 반환: 리소스 해제
2021/05/09 15:52:54 닫힘: 데이터베이스 연결 25
2021/05/09 15:52:54 리소스 반환: 리소스 해제
2021/05/09 15:52:54 닫힘: 데이터베이스 연결 35
2021/05/09 15:52:54 리소스 반환: 리소스 해제
2021/05/09 15:52:54 닫힘: 데이터베이스 연결 27
2021/05/09 15:52:54 리소스 반환: 리소스 해제
2021/05/09 15:52:54 닫힘: 데이터베이스 연결 15
2021/05/09 15:52:54 리소스 반환: 리소스 해제
2021/05/09 15:52:54 닫힘: 데이터베이스 연결 44
2021/05/09 15:52:54 리소스 반환: 리소스 해제
2021/05/09 15:52:54 닫힘: 데이터베이스 연결 46
2021/05/09 15:52:55 질의: QID[2] CID[48]
2021/05/09 15:52:55 질의: QID[45] CID[16]
2021/05/09 15:52:55 질의: QID[30] CID[20]
2021/05/09 15:52:55 질의: QID[33] CID[5]
2021/05/09 15:52:55 질의: QID[40] CID[42]
2021/05/09 15:52:55 질의: QID[41] CID[47]
2021/05/09 15:52:55 리소스 반환: 리소스 해제
2021/05/09 15:52:55 닫힘: 데이터베이스 연결 48
2021/05/09 15:52:55 리소스 반환: 리소스 해제
2021/05/09 15:52:55 닫힘: 데이터베이스 연결 16
2021/05/09 15:52:55 질의: QID[16] CID[38]
2021/05/09 15:52:55 리소스 반환: 리소스 해제
2021/05/09 15:52:55 닫힘: 데이터베이스 연결 20
2021/05/09 15:52:55 리소스 반환: 리소스 해제
2021/05/09 15:52:55 닫힘: 데이터베이스 연결 38
2021/05/09 15:52:55 질의: QID[37] CID[19]
2021/05/09 15:52:55 리소스 반환: 리소스 해제
2021/05/09 15:52:55 닫힘: 데이터베이스 연결 5
2021/05/09 15:52:55 리소스 반환: 리소스 해제
2021/05/09 15:52:55 닫힘: 데이터베이스 연결 19
2021/05/09 15:52:55 리소스 반환: 리소스 해제
2021/05/09 15:52:55 닫힘: 데이터베이스 연결 42
2021/05/09 15:52:55 리소스 반환: 리소스 해제
2021/05/09 15:52:55 닫힘: 데이터베이스 연결 47
2021/05/09 15:52:55 프로그램을 종료합니다.
2021/05/09 15:52:55 닫힘: 데이터베이스 연결 14
2021/05/09 15:52:55 닫힘: 데이터베이스 연결 13
2021/05/09 15:52:55 닫힘: 데이터베이스 연결 22
2021/05/09 15:52:55 닫힘: 데이터베이스 연결 32
2021/05/09 15:52:55 닫힘: 데이터베이스 연결 33
2021/05/09 15:52:55 닫힘: 데이터베이스 연결 40
2021/05/09 15:52:55 닫힘: 데이터베이스 연결 41
2021/05/09 15:52:55 닫힘: 데이터베이스 연결 24
2021/05/09 15:52:55 닫힘: 데이터베이스 연결 12
2021/05/09 15:52:55 닫힘: 데이터베이스 연결 17

Singal Handle

2021-05-06T00:00:00+00:00

Interrupt를 발생시켜 운영체제가 프로그램에 제재를 걸수 있다. 반대로 특정 입력이 들어올때 Signal을 잡아서 처리할수 있다. Singal은 신호라는 의미로 프로세스간 서로 통신할 때 사용한다. 굉장히 작은 값으로 Interrupt 라고 부르기도 한다. 용도가 제한적이며 여러 시그널이 겹칠 경우 원치 않는 결과가 발생할 수 있다.

Singal handler는 시그널을 받았을때 특정 동작을 하도록 정의 하는 코드(함수)이다. 보통의 방식으로 종료하거나 무시 또는 재시작 처리 한다. 운영체제 인터럽트를 수신하고 Singal handler를 정의하여 응용프로그램이 (가능한)깔끔하게 종료될 수 있도록 처리하는 것 이 목적이다.

출처: www.quora.com

시그널 처리 유형

종료
무시
코어 덤프
중단
재시작

시그널 정보

❯ kill -l
HUP INT QUIT ILL TRAP ABRT EMT FPE KILL BUS SEGV SYS PIPE ALRM TERM URG STOP TSTP CONT CHLD TTIN TTOU IO XCPU XFSZ VTALRM PROF WINCH INFO USR1 USR2

❯ man signal
No    Name         Default Action       Description
   SIGHUP       terminate process    terminal line hangup
   SIGINT       terminate process    interrupt program
   SIGQUIT      create core image    quit program
   SIGILL       create core image    illegal instruction
   SIGTRAP      create core image    trace trap
   SIGABRT      create core image    abort program (formerly SIGIOT)
   SIGEMT       create core image    emulate instruction executed
   SIGFPE       create core image    floating-point exception
   SIGKILL      terminate process    kill program
  SIGBUS       create core image    bus error
  SIGSEGV      create core image    segmentation violation
  SIGSYS       create core image    non-existent system call invoked
  SIGPIPE      terminate process    write on a pipe with no reader
  SIGALRM      terminate process    real-time timer expired
  SIGTERM      terminate process    software termination signal
  SIGURG       discard signal       urgent condition present on socket
  SIGSTOP      stop process         stop (cannot be caught or ignored)
  SIGTSTP      stop process         stop signal generated from keyboard
  SIGCONT      discard signal       continue after stop
  SIGCHLD      discard signal       child status has changed
  SIGTTIN      stop process         background read attempted from control terminal
  SIGTTOU      stop process         background write attempted to control terminal
  SIGIO        discard signal       I/O is possible on a descriptor (see fcntl(2))
  SIGXCPU      terminate process    cpu time limit exceeded (see setrlimit(2))
  SIGXFSZ      terminate process    file size limit exceeded (see setrlimit(2))
  SIGVTALRM    terminate process    virtual time alarm (see setitimer(2))
  SIGPROF      terminate process    profiling timer alarm (see setitimer(2))
  SIGWINCH     discard signal       Window size change
  SIGINFO      discard signal       status request from keyboard
  SIGUSR1      terminate process    User defined signal 1
  SIGUSR2      terminate process    User defined signal 2

Example

// main.go
sigs := make(chan os.Signal, 1)
done := make(chan bool, 1)

signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM)
//signal.Notify(sigs, os.Interrupt)
signal.Notify(sigs, os.Kill)

go func() {
	sig := <-sigs
	fmt.Println(sig)
	done <- true
}()

fmt.Println("awaiting signal")
<-done
fmt.Println("existing")

kill -9 (kill program)

❯ go build main.go
❯ main
awaiting signal
[1]    13673 killed     main

kill -15 (terminate signal)

❯ go build main.go
❯ main      
awaiting signal
terminated
existing

Ctrl+C (사용자 인터럽트)

❯ go build main.go
❯ main
awaiting signal
^Cinterrupt
existing

Check out the GitHub repository for more info.

Protocol Buffers 3

2021-05-04T00:00:00+00:00

Need to think about data model and efficiency of the API.

JSON / XML / Something Binary
How much data do I get out of one call?
Too much data
Too little data -> many API calls?
Latency
Scalability to 1000s of clients
Load balancing
Inter operability with many languages
Authenticatin, Monitoring, Logging

An Evolution of data type

CSV (Comma Separated Values)

Advantegs:

Easy to parse
Easy to read
Easy to make sense of

Disadvantages:

The data types of elements has to be inferred and is not a guarantee
Parsing becomes tricky when data contains commas
Column names may or may not be there

Relational tables definitions

Advantages:

Data is fully typed
Data fits in a table

Disadvantages:

Data has to be flat
Data is stored in a database, and data definition will be different for each database

JSON (JavaScript Object Notation)

Advantages:

Data can take any form (arrays, nested elements)
JSON is a widely accepted format on the web
JSON can be read by pretty much any language
JSON can be easily shared over a network

Disadvantages:

Data has no schema enforcing
JSON Objects can be quite big in size because of repeated keys
No comments, metadata, documentation

Protocol Buffers

Protocol Buffers is defined by a .proto text file. You can easily read it and understand it as a human.

Advantages:

Data is fully typed
Data is compressed automatically (less CPU usage)
Schema (defined using .proto file) is needed to generate code and read the data
Documentation can be embedded in the schema
Data can be read across any language (C#, Java, Go, Python, Javascript, etc…)
Schema can evolve over time, in a safe manager (schema evolution)
3-10x smaller, 20-100x faster than XML
Code is generated for you automatically!

Disadvantages:

Protobuf support for some languages might be lacking (but the amin ones is fine)
Can’t “open” the serialized data with a text editor (because it’s compressed and serialised)

Message structure

// We are using proto3
syntax = "proto3"; 

// In Protocol Buffers we define message
message MyMessage {
	// Field Ttype, Field Name, Field Tag (e.g. Number)
	int32 id = 1;
	string first_name = 2;
	bool is_validated = 3;
}

Default Vlaues for fields

All fields, if not specified or unknown, will take a default value

bool: false
number (int32, etc…): 0
string: empty string
bytes: empty bytes
enum: first value
repeated: empty list

Enums

If you know all the values a field can take in advance, you can leverage th Enum type
The first value of an Enum is the default value
Enum must start by the tag 0 (which is the default value)

Example

// simple.proto

syntax = "proto3";

package simple;
option go_package="simple/simplepb";

message SimpleMessage {
  int32 id = 1;
  bool is_simple = 2;
  string name = 3;
  repeated int32 simple_list = 4;
}

> protoc -I . --go_out=. simple/simplepb/simple.proto

// main.go
func main() {
	sp := doSimple()
}

func doSimple() *simplepb.SimpleMessage {
	sp := simplepb.SimpleMessage{
		Id: 12345,
		IsSimple: true,
		Name: "My Simple Message",
		SimpleList: []int32{1, 2, 3, 4},
	}

	fmt.Println(sp)

	sp.Name = "I renamed you"
	fmt.Println(sp)

	fmt.Println("The ID is: ", sp.GetId())

	return &sp
}

❯ go run main.go
0 [] 12345 true My Simple Message [1 2 3 4]
0 [] 12345 true I renamed you [1 2 3 4]
The ID is:  12345

Check out the GitHub repository for more info.

gRPC Deadlines

2021-05-03T00:00:00+00:00

Deadlines allow gRPC lcients to specify how long they ar willing to wait for and RPC to complete before the RPC is terminated with error DEADLINE_EXCEEDED. The gRPC documentation recommends you set a deadline for all client RPC calls. Setting the deadline is up to you: how long do you feel your API should have to complete?

The server should check if the deadline has exceeded and cancel the work it is doing.

Note: Deadlines are propagated accross if gRPC calls are chained

A => B => C (deadline for A is passed to B and thend passed to C)

Server

for i := 0; i < 3; i ++ {
	if ctx.Err() == context.Canceled {
		// the client canceled the request
		fmt.Println("The client canceled the request!")
		return nil, status.Error(codes.Canceled, "The client canceled the request")
	}
	time.Sleep(1* time.Second)
}

Client

ctx, cancel := context.WithTimeout(context.Background(), timeout)
defer cancel()

res, err := c.HelloWithDeadline(ctx, req)
if err != nil {
	statusErr, ok := status.FromError(err)
	if ok {
		if statusErr.Code() == codes.DeadlineExceeded {
			fmt.Println("Timeout was hit! Deadline was exceeded")
		} else {
			fmt.Printf("Unexpected error: %v", statusErr)
		}
	} else {
		log.Fatalf("Error while calling Hello RPC: %v", err)
	}
	return
}
log.Printf("Response from Hello: %v", res.Result)

Console

❯ go run hello/hello_server/server.go
Hello server
HelloWithDeadline function was invoked with hello:{first_name:"Younghyun" last_name:"Ahn"}
HelloWithDeadline function was invoked with hello:{first_name:"Younghyun" last_name:"Ahn"}

❯ go run hello/hello_client/client.go
Hello client
2021/05/03 22:46:56 Response from Hello: Hello Younghyun
Timeout was hit! Deadline was exceeded

Check out the gRPC and Deadlines for more info.

gRPC Introduction

2021-05-02T00:00:00+00:00

At the core of gRPC, you need to define the messages and services using Protocol Buffers. The rest of the gRPC code will be generated for you and you’ll have to provide and implementatin for it. one .proto file works for over 12 programming languages (server and client), and allow you to use a framework that scales to millions of RPC per seconds.

gRPC is a free and open-source framework developed by Google
gRPC is part of the Cloud Native Computation Foundation (CNCF) - like Docker & Kubernetes for example
At a high level, it allows you to define REQUEST and RESPONSE for RPC (Remote Procedure Calls) and handles all the rest for you
On top of it, it’s modern, fast and efficient, build on top of HTTP/2, low latency, supports streaming, language independent, and makes it supper easy to plug in authentication, load balancing, logging and monitoring.

What’s an RPC?

It’s not a new concept (CORBA had this berore).
With gRPC, it’s implemented very cleanly and solves a lot of problems.

Protocol Buffers?

gRPC use Protocol Buffers for communications.
Let’s measure the payload size vs JSON:

// JSON: 55 bytes
{
	"age": 25,
	"first_name": "Younhghyun",
	"last_name": "Ahn"
}

// same in Protocol BUffers: 20 bytes
message Person {
	int32 age = 1;
	string first_name = 2;
	string last_name = 3;
}

We save in Network Bandwidth.

Efficiency of Protocol Buffers over JSON

Parsing JSON is actually CPU intensive (because toe format is human readable)
Parsing Protocol Buffers (binary format) is less CPU intensive because it’s closer to how a machine represents data
By using gRPC, the use of Protocol Buffers means faster and more effcient communication, friendly with mobile device that have a slower CPU

Summary: Why Protocol Buffers?

Easy to write message definition
The definition of the API is independent from the implementation
A huge amount of code can be generated, in andy language, from a simpe .proto file
The payload is binary, therefor very efficient to send / receive on a network and serialize / de-serializer on a CPU
Protocol Buffers defines rules to make an API evolve without breaking existing clients, with is helpful for microservices

Language Interoperability

gRPC can be used by any language. Because the code can be generated for any language, it makes it super simple to create micro-services in any language that interact with each other.

4 Types of API in gRPC

Unary is what a traditional API looks like (HTTP REST)
HTTP/2 enables APIs to now have streaming capabilities.
The server and client can push multiple messages as part of one request!
In gRPC it’s very easy to define thes APIs as we’ll see

Scalability in gRPC

gRPC Server are asynchronous by default
This means they do not block threads on request
Therefore each gRPC server can serve millions of requests in parallel
gRPC Clients can be asynchronous or synchronous (blocking)
The client decides which model works best for the performance nees
gRPC Client can perform client side load balancing

gRPC vs REST

gRPC	REST
Protocol Buffers - smaller, faster	JSON - text based, slower, bigger
HTTP/2 (lower latency) - from 2015	HTTP1.1 (high latency) - from 1997
Bidirectional & Async	Client => Server requests only
Stream Support	Request / Response support only
API Oriented-“WHAT” (no constraints - free design)	CRUD Oriented (Create-Retrieve-Update-Delete / POST GET PUT DELETE)
Code Generation through Protocol Buffers in any language - 1st class citizen	Code generation through OpenAPI / Swagger(add-on) - 2nd class citizen
RPC Based - gRPC does the plumbing for us	HTTP verbs based - we have to write the plumbing or use a 3rd party library

Summary: Why use gRPC

Easy code defiition in over 11 languages
Uses a mordern, low latency HTTP/2 transport mechanism
SSL Security is built in
Support for streaming APIs for maximum performance
gRPC is API oriented, insted of Resource Oriented like REST

Check out the gRPC and gRPC Reflection, REST v. gRPC for more info.

gRPC Reflection & Evans CLI

2021-05-01T00:00:00+00:00

gRPC Clients to connect to Server to have a .proto file which defines the service. This is fine for proeuctin(you definitely want to know the API definition in advance). For development, when you hanve a gRPC server you don’t know, simetimes you wish you could ask the server:

“What APIs do you Have” ?

Reflection for two reaseons

Having server expose which endpoints are available
Allow command line interfaces (CLI) to talk to our server without have preliminary .proto file

Check out the gRPC Reflection for more info.

Server

import "google.golang.org/grpc/reflection"

s := grpc.NewServer()
pb.RegisterYourOwnServer(s, &server{})

// Register reflection service on gRPC server.
reflection.Register(s)

s.Serve(lis)

Installation

macOS

$ brew tap ktr0731/evans
$ brew install evans

go get

$ go get github.com/ktr0731/evans

Usage (REPL)

> evans
> evans -p 50051 -r
> show package
+---------+
| PACKAGE |
+---------+
| api     |
+---------+
> package api
api@172.0.0.1:50051> show service
+---------+----------------------+-----------------------------+----------------+
| SERVICE |         RPC          |         REQUESTTYPE         |  RESPONSETYPE  |
+---------+----------------------+-----------------------------+----------------+
| Example | Unary                | SimpleRequest               | SimpleResponse |
|         | UnaryMessage         | UnaryMessageRequest         | SimpleResponse |
|         | UnaryRepeated        | UnaryRepeatedRequest        | SimpleResponse |
|         | UnaryRepeatedMessage | UnaryRepeatedMessageRequest | SimpleResponse |
|         | UnaryRepeatedEnum    | UnaryRepeatedEnumRequest    | SimpleResponse |
|         | UnarySelf            | UnarySelfRequest            | SimpleResponse |
|         | UnaryMap             | UnaryMapRequest             | SimpleResponse |
|         | UnaryMapMessage      | UnaryMapMessageRequest      | SimpleResponse |
|         | UnaryOneof           | UnaryOneofRequest           | SimpleResponse |
|         | UnaryEnum            | UnaryEnumRequest            | SimpleResponse |
|         | UnaryBytes           | UnaryBytesRequest           | SimpleResponse |
|         | ClientStreaming      | SimpleRequest               | SimpleResponse |
|         | ServerStreaming      | SimpleRequest               | SimpleResponse |
|         | BidiStreaming        | SimpleRequest               | SimpleResponse |
+---------+----------------------+-----------------------------+----------------+
api@172.0.0.1:50051> show message
+-----------------------------+
|           MESSAGE           |
+-----------------------------+
| SimpleRequest               |
| SimpleResponse              |
| Name                        |
| UnaryMessageRequest         |
| UnaryRepeatedRequest        |
| UnaryRepeatedMessageRequest |
| UnaryRepeatedEnumRequest    |
| UnarySelfRequest            |
| Person                      |
| UnaryMapRequest             |
| UnaryMapMessageRequest      |
| UnaryOneofRequest           |
| UnaryEnumRequest            |
| UnaryBytesRequest           |
+-----------------------------+
api@172.0.0.1:50051> desc SimpleRequest
+-------+-------------+
| FIELD |    TYPE     |
+-------+-------------+
| name  | TYPE_STRING |
+-------+-------------+

# Call a gRPC
api@172.0.0.1:50051> service Example
api.Example@172.0.0.1:50051> call Unary
name (TYPE_STRING) => ktr
{
  "message": "hello, ktr"
}

Real world service (reference)

Google uses gRPC for some of ti’s most important cloud service:

grpc.io

RESTful HTTP API into gRPC

gRPC SSL Security

2021-04-29T00:00:00+00:00

gRPC has SSL/TLS integration and promotes the use of SSL/TLS to authenticate the server, and to encrypt all the data exchanged between the client and the server. Optional mechanisms are available for clients to provide certificates for mutual authentication.

Certificate files by openssl

ca.key	Certificate Authority `private key` file (this shouldn’t be shsare in real-life)
ca.crt	Certificate Authority trust `certificate` (this should be share with user in real-life)
server.key	Server private key, passwrod protected (this shouldn’t b share)
server.csr	Server certificate signing request (thils should be shared with the CA owner)
server.crt	Server certificate signed by the CA (this would be sent back by the CA owner) - keep on server
server.pem	Conversion for server.key into a format gRRPC like (this shouldn’t be share)

Caution

Private files: ca.key, server.key, sever.pem, server.crt
Share files: ca.crt (need by the client), server.csr (need by th CA)

Openssl

# Changes these CN's to match your hosts in your envrioment if need.
SERVER_CN=localhost

# Step 1: Generate Certificate Authority + Trust Certificate (ca.crt)
openssl genrsa -passout pass:1111 -des3 -out ca.key 4096
openssl req -passin pass:1111 -new -x509 -days 365 -key ca.key -out ca.crt -subj "/CN=${SERVER_CN}"

# Step 2: Generate the Server Private Key (server.key)
openssl genrsa -passout pass:1111 -des3 -out server.key 4096

# Step 3: Get a certificate signing request from the CA (server.csr)
openssl req -passin pass:1111 -new -key server.key -out server.csr -subj "/CN=${SERVER_CN}"

# Step 4: Sign the certificate with the CA we created (it's called self signing) - server.crt
openssl x509 -req -passin pass:1111 -days 365 -in server.csr -CA ca.crt -CAkey ca.key -set_serial 01 -out server.crt

# Step 5: Convert the server certificate to .pem format (server.pem) - usable by gRPC
openssl pkcs8 -topk8 -nocrypt -passin pass:1111 -in server.key -out server.pem

Example Code

Sever

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

certFile := "server.crt"
keyFile := "server.pem"
creds, err := credentials.newServerTLSFromFIle(certFile, keyFile)
if err != nil {
	log.Fatalf("Faild loading certificates: %v", err)
}
opts := grpc.Creds(creds)

s := grpc.NewServer(opts)

if err := s.Serve(lis); err != nil {
	log.Fatalf("faild to serve: %v", err)
}

Client

certFile := "ca.cert" // Certification Authority Trust certificate
creds, err := credentials.newClientTLSFromFile(certFile, "")
if err != nil {
	log.Fatalf("Error while loading CA trust certificate: %v", err)
}
opts := grpc.WithTransportCredentials(creds)

conn, err := grpc.Dial("localhost:50051", opts)
if err != nil {
	log.Fatalf("could not connect: %v", err)
}
defer conn.Close()

c := pb.NewGreetClient(conn)
// ...

Check out the gRPC Docs for more info.

Welcome to minima-reboot

2017-12-26T00:00:00+00:00

Welcome to Minima Reboot, a Bootstrap-based rewrite of Minima, the base Jekyll theme. Check out the responsive navigation menu and footer by changing your browser’s width. This is a post in the _posts directory. You can view Minima Reboot’s source on GitHub. Minima Reboot inherits Jekyll’s support for code highlighting, as shown below.

def print_hi(name)
  puts "Hi, #{name}"
end
print_hi('Tom')
#=> prints 'Hi, Tom' to STDOUT.

Check out the GitHub repository for more info.

Even More Posts For Pagination

2016-05-20T00:00:00+00:00

Eos eu docendi tractatos sapientem, brute option menandri in vix, quando vivendo accommodare te ius. Nec melius fastidii constituam id, viderer theophrastus ad sit, hinc semper periculis cum id. Noluisse postulant assentior est in, no choro sadipscing repudiandae vix. Vis in euismod delenit dignissim. Ex quod nostrum sit, suas decore animal id ius, nobis solet detracto quo te.

lake log

Go Currency Patterns - Pooling

pool.go

main.go

실행 결과

Singal Handle

시그널 처리 유형

시그널 정보

Example

kill -9 (kill program)

kill -15 (terminate signal)

Ctrl+C (사용자 인터럽트)

Protocol Buffers 3

An Evolution of data type

CSV (Comma Separated Values)

Relational tables definitions

JSON (JavaScript Object Notation)

Protocol Buffers

To share data accross languages!

Message structure

Default Vlaues for fields

Enums

Example

gRPC Deadlines

Server

Client

Console

gRPC Introduction

What’s an RPC?

Protocol Buffers?

Efficiency of Protocol Buffers over JSON

Summary: Why Protocol Buffers?

Language Interoperability

4 Types of API in gRPC

Scalability in gRPC

gRPC vs REST

Summary: Why use gRPC

gRPC Reflection & Evans CLI

Server

Installation

macOS

go get

Usage (REPL)

Real world service (reference)

gRPC SSL Security

Certificate files by openssl

Caution

Openssl

Example Code

Sever

Client

Welcome to minima-reboot

Even More Posts For Pagination

More Posts For Pagination