Golang

paquete principal función principal() { c := hacer canal de int, 1) para rango 3 { seleccionar { predeterminado: println(1) caso <-c: println(2) caso c <- 1: println(3) } } }

```go func fail() { panic("¡Fallar!") } func main() { fmt.Println("¡Inicio!") 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("¡Fin!") } ```

¿Por qué eligieron Elasticsearch? ¿Cuáles eran las opciones? ¿Eligieron algo o simplemente ya tenían ELK?

¿Tiene alguna pregunta sobre los proyectos o las condiciones de trabajo?

Dices que con Elasticsearch crearon una herramienta para la búsqueda rápida de transacciones. ¿Qué es esto, cuántas transacciones hay y qué beneficios aporta?

func fetch(ctx context.Context, u User) (string, error) { // hacemos algo en la red time.Sleep(time.Millisecond * 10) // simulación de retraso return u.Name, nil //return "", errors.New("algún error") } 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: } }() }

¿Al final, de qué soluciones eligieron? ClickHouse, ELK y ¿qué más?

¿Dónde trabajas ahora?

¿Hubo algún comentario de los usuarios o del servicio de soporte técnico después de la implementación de Elasticsearch?

¿Qué hace que un sistema sea de alta carga? Basándose en su experiencia.

¿Tiene usted un certificado militar?

¿De qué cantidad considera la oferta?

paquete principal importar ( "fmt" ) función principal() { c := make(chan string, 1) go fmt.Println(<-c) c <- "¡Hola Mundo!" fmt.Println("¡Salida!") } error fatal: ¡todas las goroutines están dormidas - bloqueo muerto! goroutine 1 [recepción de canal]: main.main() /tmp/sandbox[phone]/prog.go:10 +0x3a Programa finalizado: estado 2.

paquete principal función principal() { c := hacer(canal de int) para rango 3 { seleccionar { predeterminado: imprimir(1) caso <-c: imprimir(2) caso c <- 1: imprimir(3) } } }

paquete principal importar ( "fmt" ) función principal() { c := make(chan string) go fmt.Println(<-c) c <- "¡Hola Mundo!" fmt.Println("¡Salida!") }

¿Qué tienen que ver los servicios si estamos hablando de tolerancia a fallos y lo hemos reducido a réplicas?

paquete principal importar ( "fmt" ) función principal() { c := make(chan string) go fmt.Println(<-c) c <- "¡Hola Mundo!" fmt.Println("¡Salida!") } error fatal: ¡todos los goroutines están dormidos - deadlock! goroutine 1 [recepción de canal]: main.main() /tmp/sandbox[phone]/prog.go:10 +0x3a Programa finalizado: estado 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() }

¿Dónde vives ahora?

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 }