Golang

hoofd pakket func main() { c := make(chan int, 1) for range 3 { select { default: println(1) case <-c: println(2) case c <- 1: println(3) } } }

```go func fail() { panic("Falen!") } func main() { fmt.Println("Start!") var wg sync.WaitGroup wg.Add(1) go func() { defer func() { if e := recover(); e != nil { fmt.Println(e) } }() fail() wg.Done() }() wg.Wait() fmt.Println("Einde!") } ```

Waarom hebben jullie voor Elasticsearch gekozen? Welke opties waren er? Hebben jullie iets anders gekozen of was ELK er al?

Heeft u vragen over de projecten of de arbeidsvoorwaarden?

Je zegt dat je met Elasticsearch een tool hebt gemaakt voor snelle zoekopdrachten naar transacties. Wat is dat, hoeveel transacties zijn er en wat is het voordeel?

func fetch(ctx context.Context, u User) (string, error) { // iets doen in het netwerk time.Sleep(time.Millisecond * 10) // vertraging simulatie return u.Name, nil //return "", errors.New("enkele fout") } func Do(ctx context.Context, users []User) (map[string]int64, error) { var mu sync.Mutex var wg sync.WaitGroup ch := make(chan error, len(users)) names := make(map[string]int64, 0) ctxWithCancel, cancel := context.WithCancel(ctx) wg.Add(len(users)) for _, u := range users { go func() { defer wg.Done() select { case name, err := fetch(ctx, u): if err != nil { ch <- err return } mu.Lock() names[name] = names[name] + 1 mu.Unlock() case <-ctxWithCancel.Err: } }() }

Uiteindelijk, uit welke oplossingen hebben ze gekozen? ClickHouse, ELK en wat nog meer?

Waar werk je momenteel?

Was er na de implementatie van Elasticsearch enige productfeedback van gebruikers of de technische ondersteuning?

Wat maakt een systeem hoogbelast? Gebaseerd op uw expertise.

Heeft u een militair document?

Vanaf welk bedrag overweegt u het aanbod?

hoofd pakket import ( "fmt" ) func main() { c := make(chan string, 1) go fmt.Println(<-c) c <- "Hallo Wereld!" fmt.Println("Uitgang!") } fatale fout: alle goroutines slapen - deadlock! goroutine 1 [chan ontvangst]: main.main() /tmp/sandbox[phone]/prog.go:10 +0x3a Programma beëindigd: status 2.

hoofd pakket func main() { c := maken(chan int) voor bereik 3 { select { standaard: println(1) geval <-c: println(2) geval c <- 1: println(3) } } }

package main import ( "fmt" ) func main() { c := make(chan string) go fmt.Println(<-c) c <- "Hello World!" fmt.Println("Exit!") }

Wat hebben services te maken met fouttolerantie als we het hebben over replicaties?

main pakket importeer ( "fmt" ) func main() { c := make(chan string) go fmt.Println(<-c) c <- "Hallo Welt!" fmt.Println("Ausgang!") } fatale fout: alle goroutines slapen - deadlock! goroutine 1 [kanaal ontvangen]: main.main() /tmp/sandbox[phone]/prog.go:10 +0x3a Programma geëindigd: status 2.

var defaultTxOptions = &sql.TxOptions{} const defaultCurrency = "RUB" func CreateUserWithDefaultCurrency(ctx context.Context, db *sql.DB, email, passwordHash string) error { tx, err := db.BeginTx(ctx, defaultTxOptions) if err != nil { return err } defer func() { if err != nil{ tx.Rollback() } }() _, err = tx.Exec("INSERT INTO users (email, password) VALUES (?, ?)", email, passwordHash) if err != nil { return err } rows, err := tx.Query("SELECT id FROM users WHERE email = ?", email) if err != nil { return err } defer rows.Close() id := 0 for rows.Next() { err = rows.Scan(&id) if err != nil { return err } } _, err = tx.Exec("INSERT INTO balances (user_id, currency, current_balance) VALUES (?, ?, 0)", id, defaultCurrency) if err != nil { return err } return tx.Commit() }

Waar woon je nu?

func Do(ctx context.Context, users []User) (map[string]int64, error) { var mu sync.Mutex var wg sync.WaitGroup ch := make(chan error, len(users)) names := make(map[string]int64, 0) ctxWithCancel, cancel := context.WithCancel(ctx) wg.Add(len(users)) for _, u := range users { go func() { defer wg.Done() select { case name, err := fetch(ctx, u): if err != nil { ch <- err return } mu.Lock() names[name] = names[name] + 1 mu.Unlock() case <-ctxWithCancel.Err: } }() } return names, nil }