время выполнения / cgo: сбой pthread_create: ресурс временно недоступен - PullRequest
Новая
       30

время выполнения / cgo: сбой pthread_create: ресурс временно недоступен

4 голосов
/ 02 февраля 2020

В настоящее время у меня есть эта функция, которая передает несколько команд youtubedl через ffmpeg, а затем передает вывод ffmpeg клиенту HTTP. 

func pipeThruFfmpegToMp4(vi *VideoInfo, rw web.ResponseWriter) error {
    var ffmpeg *exec.Cmd
    ffmpeg = exec.Command(
        "ffmpeg",
        "-i", "-",
        "-i", "pipe:3",
        "-c:v", "copy", "-c:a", "copy",
        "-preset", "veryfast",
        "-metadata", fmt.Sprintf(`title=%s`, vi.GetTitle()),
        "-movflags", "frag_keyframe+empty_moov",
        "-f", "mp4",
        "-")


    youtubevideo := exec.Command(YoutubeDLPath, "-c", "-f", fmt.Sprintf("%s/bestvideo[ext=mp4]/bestvideo/best", vi.GetFormat()), "--no-cache-dir", "--restrict-filenames", "--hls-prefer-native", "-o", "-", fmt.Sprintf("%s", vi.GetVideoUrl()))
    fmt.Println(youtubevideo)

    youtube := exec.Command(YoutubeDLPath, "-c", "-f", "bestaudio[ext=m4a]/bestaudio/best", "--no-cache-dir", "--restrict-filenames", "--hls-prefer-native", "-o", "-", fmt.Sprintf("%s", vi.GetVideoUrl()))
    fmt.Println(youtube)

    var ytvbuf, ytbuf, ffbuf bytes.Buffer
    youtubevideo.Stderr = &ytvbuf
    youtube.Stderr = &ytbuf
    ffmpeg.Stderr = &ffbuf

    video, err := youtubevideo.StdoutPipe()
    if err != nil {
        log.Printf("pipeThruFfmpegToMp4: %v\n", err)
        return err
    }

    pipe3, err := youtube.StdoutPipe()
    if err != nil {
        log.Printf("pipeThruFfmpegToMp4: %v\n", err)
        return err
    }

    ffmpeg.Stdin = video
    ffmpeg.ExtraFiles = []*os.File{pipe3.(*os.File)}
    ffmpeg.Stdout = rw

    // Headers sent, no turning back now
    rw.Header().Set("Content-Type", "video/mp4")
    rw.Header().Set("Content-Disposition", fmt.Sprintf("attachment;filename=\"%s.mp4\"", vi.GetSlug()))
    rw.Flush()

    ffmpeg.Start()
    youtubevideo.Start()
    youtube.Start()
    ffmpeg.Wait()
    youtubevideo.Wait()
    youtube.Wait()

    // check ytvbuf, ytbuf, ffbuf for stderr errors

    if ffbuf.Len() != 0 {
        rollbar.Error(rollbar.ERR, err, &rollbar.Field{"stderr", ffbuf.String()})
        log.Printf("pipeThruFfmpegToMp4: %v\n", ffbuf.String())
    }
    if ytvbuf.Len() != 0 {
        rollbar.Error(rollbar.ERR, err, &rollbar.Field{"stderr", ytvbuf.String()})
        log.Printf("pipeThruYouTubevDLToMp4: %v\n", ytvbuf.String())
    }
    if ytbuf.Len() != 0 {
        rollbar.Error(rollbar.ERR, err, &rollbar.Field{"stderr", ytbuf.String()})
        log.Printf("pipeThruYouTubeDLToMp4: %v\n", ytbuf.String())
    }

    return nil
}

Проблема в том, что все работает нормально, но через некоторое время оперативная память начинает заполняться на сервере, пока не дойдет до того, что она выдаст ошибку с runtime/cgo: pthread_create failed: Resource temporarily unavailable

Я не уверен, утечка ли это памяти или не закрывается какой-либо экземпляр youtube-dl правильно или если ffmpeg не закрывается правильно и просто потребляет все больше оперативной памяти по мере того, как программа работает больше, пока программа не завершится с этой ошибкой 

runtime/cgo: pthread_create failed: Resource temporarily unavailable
SIGABRT: abort
PC=0x7f083501fe97 m=128 sigcode=18446744073709551610

