package main

import (
 "github.com/gliderlabs/ssh"
 "io"
 "log"
)

func main() {
 ssh.Handle(func(s ssh.Session) {
     io.WriteString(s, "Hello world\n")
 })  

 log.Fatal(ssh.ListenAndServe(":2222", nil))
}

import (
  ...
  terminal "golang.org/x/term"
)

func sessionHandler(s gssh.Session) {
  defer s.Close()
  if s.RawCommand() != "" {
    io.WriteString(s, "raw commands are not supported")
    return
  }
    
    // создаем терминал
  term := terminal.NewTerminal(s,
    fmt.Sprintf("/%s/ > ", s.User()))

    // добавляем обработку pty-request 
  pty, winCh, isPty := s.Pty()
  if isPty {
    _ = pty
    go func() {
            // реагируем на изменение размеров терминала
      for chInfo := range winCh {
        _ = term.SetSize(chInfo.Width, chInfo.Height)
      }
    }()
  }

  for {
        // считываем ввод пользователя
    line, err := term.ReadLine()
    if err == io.EOF {
      _, _ = io.WriteString(s, "EOF.\n")
      break
    }
    
        // обработаем результат
    result = processInput(line)
      
        // выведем в терминал
        io.WriteString(term, result)
  }
}

import (
    "github.com/golang-migrate/migrate/v4"
    _ "github.com/golang-migrate/migrate/v4/database/postgres"
    _ "github.com/golang-migrate/migrate/v4/source/github"
)

func main() {
    m, err := migrate.New(
        "github://mattes:personal-access-token@mattes/migrate_test",
        "postgres://localhost:5432/database?sslmode=enable")
    m.Steps(2)
}

type Response2 struct {
    Page   int      `json:"page"`
    Fruits []string `json:"fruits"`
}

type Response2 struct {
    Page   int      `json:"page" yaml:"page" validation:"min:1,max:10"`
    Fruits []string `json:"fruits" yaml:"fruits,omitempty" validation:"nonempty"`
}

r := &Response2{}
json.Read("file.json", r)
validator.Validate(r)
yaml.Write("file.yaml", r)

package main

import (
"fmt"
"sync"
)

func FibonacciRecursion(n int) int {
    if n <= 1 {
        return n
    }
    return FibonacciRecursion(n-1) + FibonacciRecursion(n-2)
}

func f(i int, wg *sync.WaitGroup) {
    defer wg.Done()
    fmt.Println(FibonacciRecursion(45 + i))
}

func fun() {
    var wg sync.WaitGroup
    for i := 0; i < 3; i++ {
        go f(i, &wg)
       wg.Add(1)
    }
    wg.Wait()
    println("Function ended")
}

func main() {
    fun()
}

package main

import (
    "context"
    "fmt"
    "sync"
    "time"
)

func main() {
    timeLimit := time.Second * 10
    ctx, cancel := context.WithTimeout(context.Background(), timeLimit)
    defer cancel()
    fun(ctx)
}

func isDone(ctx context.Context) bool {
    select {
    case <-ctx.Done():
        return true
    default:
        return false
    }
}

func FibonacciRecursion(ctx context.Context, n int) int {
    if n <= 1 || isDone(ctx) {
        return n
    }
    return FibonacciRecursion(ctx, n-1) + FibonacciRecursion(ctx, n-2)
}

func f(ctx context.Context, i int, wg *sync.WaitGroup) {
    defer wg.Done()
    fmt.Println(FibonacciRecursion(ctx, 45+i))
}

func fun(ctx context.Context) {
    var wg sync.WaitGroup
    for i := 0; i < 3; i++ {
        wg.Add(1)
        go f(ctx, i, &wg)
    }
    wg.Wait()
    println("Function ended")
}

ctx, _ := context.WithTimeout(context.Background(), timeoutSecond*time.Second)

client, err := mongo.Connect(ctx, options.Client().ApplyURI(connString))

err := mr.client.Database(mr.dbName).Collection(mr.collName).FindOne(ctx, filter).Decode(&p)

select {
case <-ctx.Done():
    return nil, ctx.Err()
case <-selectionState.timeoutChan:
    return nil, wrapServerSelectionError(ErrServerSelectionTimeout, t)
case current = <-subscriptionCh:
}

client, err := mongo.NewClient(options.Client().ApplyURI("mongodb://localhost:27017"),
        options.Client().SetConnectTimeout(time.Second * myTimeout),
        options.Client().SetServerSelectionTimeout(time.Second * myServerTimeout))