Golang

Hauptpaket 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("Fehler!") } 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("Fertig!") } ```

Warum haben Sie Elasticsearch gewählt? Welche Alternativen gab es? Haben Sie etwas anderes gewählt oder war das ELK bereits vorhanden?

Haben Sie Fragen zu den Projekten oder den Arbeitsbedingungen?

Du sagst, dass ihr mit Elasticsearch eine Funktion für die schnelle Suche nach Transaktionen entwickelt habt. Was ist das, wie viele Transaktionen gibt es und welchen Nutzen hat das?

func fetch(ctx context.Context, u User) (string, error) { // etwas im Netzwerk machen time.Sleep(time.Millisecond * 10) // Verzögerung simulieren return u.Name, nil //return "", errors.New("irgendein Fehler") } 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: } }() }

Letztendlich, welche Lösungen wurden ausgewählt? ClickHouse, ELK und was noch?

Wo arbeiten Sie derzeit?

Gab es nach der Einführung von Elasticsearch Feedback von den Nutzern oder dem technischen Support?

Was macht ein System hochbelastet? Basierend auf Ihrer Expertise.

Haben Sie einen Wehrpass?

Hauptpaket import ( "fmt" ) func main() { c := make(chan string, 1) go fmt.Println(<-c) c <- "Hallo Welt!" fmt.Println("Ausgang!") } fataler Fehler: alle Goroutinen sind eingeschlafen - Deadlock! goroutine 1 [Kanal empfangen]: main.main() /tmp/sandbox[phone]/prog.go:10 +0x3a Programm beendet: Status 2.

Paket Haupt func main() { c := make(chan int) für Bereich 3 { select { default: println(1) fall <-c: println(2) fall c <- 1: println(3) } } }

Ab welcher Summe betrachten Sie das Angebot?

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

Was haben Dienste damit zu tun, wenn wir über Fehlertoleranz sprechen und es auf Replikate reduziert haben?

Hauptpaket importiere ( "fmt" ) func main() { c := make(chan string) go fmt.Println(<-c) c <- "Hallo Welt!" fmt.Println("Beenden!") } fataler Fehler: alle Goroutinen schlafen - Deadlock! goroutine 1 [Kanal empfangen]: main.main() /tmp/sandbox[phone]/prog.go:10 +0x3a Programm beendet: 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() }

Wo wohnst du jetzt?

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 }