cqrs - GitLite

KO | EN

gitlite — search

#javascript #python #go #golang #android #machine-learning #deep-learning #linux #nodejs #windows #cli #awesome-list #pytorch #ios

cqrs

(★ 208)

cqrs framework in go

파일 탐색기

최종 버전 다운로드 (.zip)

- doc.go
- provider.go
- commandbus.go
- commandbus_test.go
- doc.go
- eventbus.go
- eventbus_test.go
- metrics.go
- prefetch.go
- reconnection.go
- retry.go
- test
.gitignore
commands.go
commands_test.go
correlation.go
cqrs-testentities_test.go
cqrs-testreadmodels_test.go
cqrs_test.go
doc.go
event-source-based.go
events.go
events_test.go
eventsourcing.go
go.mod
go.sum
inmemory-commandbus.go
inmemory-commandbus_test.go
inmemory-eventbus.go
inmemory-eventbus_test.go
inmemory-eventstreamrepo_test.go
inmemory-eventstreamrepository.go
LICENSE
logger.go
Makefile
metrics.go
README.md
type-registry.go
uuid.go

# 설치 가이드

1. 코드 내려받기

git clone https://github.com/andrewwebber/cqrs

깃허브에서 프로젝트 코드 전체를 내 컴퓨터로 내려받습니다.

cd cqrs

방금 내려받은 프로젝트 폴더 안으로 이동합니다.

2. Go

보통 추천

사전 준비물

Git GitHub에서 프로젝트 코드를 내려받으려면 필요합니다.
Go Go 언어 컴파일러 및 도구 모음입니다.

go build ./...

Go 프로그램을 컴파일해 실행 파일을 만듭니다.

go run .

따로 빌드하지 않고 바로 Go 프로그램을 실행합니다.

✅ 빌드가 에러 없이 끝나면 성공입니다. go run . 을 썼다면 터미널 출력을 확인하세요.

3. Make

보통

사전 준비물

Git GitHub에서 프로젝트 코드를 내려받으려면 필요합니다.
Make Linux/macOS는 보통 기본 설치되어 있습니다. Windows는 별도 설치(예: MSYS2, WSL)가 필요합니다.

make

생성된 빌드 설정을 바탕으로 실제 컴파일을 진행해 실행 파일을 만듭니다.

✅ 에러 없이 끝나면 성공입니다. 생성된 실행 파일을 직접 실행해보세요.

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

CQRS framework in go
=======