goroutine 0 [idle]:
runtime: unknown pc 0x7f083501fe97
stack: frame={sp:0x7f05ff7fd7d0, fp:0x0} stack=[0x7f05feffe288,0x7f05ff7fde88)
00007f05ff7fd6d0:  00007f05ff7fd700  0000ffff00001fa0
00007f05ff7fd6e0:  00007f05ff7fdbe0  00007f05f8000da0
00007f05ff7fd6f0:  0000000000000000  000000000093032c
00007f05ff7fd700:  0000000000000000  00007f0835600ec3
00007f05ff7fd710:  0000000000000005  0000000000000000
00007f05ff7fd720:  000000c0000ce120  00007f0834ff1ce0
00007f05ff7fd730:  00007f05ff7fdaf0  00007f083560870a
00007f05ff7fd740:  0000000000000000  0000000000000000
00007f05ff7fd750:  0000000000000000  00007f05ff7fdbe0
00007f05ff7fd760:  2525252525252525  2525252525252525
00007f05ff7fd770:  000000ffffffffff  0000000000000000
00007f05ff7fd780:  000000ffffffffff  0000000000000000
00007f05ff7fd790:  000000c00010d1a0  000000c000953740
00007f05ff7fd7a0:  000000c0000ce120  000000c000cf2300
00007f05ff7fd7b0:  000000c00010d260  000000c001f4e180
00007f05ff7fd7c0:  000000c001f4e000  000000c00169f680
00007f05ff7fd7d0: <0000000000000000  000000c001f34180
00007f05ff7fd7e0:  6e75720000000000  6f67632f656d6974
00007f05ff7fd7f0:  0000000000000000  0000000000000000
00007f05ff7fd800:  000000c000cf2300  000000c00010d260
00007f05ff7fd810:  000000c001f4e180  000000c001f4e000
00007f05ff7fd820:  000000c00169f680  000000c00169f500
00007f05ff7fd830:  000000c001f34180  000000c001f34000
00007f05ff7fd840:  000000c000c92780  000000c001ec2600
00007f05ff7fd850:  fffffffe7fffffff  ffffffffffffffff
00007f05ff7fd860:  ffffffffffffffff  ffffffffffffffff
00007f05ff7fd870:  ffffffffffffffff  ffffffffffffffff
00007f05ff7fd880:  ffffffffffffffff  ffffffffffffffff
00007f05ff7fd890:  ffffffffffffffff  ffffffffffffffff
00007f05ff7fd8a0:  ffffffffffffffff  ffffffffffffffff
00007f05ff7fd8b0:  ffffffffffffffff  ffffffffffffffff
00007f05ff7fd8c0:  ffffffffffffffff  ffffffffffffffff
runtime: unknown pc 0x7f083501fe97
stack: frame={sp:0x7f05ff7fd7d0, fp:0x0} stack=[0x7f05feffe288,0x7f05ff7fde88)
00007f05ff7fd6d0:  00007f05ff7fd700  0000ffff00001fa0
00007f05ff7fd6e0:  00007f05ff7fdbe0  00007f05f8000da0
00007f05ff7fd6f0:  0000000000000000  000000000093032c
00007f05ff7fd700:  0000000000000000  00007f0835600ec3
00007f05ff7fd710:  0000000000000005  0000000000000000

Я также пытался собрать двоичный файл с CGO_ENABLED=0 хотя у меня даже нет import "c", но это также приводит к ошибкам с 

runtime: failed to create new OS thread (have 21 already; errno=11)
runtime: may need to increase max user processes (ulimit -u)
fatal error: newosproc

, мои лимиты уже очень щедры, что может также быть проблемой? Или мне, возможно, придется увеличить размер трубы? 

$ ulimit -a
core file size          (blocks, -c) 0
data seg size           (kbytes, -d) unlimited
scheduling priority             (-e) 0
file size               (blocks, -f) unlimited
pending signals                 (-i) 192907
max locked memory       (kbytes, -l) 16384
max memory size         (kbytes, -m) unlimited
open files                      (-n) 100000
pipe size            (512 bytes, -p) 8
POSIX message queues     (bytes, -q) 819200
real-time priority              (-r) 0
stack size              (kbytes, -s) 65536
cpu time               (seconds, -t) unlimited
max user processes              (-u) 63883
virtual memory          (kbytes, -v) unlimited

