codeclimate/test-reporter

package upload

import (
    "bytes"
    "crypto/tls"
    "crypto/x509"
    "encoding/json"
    "fmt"
    "io"
    "io/ioutil"
    "log"
    "net/http"
    "net/url"
    "os"
    "strings"
    "time"

    "github.com/Sirupsen/logrus"
    "github.com/codeclimate/test-reporter/formatters"
    "github.com/codeclimate/test-reporter/version"
    "github.com/pkg/errors"
)

type Uploader struct {
    ReporterID  string
    EndpointURL string
    BatchSize   int
    Input       io.Reader
    Insecure    bool
}

type ErrConflict struct {
    message string
}

func (e *ErrConflict) Error() string {
    return e.message
}

func (u Uploader) Upload() error {
    if u.ReporterID == "" {
        return errors.New("you must supply a CC_TEST_REPORTER_ID ENV variable or pass it via the -r flag")
    }

    rep := formatters.Report{
        SourceFiles: formatters.SourceFiles{},
    }

    err := json.NewDecoder(u.Input).Decode(&rep)
    if err != nil {
        return errors.WithStack(err)
    }

    testReport := NewTestReport(rep)

    pr, pw := io.Pipe()
    go func() {
        defer pw.Close()
        bb := &bytes.Buffer{}
        w := io.MultiWriter(pw, bb)
        err := json.NewEncoder(w).Encode(JSONWraper{Data: testReport})
        if err != nil {
            logrus.Error(err)
            return
        }
        logrus.Debug(bb.String())
    }()

    res, err := u.doRequest(pr, u.EndpointURL)
    if err != nil {
        switch err.(type) {
        case *ErrConflict:
            logrus.Warnf("%s, skipping upload", err.Error())
            return nil
        default:
            return errors.WithStack(err)
        }
    }

    batchLinks := struct {
        Links struct {
            PostBatch string `json:"post_batch"`
        } `json:"links"`
    }{}

    err = json.NewDecoder(res.Body).Decode(&batchLinks)
    if err != nil {
        return errors.WithStack(err)
    }

    postBatchURL, err := u.TransformPostBatchURL(batchLinks.Links.PostBatch)
    if err != nil {
        return errors.WithStack(err)
    }

    return u.SendBatches(testReport, postBatchURL)
}

func (u Uploader) TransformPostBatchURL(rawURL string) (string, error) {
    parsed, err := url.Parse(rawURL)
    if err != nil {
        return "", err
    }

    if u.Insecure {
        parsed.Scheme = "http"
    } else {
        parsed.Scheme = "https"
    }

    return parsed.String(), nil
}

func (u Uploader) SendBatches(rep *TestReport, url string) error {
    batch := [][]SourceFile{}

    pos := 0
    count := len(rep.SourceFiles) / u.BatchSize
    remainder := len(rep.SourceFiles) % u.BatchSize
    for i := 0; i < count; i++ {
        end := pos + u.BatchSize
        batch = append(batch, rep.SourceFiles[pos:end])
        pos = end
    }
    if remainder > 0 {
        batch = append(batch, rep.SourceFiles[pos:])
    }

    for i, b := range batch {
        pr, pw := io.Pipe()
        go func() {
            defer pw.Close()
            bb := &bytes.Buffer{}
            w := io.MultiWriter(pw, bb)
            err := json.NewEncoder(w).Encode(JSONWraper{
                Data: b,
                Meta: map[string]int{
                    "current": i + 1,
                    "total":   len(batch),
                },
            })
            if err != nil {
                logrus.Error(err)
                return
            }
            logrus.Debug(bb.String())
        }()
        _, err := u.doRequest(pr, url)
        if err != nil {
            return errors.WithStack(err)
        }
    }
    fmt.Println("Test report uploaded successfully to Code Climate")
    return nil
}

func (u Uploader) doRequest(in io.Reader, url string) (*http.Response, error) {
    c := http.Client{
        Transport: u.newTransport(),
        Timeout:   30 * time.Second,
    }

    req, err := u.newRequest(in, url)
    if err != nil {
        return nil, errors.WithStack(err)
    }

    logrus.Debugf("posting request to %s", url)
    res, err := c.Do(req)
    if err != nil {
        return res, errors.WithStack(err)
    }

    if res.StatusCode < 200 || res.StatusCode >= 300 {
        httpBody, err := ioutil.ReadAll(res.Body)
        if err != nil {
            return nil, errors.WithStack(err)
        }

        logrus.Debug(string(httpBody))
        errorMessage, err := getErrorMessage(httpBody)
        if err != nil {
            return nil, errors.WithStack(err)
        }

        if res.StatusCode == 409 {
            return nil, &ErrConflict{
                message: fmt.Sprintf("Conflict when uploading: %s", errorMessage),
            }
        }

        return res, fmt.Errorf("response from %s.\nHTTP %d: %s", url, res.StatusCode, errorMessage)
    }
    return res, nil
}

func (u Uploader) newTransport() (tr http.RoundTripper) {
    sslCertFile := os.Getenv("SSL_CERT_FILE")
    if sslCertFile == "" {
        return tr
    }

    caCert, err := ioutil.ReadFile(sslCertFile)
    if err != nil {
        log.Fatal(err)
    }
    caCertPool := x509.NewCertPool()
    caCertPool.AppendCertsFromPEM(caCert)
    return &http.Transport{
        TLSClientConfig: &tls.Config{
            RootCAs: caCertPool,
        },
    }
}

func (u Uploader) newRequest(in io.Reader, url string) (*http.Request, error) {
    req, err := http.NewRequest("POST", url, in)
    if err != nil {
        return nil, errors.WithStack(err)
    }
    req.Header.Set("User-Agent", fmt.Sprintf("TestReporter/%s (Code Climate, Inc.)", version.Version))
    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("X-CC-Test-Reporter-Id", u.ReporterID)
    req.Header.Set("Accept", "application/vnd.api+json")
    return req, err
}

type apiError struct {
    Detail string `json:"detail"`
}

type errorsResponse struct {
    Errors []apiError `json:"errors"`
}

func getErrorMessage(body []byte) (string, error) {
    var response = new(errorsResponse)
    err := json.Unmarshal(body, &response)
    if err != nil {
        return "", errors.WithStack(err)
    }

    var details []string

    for i := range response.Errors {
        details = append(details, response.Errors[i].Detail)
    }

    return strings.Join(details, ", "), err
}