gistfile1.go

package job

import (
    "bufio"
    "fmt"
    "github.com/op/go-logging"
    "hash/fnv"
    "os"
    "time"
)

var log = logging.MustGetLogger("job")

type Job struct {

    PublisherUsername string

    Username string
    ProjectName string

    ArchiveType string
    ArchivePath string

    CompilationPath string

    TimeReceived time.Time
    TimeSubmitted time.Time
    TimeStarted time.Time
    TimeUnzipped time.Time
    TimeCompiled time.Time
    TimeDeployed time.Time
    TimeCompleted time.Time

}

func (j *Job) Id() string {
    return j.Username + "/" + j.ProjectName
}

func (j *Job) HashCode() uint32 {
    h := fnv.New32a()
    h.Write([]byte(j.Id()))
    return h.Sum32()
}

func (j *Job) String() string {
    return fmt.Sprintf(
        "<Job publisher=%s username=%s project=%s archiveType=%s archivePath=%s timeReceived=%s>",
        j.PublisherUsername,
        j.Username,
        j.ProjectName,
        j.ArchiveType,
        j.ArchivePath,
        j.TimeReceived)
}

func ReadJobFromDescriptor(path string) (*Job, error) {

    f, err := os.Open(path)
    if err != nil {
        return nil, err
    }

    defer f.Close()

    r := bufio.NewReader(f)

    var readError error = nil
    readLine := func() (string, error) {
        var str string = ""
        if readError == nil {
            if str, readError = r.ReadString('\n'); readError == nil {
                str = str[:len(str)-1]
            }   
        }
        return str, readError
    }

    publisherUsername, err  := readLine()
    username, err           := readLine()
    projectName, err        := readLine()
    archiveType, err        := readLine()
    archivePath, err        := readLine()
    timeReceived, err       := readLine()

    if err != nil {
        return nil, err
    }

    parsedTime, err := time.Parse(time.RFC3339Nano, timeReceived)
    if err != nil {
        return nil, err
    }

    return &Job{
        PublisherUsername: publisherUsername,
        Username: username,
        ProjectName: projectName,
        ArchiveType: archiveType,
        ArchivePath: archivePath,
        TimeReceived: parsedTime,
    }, nil

}

func (j *Job) Latency() time.Duration {
    return j.TimeCompleted.Sub(j.TimeSubmitted)
}

func (j *Job) StartDelay() time.Duration {
    return j.TimeStarted.Sub(j.TimeSubmitted)
}

func (j *Job) ProcessingTime() time.Duration {
    return j.TimeCompleted.Sub(j.TimeStarted)
}

func (j *Job) DescriptorPath() string {
    return j.ArchivePath + ".job"
}

func (j *Job) WriteDescriptor() error {

    dp := j.DescriptorPath()

    file, err := os.Create(dp)
    if err != nil {
        log.Error("couldn't create job descriptor %s: %s", dp, err.Error())
        return err
    }

    delete := false
    defer func() {
        file.Close()
        if delete {
            os.Remove(dp)
        }
    }()
    
    w := bufio.NewWriter(file)
    _, err = w.WriteString(
        j.PublisherUsername + "\n" +
        j.Username + "\n" +
        j.ProjectName + "\n" +
        j.ArchiveType + "\n" +
        j.ArchivePath + "\n" +
        j.TimeReceived.Format(time.RFC3339Nano) + "\n")

    if err != nil {
        log.Error("couldn't write job descriptor %s: %s", dp, err.Error())
        delete = true
        return err
    }

    if err = w.Flush(); err != nil {
        log.Error("couldn't flush job descriptor %s: %s", dp, err.Error())
        delete = true
        return err
    }

    log.Debug("job descriptor written: %s", dp)
    
    return nil

}

func (j *Job) CleanUp() {
    if err := os.Remove(j.ArchivePath); err != nil {
        log.Error("(cleanup) couldn't remove archive: %s", err.Error())
    }
    if err := os.Remove(j.DescriptorPath()); err != nil {
        log.Error("(cleanup) couldn't remove descriptor: %s", err.Error())
    }
}