В любом случае, я ценю любую помощь, которую я могу получить в этом. Вот ссылка на всю программу , а вот ветка на форуме golang -nuts по этим вопросам

Ответы [ 2 ]

3 голосов
/ 05 февраля 2020

У меня иногда возникали проблемы, когда ваш код не убивал процессы youtube-dl. Видео было конвертировано, но процесс сохранился. В качестве первого индикатора просмотрите количество процессов, например: 

ps | grep youtube-dl | wc -l

Можно разрешить тайм-аут подпроцессов, для одного подпроцесса это будет выглядеть так: 

package main

import (
    "bytes"
    "fmt"
    "os/exec"
    "time"
)

func main() {
    // Sleep is used, so we can control how long it runs.
    cmd := exec.Command("sleep", "2")

    // Use a bytes.Buffer to get the output
    var buf bytes.Buffer
    cmd.Stdout = &buf

    cmd.Start()

    // Use a channel to signal completion so we can use a select statement
    done := make(chan error)
    go func() { done <- cmd.Wait() }()

    // Start a timer, should be higher for your video conversion, 
    // I suggest you use a value that fits both your videos and server capabilities
    timeout := time.After(2 * time.Second)

    // The select statement allows us to execute based on which channel
    // we get a message from first.
    select {
    case <-timeout:
        // Timeout happened first, kill the process and print a message.
        cmd.Process.Kill()
        fmt.Println("Command timed out")
    case err := <-done:
        // Command completed before timeout. Print output and error if it exists.
        fmt.Println("Output:", buf.String())
        if err != nil {
            fmt.Println("Non-zero exit code:", err)
        }
    }
}

В вашем Если вы можете заменить 

    ffmpeg.Start()
    youtubevideo.Start()
    youtube.Start()
    ffmpeg.Wait()
    youtubevideo.Wait()
    youtube.Wait()

на 

    ffmpeg.Start()
    youtubevideo.Start()
    youtube.Start()
    commands := 3

    done := make(chan error)
    go func() { done <- ffmpeg.Wait() }()
    go func() { done <- youtubevideo.Wait() }()
    go func() { done <- youtube.Wait() }()

    timeout := time.After(1 * time.Hour)

Loop:
    for {
        select {
        case <-timeout:
            ffmpeg.Process.Kill()
            youtubevideo.Process.Kill()
            youtube.Process.Kill()
            log.Println("Conversion timed out")
            break Loop
        case err := <-done:
            if err != nil {
                log.Println("Non-zero exit code:", err)
            }
            commands = commands - 1
            if commands == 0 {
                break Loop
            }
        }
    }
2 голосов
/ 15 февраля 2020

Итак, после некоторой отладки и с помощью ответа Кевина. Кажется, youtube-dl не закрывался после того, как это было успешно.

Учитывая, что если ffmpeg завершено, то не будет никакого смысла запускать экземпляр youtube-dl, и поскольку функция Wait() ожидает youtube-dl до конца sh, но это Кажется, что никогда не посылает сигнал о своем окончании sh, я пошел дальше и мне пришлось добавить kill, чтобы также уничтожить дочерние подпроцессы.

Так что мне пришлось добавить изменить это 

    ffmpeg.Start()
    youtubevideo.Start()
    youtube.Start()
    ffmpeg.Wait()
    youtubevideo.Wait()
    youtube.Wait()

К этому 

    youtube.SysProcAttr = &syscall.SysProcAttr{Setpgid: true}
    youtubevideo.SysProcAttr = &syscall.SysProcAttr{Setpgid: true}
    ffmpeg.Start()
    youtubevideo.Start()
    youtube.Start()
    ffmpeg.Wait()
    syscall.Kill(-youtube.Process.Pid, syscall.SIGKILL)
    syscall.Kill(-youtubevideo.Process.Pid, syscall.SIGKILL)
    youtubevideo.Wait()
    youtube.Wait()

Обратите внимание, поскольку кажется, что это делает своего рода дочерний подпроцесс, youtube.Process.Kill() на самом деле не убивал процесс, поэтому мне пришлось использовать syscall, а также Setpgid: true

...