389 lines
8.5 KiB
Go
389 lines
8.5 KiB
Go
package main
|
|
|
|
import (
|
|
"context"
|
|
_ "embed"
|
|
"encoding/json"
|
|
"fmt"
|
|
"log"
|
|
"net/http"
|
|
"os"
|
|
"path"
|
|
"strings"
|
|
"sync"
|
|
|
|
"golang.org/x/oauth2"
|
|
"golang.org/x/oauth2/google"
|
|
"google.golang.org/api/youtube/v3"
|
|
|
|
"arimelody.space/vodular/config"
|
|
"arimelody.space/vodular/scanner"
|
|
vid "arimelody.space/vodular/video"
|
|
yt "arimelody.space/vodular/youtube"
|
|
)
|
|
|
|
//go:embed res/help.txt
|
|
var helpText string
|
|
|
|
const segmentExtension = "mkv"
|
|
|
|
func showHelp() {
|
|
execSplits := strings.Split(os.Args[0], "/")
|
|
execName := execSplits[len(execSplits) - 1]
|
|
fmt.Printf(helpText, execName)
|
|
}
|
|
|
|
func main() {
|
|
// config
|
|
cfg, err := config.ReadConfig(config.CONFIG_FILENAME)
|
|
if err != nil {
|
|
log.Fatalf("Failed to read config: %v", err)
|
|
os.Exit(1)
|
|
}
|
|
if cfg == nil {
|
|
err = config.GenerateConfig(config.CONFIG_FILENAME)
|
|
if err != nil {
|
|
log.Fatalf("Failed to generate config: %v", err)
|
|
os.Exit(1)
|
|
}
|
|
log.Printf(
|
|
"New config file created (%s). " +
|
|
"Please edit this file before running again!",
|
|
config.CONFIG_FILENAME,
|
|
)
|
|
os.Exit(0)
|
|
}
|
|
|
|
// arguments
|
|
if len(os.Args) < 2 || os.Args[1] == "--help" || os.Args[1] == "-h" {
|
|
showHelp()
|
|
os.Exit(0)
|
|
}
|
|
|
|
var verbose bool = false
|
|
var initDirectory bool = false
|
|
var logout bool = false
|
|
var deleteFullVod bool = false
|
|
var forceUpload bool = false
|
|
var directory string
|
|
|
|
for i, arg := range os.Args {
|
|
if i == 0 { continue }
|
|
if strings.HasPrefix(arg, "-") {
|
|
switch arg {
|
|
|
|
case "-h":
|
|
fallthrough
|
|
case "--help":
|
|
showHelp()
|
|
os.Exit(0)
|
|
|
|
case "-v":
|
|
fallthrough
|
|
case "--verbose":
|
|
verbose = true
|
|
|
|
case "--init":
|
|
initDirectory = true
|
|
|
|
case "--logout":
|
|
logout = true
|
|
|
|
case "-d":
|
|
fallthrough
|
|
case "--deleteAfter":
|
|
deleteFullVod = true
|
|
|
|
case "-f":
|
|
fallthrough
|
|
case "--force":
|
|
forceUpload = true
|
|
|
|
default:
|
|
fmt.Fprintf(os.Stderr, "Unknown option `%s`\n", arg)
|
|
os.Exit(1)
|
|
|
|
}
|
|
} else {
|
|
directory = arg
|
|
}
|
|
}
|
|
|
|
if !strings.HasPrefix(directory, "/") {
|
|
if wd, err := os.Getwd(); err != nil {
|
|
directory = path.Join(directory, wd)
|
|
}
|
|
}
|
|
|
|
// logout (--logout)
|
|
if logout {
|
|
cfg.Token = nil
|
|
err = config.WriteConfig(cfg, config.CONFIG_FILENAME)
|
|
if err != nil {
|
|
log.Fatalf("Failed to write config: %v", err)
|
|
os.Exit(1)
|
|
}
|
|
log.Println("Logged out successfully.")
|
|
os.Exit(0)
|
|
}
|
|
|
|
// initialising directory (--init)
|
|
if initDirectory {
|
|
err = initialiseDirectory(directory)
|
|
if err != nil {
|
|
log.Fatalf("Failed to initialise directory: %v", err)
|
|
os.Exit(1)
|
|
}
|
|
log.Printf(
|
|
"Directory successfully initialised. " +
|
|
"Be sure to update %s before uploading!",
|
|
scanner.METADATA_FILENAME,
|
|
)
|
|
os.Exit(0)
|
|
}
|
|
|
|
// good to have early on
|
|
templates, err := yt.FetchTemplates()
|
|
if err != nil {
|
|
log.Fatalf("Failed to fetch templates: %v", err)
|
|
os.Exit(1)
|
|
}
|
|
|
|
// read directory metadata
|
|
metadata, err := scanner.ReadMetadata(directory)
|
|
if err != nil {
|
|
if os.IsNotExist(err) {
|
|
log.Fatalf("Directory does not exist: %s", directory)
|
|
os.Exit(1)
|
|
}
|
|
log.Fatalf("Failed to fetch VOD metadata: %v", err)
|
|
os.Exit(1)
|
|
}
|
|
if metadata == nil {
|
|
log.Fatal(
|
|
"Directory contained no metadata. " +
|
|
"Use `--init` to initialise this directory.",
|
|
)
|
|
os.Exit(1)
|
|
}
|
|
|
|
// skip uploading if already done
|
|
if metadata.Uploaded == !forceUpload {
|
|
log.Printf(
|
|
"VOD has already been uploaded. " +
|
|
"Use --force to override, or update the %s.",
|
|
scanner.METADATA_FILENAME,
|
|
)
|
|
os.Exit(0)
|
|
}
|
|
|
|
// default footage directory
|
|
if len(metadata.FootageDir) == 0 {
|
|
metadata.FootageDir = directory
|
|
} else if !strings.HasPrefix(metadata.FootageDir, "/") {
|
|
metadata.FootageDir = path.Join(directory, metadata.FootageDir)
|
|
}
|
|
|
|
// scan for VOD segments
|
|
vodFiles, err := scanner.ScanSegments(metadata.FootageDir, segmentExtension)
|
|
if err != nil {
|
|
log.Fatalf("Failed to fetch VOD filenames: %v", err)
|
|
os.Exit(1)
|
|
}
|
|
if len(vodFiles) == 0 {
|
|
log.Fatalf(
|
|
"Directory contained no VOD files (expecting .%s)",
|
|
segmentExtension,
|
|
)
|
|
os.Exit(1)
|
|
}
|
|
if verbose {
|
|
enc := json.NewEncoder(os.Stdout)
|
|
enc.SetIndent("", "\t")
|
|
fmt.Printf("Directory metadata: ")
|
|
enc.Encode(metadata)
|
|
fmt.Printf("\nVOD files available: ")
|
|
enc.Encode(vodFiles)
|
|
}
|
|
|
|
// build video template for upload
|
|
video, err := yt.BuildVideo(metadata)
|
|
if err != nil {
|
|
log.Fatalf("Failed to build video template: %v", err)
|
|
os.Exit(1)
|
|
}
|
|
if verbose {
|
|
enc := json.NewEncoder(os.Stdout)
|
|
fmt.Printf("\nVideo template: ")
|
|
enc.Encode(video)
|
|
|
|
title, err := yt.BuildTemplate(video, templates.Title)
|
|
if err != nil {
|
|
log.Fatalf("Failed to build video title: %v", err)
|
|
os.Exit(1)
|
|
}
|
|
description, err := yt.BuildTemplate(video, templates.Description)
|
|
if err != nil {
|
|
log.Fatalf("Failed to build video description: %v", err)
|
|
os.Exit(1)
|
|
}
|
|
fmt.Printf(
|
|
"\n================================\n" +
|
|
"TITLE:\n%s\n\n" +
|
|
"DESCRIPTION:\n%s\n" +
|
|
"\n================================\n",
|
|
title, description,
|
|
)
|
|
}
|
|
|
|
// concatenate VOD segments into full VOD
|
|
video.SizeBytes, err = vid.ConcatVideo(video, vodFiles, verbose)
|
|
if err != nil {
|
|
log.Fatalf("Failed to concatenate VOD segments: %v", err)
|
|
os.Exit(1)
|
|
}
|
|
|
|
// youtube oauth flow
|
|
ctx := context.Background()
|
|
oauth2Config := &oauth2.Config{
|
|
ClientID: cfg.Google.ClientID,
|
|
ClientSecret: cfg.Google.ClientSecret,
|
|
Endpoint: google.Endpoint,
|
|
Scopes: []string{ youtube.YoutubeScope },
|
|
RedirectURL: cfg.RedirectUri,
|
|
}
|
|
var token *oauth2.Token
|
|
if cfg.Token != nil {
|
|
token = cfg.Token
|
|
} else {
|
|
token, err = generateOAuthToken(&ctx, oauth2Config, cfg)
|
|
if err != nil {
|
|
log.Fatalf("OAuth flow failed: %v", err)
|
|
os.Exit(1)
|
|
}
|
|
cfg.Token = token
|
|
}
|
|
tokenSource := oauth2Config.TokenSource(ctx, token)
|
|
if err != nil {
|
|
log.Fatalf("Failed to create OAuth2 token source: %v", err)
|
|
os.Exit(1)
|
|
}
|
|
|
|
err = config.WriteConfig(cfg, config.CONFIG_FILENAME)
|
|
if err != nil {
|
|
log.Fatalf("Failed to save OAuth token: %v", err)
|
|
}
|
|
|
|
// okay actually upload now!
|
|
ytVideo, err := yt.UploadVideo(ctx, tokenSource, video, templates)
|
|
if err != nil {
|
|
log.Fatalf("Failed to upload video: %v", err)
|
|
os.Exit(1)
|
|
}
|
|
if verbose {
|
|
jsonString, err := json.MarshalIndent(ytVideo, "", " ")
|
|
if err != nil {
|
|
log.Fatalf("Failed to marshal video data json: %v", err)
|
|
}
|
|
fmt.Println(string(jsonString))
|
|
}
|
|
log.Print("Video uploaded successfully!")
|
|
|
|
// update metadata to reflect VOD is uploaded
|
|
metadata.Uploaded = true
|
|
err = scanner.WriteMetadata(directory, metadata)
|
|
if err != nil {
|
|
log.Fatalf("Failed to update metadata: %v", err)
|
|
}
|
|
|
|
// delete full VOD after upload, if requested
|
|
if deleteFullVod {
|
|
err = os.Remove(video.Filename)
|
|
if err != nil {
|
|
log.Fatalf("Failed to delete full VOD: %v", err)
|
|
}
|
|
}
|
|
}
|
|
|
|
func initialiseDirectory(directory string) error {
|
|
dirInfo, err := os.Stat(directory)
|
|
if err != nil {
|
|
if os.IsNotExist(err) {
|
|
return fmt.Errorf("no such directory: %s", directory)
|
|
}
|
|
return fmt.Errorf("failed to open directory: %v", err)
|
|
}
|
|
if !dirInfo.IsDir() {
|
|
return fmt.Errorf("not a directory: %s", directory)
|
|
}
|
|
|
|
_, err = os.Stat(path.Join(directory, scanner.METADATA_FILENAME))
|
|
if err == nil {
|
|
return fmt.Errorf("directory already initialised: %s", directory)
|
|
}
|
|
|
|
err = scanner.WriteMetadata(directory, scanner.DefaultMetadata())
|
|
|
|
return err
|
|
}
|
|
|
|
func generateOAuthToken(
|
|
ctx *context.Context,
|
|
oauth2Config *oauth2.Config,
|
|
cfg *config.Config,
|
|
) (*oauth2.Token, error) {
|
|
verifier := oauth2.GenerateVerifier()
|
|
|
|
var token *oauth2.Token
|
|
wg := sync.WaitGroup{}
|
|
var server http.Server
|
|
server.Addr = cfg.Host
|
|
server.Handler = http.HandlerFunc(
|
|
func(w http.ResponseWriter, r *http.Request) {
|
|
if !r.URL.Query().Has("code") {
|
|
http.Error(w, http.StatusText(http.StatusBadRequest), http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
code := r.URL.Query().Get("code")
|
|
|
|
t, err := oauth2Config.Exchange(*ctx, code, oauth2.VerifierOption(verifier))
|
|
if err != nil {
|
|
log.Fatalf("Could not exchange OAuth2 code: %v", err)
|
|
http.Error( w,
|
|
fmt.Sprintf("Could not exchange OAuth2 code: %v", err),
|
|
http.StatusBadRequest,
|
|
)
|
|
return
|
|
}
|
|
|
|
token = t
|
|
http.Error(
|
|
w,
|
|
"Authentication successful! You may now close this tab.",
|
|
http.StatusOK,
|
|
)
|
|
if f, ok := w.(http.Flusher); ok {
|
|
f.Flush()
|
|
}
|
|
|
|
wg.Done()
|
|
server.Close()
|
|
},
|
|
)
|
|
|
|
url := oauth2Config.AuthCodeURL(
|
|
"state",
|
|
oauth2.AccessTypeOffline,
|
|
oauth2.S256ChallengeOption(verifier),
|
|
)
|
|
fmt.Printf("\nSign in to YouTube: %s\n\n", url)
|
|
|
|
wg.Add(1)
|
|
if err := server.ListenAndServe(); err != http.ErrServerClosed {
|
|
return nil, fmt.Errorf("http: %v", err)
|
|
}
|
|
wg.Wait()
|
|
|
|
return token, nil
|
|
}
|