Upload 2019.01 meetup slides and resources

Author: mingrammer

README.md

@@ -4,15 +4,25 @@ Golang Korea에서 주최하는 밋업, 세미나 및 컨퍼런스의 발표 자
 
 
 
-## Golang Korea MeetUp in Seoul 12월
+## Golang Korea MeetUp in Seoul 2019.01
+
+> [밋업 링크](https://www.meetup.com/Seoul-Go-Meetup/events/258121678/)
+
+| 발표자   | 주제                        | 발표 자료                                                    | 코드 자료 |
+| -------- | --------------------------- | ------------------------------------------------------------ | -- |
+| 주원영님 | How we use Golang heybeauty | [How we use Golang heybeauty](slides/201901/how-we-golang-heybeauty.pdf) | - |
+| 최흥배님 | Golang 로그 라이브러리 zap  | [고성능 로그 라이브러리 zap 소개](slides/201901/golang-log-library-zap.pdf) | - |
+| 한병일님 | 모듈화와 액터               | [모듈화와 액터](slides/201901/modularization-and-actor.pdf) |[예제](resources/201901/modularization-and-actor) |
+
+## Golang Korea MeetUp in Seoul 2018.12
 
 > [밋업 링크](https://www.meetup.com/ko-KR/Seoul-Go-Meetup/events/257399368/)
 
 | 발표자   | 주제                     | 발표 자료                                                    |
 | -------- | ------------------------ | ------------------------------------------------------------ |
 | 이재용님 | Telegraf 코드 기여해보기 | [Telegraf 코드 기여해보기](slides/201812/contribute-open-source-with-telegraf.pdf) |
 
-## Golang Korea MeetUp in Seoul 11월
+## Golang Korea MeetUp in Seoul 2018.11
 
 > [밋업 링크](https://www.meetup.com/ko-KR/Seoul-Go-Meetup/events/256560625/)
 
@@ -22,7 +32,7 @@ Golang Korea에서 주최하는 밋업, 세미나 및 컨퍼런스의 발표 자
 | 이용희님 | Golang으로 제작한 Network Scanner    | [Golang으로 제작한 Network Scanner](slides/201811/make-network-scanner-with-go.pdf) |
 | 온수영님 | Golang으로 로그 적재 시스템 개발하기 | [Golang으로 로그 적재 시스템 개발하기](slides/201811/build-logging-system-with-go.pdf) |
 
-## Golang Korea MeetUp in Seoul 8월
+## Golang Korea MeetUp in Seoul 2018.08
 
 > [밋업 링크](https://www.meetup.com/Seoul-Go-Meetup/events/253672991/)
 
@@ -32,7 +42,7 @@ Golang Korea에서 주최하는 밋업, 세미나 및 컨퍼런스의 발표 자
 | 이흥섭님 | 한글라이즈 재제작기                                          | [Remake of Hangulize](slides/201808/remake-of-hangulize.pdf) |
 | 김효준님 | ab180에서의 Go 도입기                                        | [Golang on Airbridge Airbloc](slides/201808/golang-on-airbridge-airbloc.pdf) |
 
-## Golang Korea MeetUp in Seoul 7월
+## Golang Korea MeetUp in Seoul 2018.07
 
 > [밋업 링크](https://www.meetup.com/Seoul-Go-Meetup/events/252632375)
 

resources/201901/modularization-and-actor/actor/actor.go

@@ -0,0 +1,122 @@
+package actor
+
+import (
+	"fmt"
+	"reflect"
+	"container/list"
+)
+
+type AID struct {
+	ActorID  uint64
+	NodeName string
+}
+
+func (a *AID) String() string {
+	return fmt.Sprintf("<%d, %s>", a.ActorID, a.NodeName)
+}
+
+
+type IActorReceiver interface {
+
+	GetNodeName() string
+}
+
+type iActor interface {
+	IActorReceiver
+	getReceiver() reflect.Value
+	getAID() *AID
+
+	setAID(aid *AID)
+	call(function interface{}, args ...interface{}) ([]interface{}, error)
+}
+
+var _ IActorReceiver = &Actor{}
+var _ iActor = &Actor{}
+
+type Actor struct {
+	aid       		*AID
+	receiver 	    reflect.Value
+	queue		    *list.List
+	inChan    		chan *ActorCall
+}
+
+func (a *Actor) start(receiver IActorReceiver, aid *AID) bool {
+	a.aid = aid
+	a.receiver = reflect.ValueOf(receiver)
+	a.queue = list.New()
+	a.inChan = make(chan *ActorCall, 1)
+	go a.loop()
+	return true
+}
+
+func (a *Actor) loop() {
+	for {
+		if a.queue.Len() == 0 {
+			select {
+			case actorCall := <-a.inChan:
+				a.queue.PushBack(actorCall)
+			}
+		} else {
+			select {
+			case actorCall := <-a.inChan:
+				a.queue.PushBack(actorCall)
+			default:
+				actorCall := a.queue.Front().Value.(*ActorCall)
+				a.queue.Remove(a.queue.Front())
+				a.process(actorCall)
+			}
+		}
+
+	}
+}
+
+
+func (a *Actor) GetNodeName() string {
+	return a.aid.NodeName
+}
+
+func (a *Actor) getAID() *AID {
+	return a.aid
+}
+
+func (a *Actor) getReceiver() reflect.Value {
+	return a.receiver
+}
+
+func (a *Actor) setAID(aid *AID) {
+	a.aid = aid
+}
+
+func (a *Actor) process(actorCall *ActorCall) {
+	actorCall.Results = actorCall.Function.Call(actorCall.Args)
+	if actorCall.Done != nil {
+		actorCall.Done <- actorCall
+	}
+}
+
+
+func (a *Actor) makeActorCall(done chan *ActorCall , function interface{}, args ...interface{}) *ActorCall {
+
+	v := reflect.ValueOf(function)
+	if v.Kind() != reflect.Func {
+		fn, _ := defaultActorSystem.findFunc(a, v.String())
+		v = reflect.ValueOf(fn)
+
+	}
+
+	valuedArgs := make([]reflect.Value, len(args)+1)
+	valuedArgs[0] = a.receiver
+	for i, x := range args {
+		valuedArgs[i+1] = reflect.ValueOf(x)
+	}
+
+	return &ActorCall{Function:v, Args:valuedArgs, Done:done}
+
+}
+
+func (a *Actor) call(function interface{}, args ...interface{}) ([]interface{}, error) {
+	done := make(chan *ActorCall, 0)
+	a.inChan <- a.makeActorCall(done, function, args...)
+	actorCall, _ := <-done
+	return actorCall.GetResults()
+}

resources/201901/modularization-and-actor/actor/actor_system.go

@@ -0,0 +1,159 @@
+package actor
+
+import (
+	"context"
+	"sync"
+	"sync/atomic"
+	"fmt"
+	"runtime"
+	"reflect"
+	"strings"
+	"net/http"
+)
+
+type ActorProtocolType uint16
+
+const (
+	None ActorProtocolType = iota
+	Web
+)
+
+type Request struct {
+	ActorID  uint64
+	NodeName string
+	FuncName string
+	Args     []interface{}
+}
+
+type Response struct {
+	Err    			error
+	Results 		[]interface{}
+}
+
+var defaultActorSystem *ActorSystem
+
+func init() {
+	defaultActorSystem = newActorSystem()
+}
+
+type ActorSystem struct {
+	mutex              	sync.RWMutex
+	nowActorID         	uint64
+	actorMapByAID       map[*AID]iActor
+	actorMapByNodeName 	map[string]iActor
+
+	server              *http.Server
+	serverCloseFunc     context.CancelFunc
+}
+
+func newActorSystem() *ActorSystem {
+	d := &ActorSystem{
+		actorMapByAID:        make(map[*AID]iActor),
+		actorMapByNodeName:   make(map[string]iActor),
+		nowActorID:        	  0,
+	}
+	return d
+}
+
+func (as *ActorSystem) startActor(receiver IActorReceiver) iActor {
+	actor := &Actor{}
+
+	as.mutex.Lock()
+	defer as.mutex.Unlock()
+
+	aid := as.createAID(receiver.GetNodeName())
+	actor.start(receiver, aid)
+	as.actorMapByAID[aid] = actor
+	as.actorMapByNodeName[receiver.GetNodeName()] = actor
+
+	return actor
+}
+
+func (as *ActorSystem) startWebActor(receiver IActorReceiver, nodeName string, address string) iActor {
+	actor := &WebActor{}
+
+	as.mutex.Lock()
+	defer as.mutex.Unlock()
+
+	aid := as.createAID(nodeName)
+	actor.start(receiver, aid)
+	as.actorMapByAID[aid] = actor
+	as.actorMapByNodeName[nodeName] = actor
+
+	actor.address = address
+	actor.client = &http.Client{}
+	return actor
+}
+
+func (as *ActorSystem) createAID(nodeName string) *AID {
+	id := atomic.AddUint64(&as.nowActorID, 1)
+	return &AID{NodeName:nodeName, ActorID:id}
+}
+
+func (as *ActorSystem) getActorByAIDWithLock(aid *AID) (iActor, error) {
+	as.mutex.RLock()
+	defer as.mutex.RUnlock()
+
+	actor, ok := as.actorMapByAID[aid]
+	if !ok {
+		return nil, fmt.Errorf("%s", "Not Found Actor")
+	}
+	return actor, nil
+}
+
+func (d *ActorSystem) getActorByNodeNameWithLock(nodeName string) (iActor, error) {
+	d.mutex.RLock()
+	defer d.mutex.RUnlock()
+
+	actor, ok := d.actorMapByNodeName[nodeName]
+	if !ok {
+		return nil, fmt.Errorf("%s", "Not Found Actor")
+	}
+	return actor, nil
+}
+
+func (as *ActorSystem) createRequest(ac iActor, function interface{}, args ...interface{}) *Request {
+
+
+	req := &Request{NodeName:ac.GetNodeName()}
+
+	v := reflect.ValueOf(function)
+	if v.Kind() == reflect.Func {
+		funcFullName := runtime.FuncForPC(reflect.ValueOf(function).Pointer()).Name()
+		fmt.Println(funcFullName)
+		tokens := strings.Split(funcFullName, ".")
+		req.FuncName = tokens[len(tokens)-1]
+	} else {
+		req.FuncName = v.String()
+	}
+
+	req.Args = args
+	return req
+}
+
+func (as *ActorSystem) handleRemoteCall(req *Request, res *Response) error {
+	ac, acErr := as.getActorByNodeNameWithLock(req.NodeName)
+	if acErr != nil {
+		res.Err = acErr
+		return acErr
+	}
+	fn, fnErr := as.findFunc(ac, req.FuncName)
+	if fnErr != nil {
+		res.Err = fnErr
+		return fnErr
+	}
+	rtn, callErr := ac.call(fn, req.Args...)
+	res.Results = rtn
+	res.Err = callErr
+	return callErr
+}
+
+func (as *ActorSystem) findFunc(ac iActor, funcName string) (interface{}, error) {
+	t := ac.getReceiver().Type()
+	method, ok := t.MethodByName(funcName)
+	if !ok {
+		return nil, fmt.Errorf("%s", "Not Found Func")
+	}
+	fn := method.Func.Interface()
+	return fn, nil
+}

resources/201901/modularization-and-actor/actor/actorcall.go

@@ -0,0 +1,35 @@
+package actor
+
+import "reflect"
+
+type ActorCall struct {
+	Function   reflect.Value
+	Args       []reflect.Value
+	Results    []reflect.Value
+	Done       chan *ActorCall
+	Error      error
+}
+
+func (c ActorCall) GetResults() ([]interface{}, error) {
+	if c.Error != nil {
+		return nil, c.Error
+	}
+	values := c.Results
+
+	var rtnResults []interface{}
+	var err error
+	for _, x := range values {
+		itf := x.Interface()
+		errorType  := reflect.TypeOf((*error)(nil)).Elem()
+
+		switch x.Type() {
+		case errorType:
+			if castingErr, ok := itf.(error); ok  && castingErr != nil {
+				err = x.Interface().(error)
+			}
+		default:
+			rtnResults = append(rtnResults, itf)
+		}
+	}
+	return rtnResults, err
+}