Youtube API ne parvient pas à créer deux liaisons simultanées de livestreams et livebroadcasts (1 à 1)

Question

D'abord, je vais vous expliquer comment cela fonctionne pour créer des diffusions en direct en utilisant l'API Youtube puis Deuxième, je vais expliquer le cas d'utilisation mon extrait de code.

Comment ça marche:

Fondamentalement, vous devez créer un LiveBroadcast (youtube.liveBroadcasts.insert) et obtenir le id LiveBroadcast (1) puis créer un livestream (youtube.liveStreams.insert) et obtenir l'ID livestream de il (2) une fois que vous avez à la fois vous devez lier le livestream au LiveBroadcast (youtube.liveBroadcasts.bind):

le résultat de la liaison contient ba siquement l'URL du flux.

Le cas d'utilisation:

Fondamentalement, il est un livestreaming api: l'utilisateur enregistrer un ou plusieurs comptes youtube, je lance le code ci-dessous pour créer livestreams chercher les urls RTMP pour que je puisse diffuser simultanément sur plusieurs youtube canaux.

le code:

oauth2Client.setCredentials({ 
    access_token: youtube_tokens.access_token, 
    refresh_token: youtube_tokens.refresh_token, 
    expiry_date: true 
}); 

var youtube_broadcasts_body = { 
    snippet: { 
     //  "scheduledEndTime": "2016-11-23T20:00:00.0+08", 
     "scheduledStartTime": start_date, 
     "title": target.stream_title 
    }, 
    status: { 
     "privacyStatus": "private" 
    }, 
    contentDetails: { 
     "projection": youtubeProjection 
    } 
} 
var youtube_livebroadcast_params = { 
    part: "id,snippet,status, contentDetails", 
    resource: youtube_broadcasts_body 
} 
var youtube_stream_body = { 
    snippet: { 
     "title": target.stream_title 
    }, 
    cdn: { 
     "ingestionType": "rtmp", 
     "frameRate": "30fps", 
     "resolution": target.youtube_resolution 
    } 
} 
var youtube_stream_params = { 
    part: "id,snippet,cdn,status", 
    resource: youtube_stream_body 
} 
var youtube = google.youtube({ version: 'v3', auth: oauth2Client }); 

youtube.liveBroadcasts.insert(youtube_livebroadcast_params, function(err, res) { 
    if (err) { 
     logger.fatal(err) 
     return callback(err) 
    } 
    target.broadcast = res 
    target.status = "livebroadcast_event_created" 
    var broadcast_id = res.id 

    youtube.liveStreams.insert(youtube_stream_params, function(err, res) { 
     if (err) { 
      logger.fatal(err) 
      return callback(err) 
     } 
     var stream_id = res.id 
     res.broadcast_id = broadcast_id 
     target.stream = res 
     target.status = "livestream_created" 
     var youtube_livebroadcast_bind_params = { 
      part: "id,contentDetails", 
      streamId: stream_id, 
      id: broadcast_id 
     } 

     youtube.liveBroadcasts.bind(youtube_livebroadcast_bind_params, function(err, res) { 
      if (err) return callback(err) 
      target.status = "livebroadcast_bound_to_livestream" 
      target.ingest_url = target.stream.cdn.ingestionInfo.ingestionAddress + "/" + target.stream.cdn.ingestionInfo.streamName 
      target._id = broadcast_id 
      return callback(null, target) 
     }) 
    }) 
}) 

Qu'est-ce qui se passe est que lorsque j'appelle ce code deux fois (dans une boucle) api Youtube renvoie une erreur: LiveBroadcast introuvable Comme il y a une course condition quelque part causant de créer 1 seul et tous les autres échoue. Une solution de contournement sale que je devais faire est d'ajouter un délai d'attente (toutes les 2 secondes), mais si plus d'un utilisateur utilisera "mon API", tout cela échouera.

Maintenant, je pense à la création d'une file d'attente qui va gérer la création des livestreams youtube. Vous vous demandez si quelqu'un avait la question ...

Answer 1

Le problème est que ce code est enveloppé dans une fonction qui utilise un extérieur oauth2Client objet initialisé l'extérieur:

const oauth2Client = new OAuth2(// initialize the object outside is wrong 
     YOUTUBE_CLIENT_ID,   // when you wanna use new tokens 
     YOUTUBE_CLIENT_SECRET,  // inside the function. 
     YOUTUBE_REDIRECT_URL 
); 

var createLiveEvent = function(target, callback) { 

    var youtubeDestination = target.destination 
    var youtube_tokens = youtubeDestination.user_data; 

    oauth2Client.setCredentials({ 
     access_token: youtube_tokens.access_token, //tokens got from oauth2 authentication 
     refresh_token: youtube_tokens.refresh_token, 
     expiry_date: true 
    }); 


    var youtube = google.youtube({ 
     version: 'v3', 
     auth: oauth2Client 
    }); 

    logger.debug("Youtube: Creating event on Channel ") 
    .... 
    .... 

}) 

La solution est en fait d'utiliser un différents oauth2Client objet intérieur la fonction pour tous les différents access_token/refresh_token:

var createLiveEvent = function(target, callback) { 
    let oauth2Client = new OAuth2(
     YOUTUBE_CLIENT_ID, 
     YOUTUBE_CLIENT_SECRET, 
     YOUTUBE_REDIRECT_URL 
    ); 


    var youtubeDestination = target.destination 
    var youtube_tokens = youtubeDestination.user_data; 

    oauth2Client.setCredentials({ 
     access_token: youtube_tokens.access_token, 
     refresh_token: youtube_tokens.refresh_token, 
     expiry_date: true 
    }); 

    .... 
    .... 
});