[![Join the chat at https://gitter.im/andrewwebber/cqrs](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/andrewwebber/cqrs?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
[![GoDoc](https://godoc.org/github.com/andrewwebber/cqrs?status.svg)](https://godoc.org/github.com/andrewwebber/cqrs)
[![Build Status](https://drone.io/github.com/andrewwebber/cqrs/status.png?foo=bar)](https://drone.io/github.com/andrewwebber/cqrs/latest)

# Project Summary
The package provides a framework for quickly implementing a CQRS style application.
The framework attempts to provides helpful functions to facilitate:
- Event Sourcing
- Command issuing and processing
- Event publishing
- Read model generation from published events

---

## Example code
[Example test scenario (inmemory)](https://github.com/andrewwebber/cqrs/blob/master/cqrs_test.go)

[Example test scenario (couchbase, rabbitmq)](https://github.com/andrewwebber/cqrs/blob/master/example/example_test.go)

[Example CQRS scaleout/concurrent test](https://github.com/andrewwebber/cqrs-scaleout)

## Test Scenario
The example test scenario is of a simple bank account that seeks to track, using event sourcing, a
customers balance and login password

The are two main areas of concern at the application level, the **Write model** and **Read model**.
The read model is aimed to facilitate fast reads (read model projections)
The write model is where the business logic get executed and asynchronously notifies the read models

## Write model - Using Event Sourcing
### Account
```go
type Account struct {
  cqrs.EventSourceBased

FirstName    string
  LastName     string
  EmailAddress string
  PasswordHash []byte
  Balance      float64
}
```
To compensate for golang's lack of inheritance, a combination of type embedding and a call convention
pattern are utilized.

```go
func NewAccount(firstName string, lastName string, emailAddress string, passwordHash []byte, initialBalance float64) *Account {
  account := new(Account)
  account.EventSourceBased = cqrs.NewEventSourceBased(account)

event := AccountCreatedEvent{firstName, lastName, emailAddress, passwordHash, initialBalance}
  account.Update(event)
  return account
}
```
The 'attached' Update function being called above will now provide the infrastructure for routing events to event handlers.
A function prefixed with 'Handle' and named with the name of the event expected with be called by the infrastructure.
```go
func (account *Account) HandleAccountCreatedEvent(event AccountCreatedEvent) {
  account.EmailAddress = event.EmailAddress
  account.FirstName = event.FirstName
  account.LastName = event.LastName
  account.PasswordHash = event.PasswordHash
}
```
The above code results in an account object being created with one single **pending** event namely **AccountCreatedEvent**.
Events will then be persisted once saved to an event sourcing repository.
If a repository is created with an event publisher then events saved for the purposes of event sourcing will also be published
```go
persistance := cqrs.NewInMemoryEventStreamRepository()
bus := cqrs.NewInMemoryEventBus()
repository := cqrs.NewRepositoryWithPublisher(persistance, bus)
...
repository.Save(account)
```

### Account Events
```go
type AccountCreatedEvent struct {
  FirstName      string
  LastName       string
  EmailAddress   string
  PasswordHash   []byte
  InitialBalance float64
}

type EmailAddressChangedEvent struct {
  PreviousEmailAddress string
  NewEmailAddress      string
}

type PasswordChangedEvent struct {
  NewPasswordHash []byte
}

type AccountCreditedEvent struct {
  Amount float64
}

type AccountDebitedEvent struct {
  Amount float64
}
```
Events souring events are raised using the embedded **Update** function. These events will eventually be published to the read models indirectly via an event bus

```go
func (account *Account) ChangePassword(newPassword string) error {
  if len(newPassword) < 1 {
    return errors.New("Invalid newPassword length")
  }

hashedPassword, err := GetHashForPassword(newPassword)
  if err != nil {
    panic(err)
  }

account.Update(PasswordChangedEvent{hashedPassword})

return nil
}

func (account *Account) HandlePasswordChangedEvent(event PasswordChangedEvent) {
  account.PasswordHash = event.NewPasswordHash
}
```

Again the calling convention routes our **PasswordChangedEvent** to the corresponding **HandlePasswordChangedEvent** instance function

## Read Model
### Accounts projection
```go
type ReadModelAccounts struct {
  Accounts map[string]*AccountReadModel
}

type AccountReadModel struct {
  ID           string
  FirstName    string
  LastName     string
  EmailAddress string
  Balance      float64
}
```
### Users projection
```go
type UsersModel struct {
  Users    map[string]*User
}

type User struct {
  ID           string
  FirstName    string
  LastName     string
  EmailAddress string
  PasswordHash []byte
}
```

## Infrastructure
There are a number of key elements to the CQRS infrastructure.
- Event sourcing repository (a repository for event sourcing based business objects)
- Event publisher (publishes new events to an event bus)
- Event handler (dispatches received events to call handlers)
- Command publisher (publishes new commands to a command bus)
- Command handler (dispatches received commands to call handlers)

### Event sourcing and integration events
Nested packages within this repository show example implementations using Couchbase Server and RabbitMQ.
The core library includes in-memory implementations for testing and quick prototyping
```go
persistance := cqrs.NewInMemoryEventStreamRepository()
bus := cqrs.NewInMemoryEventBus()
repository := cqrs.NewRepositoryWithPublisher(persistance, bus)
```

With the infrastructure implementations instantiated a stock event dispatcher is provided to route received
events to call handlers
```go
readModel := NewReadModelAccounts()
usersModel := NewUsersModel()

eventDispatcher := cqrs.NewVersionedEventDispatchManager(bus)
eventDispatcher.RegisterEventHandler(AccountCreatedEvent{}, func(event cqrs.VersionedEvent) error {
  readModel.UpdateViewModel([]cqrs.VersionedEvent{event})
  usersModel.UpdateViewModel([]cqrs.VersionedEvent{event})
  return nil
})
```

We can also register a **global** handler to be called for all events.
This becomes useful when logging system wide events and when our read models are smart enough to filter out irrelevant events
```go
integrationEventsLog := cqrs.NewInMemoryEventStreamRepository()
eventDispatcher.RegisterGlobalHandler(func(event cqrs.VersionedEvent) error {
  integrationEventsLog.SaveIntegrationEvent(event)
  readModel.UpdateViewModel([]cqrs.VersionedEvent{event})
  usersModel.UpdateViewModel([]cqrs.VersionedEvent{event})
  return nil
})
```

Within your read models the idea is that you implement the updating of your pre-pared read model based upon the
incoming event notifications

### Commands

Commands are processed by command handlers similar to event handlers.
We can make direct changes to our write model and indirect changes to our read models by correctly processing commands and then raising integration events upon command completion.

```go
commandBus := cqrs.NewInMemoryCommandBus()
commandDispatcher := cqrs.NewCommandDispatchManager(commandBus)
RegisterCommandHandlers(commandDispatcher, repository)
```

Commands can be issued using a command bus. Typically a command is a simple struct.
The application layer command struct is then wrapped within a cqrs.Command using the cqrs.CreateCommand helper function

```go
changePasswordCommand := cqrs.CreateCommand(
  ChangePasswordCommand{accountID, "$ThisIsANOTHERPassword"})
commandBus.PublishCommands([]cqrs.Command{changePasswordCommand})
```

The corresponding command handler for the **ChangePassword** command plays the role of a DDD aggregate root; responsible for the consistency and lifetime of aggregates and entities within the system)
```go
commandDispatcher.RegisterCommandHandler(ChangePasswordCommand{}, func(command cqrs.Command) error {
  changePasswordCommand := command.Body.(ChangePasswordCommand)
  // Load account from storage
  account, err := NewAccountFromHistory(changePasswordCommand.AccountID, repository)
  if err != nil {
    return err
  }

account.ChangePassword(changePasswordCommand.NewPassword)

// Persist new events
  repository.Save(account)  
  return nil
})
```

As the read models become consistant, within the tests, we check at the end of the test if everything is in sync
```go
if account.EmailAddress != lastEmailAddress {
  t.Fatal("Expected emailaddress to be ", lastEmailAddress)
}

if account.Balance != readModel.Accounts[accountID].Balance {
  t.Fatal("Expected readmodel to be synced with write model")
}
```