adept/transcoder/repository.go

package transcoder

import (
  "io"
  "log"
  "path/filepath"
  "os"
)

type Repository struct {
  basePath    string
  ingestPath  string
  archivePath string
  outputPath  string
}

// Repository struct constructor
func NewRepository(path string) *Repository {
  r := new(Repository)
  r.basePath = path
  r.ingestPath = filepath.Join(path, "ingest")
  r.archivePath = filepath.Join(path, "archive")
  r.outputPath = filepath.Join(path, "output")

  return r
}

// Repository getters
func (r *Repository) GetIngestPath() string {
  return r.ingestPath
}
func (r *Repository) GetOutputPath() string {
  return r.outputPath
}

// Initializes the video repository by ensuring the directories are available
func (r *Repository) Setup() {
  // make sure repository base directory exists
  create_repo_dir(r.basePath)
  // make sure the folder structure is setup
  create_repo_dir(r.ingestPath)
  create_repo_dir(r.archivePath)
  create_repo_dir(r.archivePath)
}

func (r *Repository) SearchIngest() []os.FileInfo {
  log.Printf("Searching ingest directory for files to transcode...")

  ingestDir, err := os.Open(r.ingestPath)
  if err != nil {
    log.Fatalf("Error opening ingest directory: %s", err)
    os.Exit(1)
  }
  files, err := ingestDir.Readdir(0)
  if err != nil {
    log.Fatalf("Error searching for files in ingest: %s", err)
    os.Exit(1)
  }

  return files
}

func (r *Repository) ArchiveFile(inFile string) {
  // create ingest and archive paths
  ingestFilePath := filepath.Join(r.ingestPath, inFile)
  archiveFilePath := filepath.Join(r.archivePath, inFile)

  log.Printf("Copying %s to the archive.", ingestFilePath)

  // open ingest file
  source, err := os.Open(ingestFilePath)
  if err != nil {
    log.Fatalf("Error opening file in ingest: %s.", err)
    os.Exit(1)
  }
  sourceStat, _ := source.Stat()
  sourceMode := sourceStat.Mode()
  defer source.Close()

  // attempt to create destination file
  destination, err := os.Create(archiveFilePath)
  if err != nil {
    log.Fatalf("Error opening archive file: %s.", err)
    os.Exit(1)
  }
  defer destination.Close()
  destination.Chmod(sourceMode)

  // perform the file copy
  _, err = io.Copy(destination, source)
  if err != nil {
    log.Fatalf("Error while archiving file from ingest: %s.", err)
    os.Exit(1)
  }
}

func (r *Repository) CleanupFile(inFile string) {
  // create ingest path
  ingestFilePath := filepath.Join(r.ingestPath, inFile)

  // remove the file
  os.Remove(ingestFilePath)
}

func create_repo_dir(path string) {
  _, err := os.Stat(path)
  if os.IsNotExist(err) {
    log.Printf("Creating directory %s.\n", path)
    os.Mkdir(path, 0755)
  } else {
    log.Printf("Directory %s already exists.\n", path)
  }
}