tiny png

package main

import (
    "encoding/base64"
    "fmt"
    "os"
    "net/http"
    "io/ioutil"
    "strings"
    "path/filepath"
    "encoding/json"
    "errors"
    "bytes"
    "time"
    "sync"
)

var sum_file_count int = 0
var handle_file_count int = 0
var wg sync.WaitGroup


func main() {
    keys := [] string{"1343vE6yKv5mlsx6anJ","REjZlZbNJdfdfQjRvE6yKv5mlsx6anJ"}
    url := "https://api.tinify.com/shrink"

    dirPath := "images"
    files, err := WalkDir(dirPath, ".png")
    if err != nil {
        fmt.Println("请检查目录是否存在~~")
        return
    }

    sum_file_count = len(files)
    if sum_file_count == 0 {
        fmt.Println("没有 *.png 图片需要处理~~")
        return
    }

    fmt.Printf("有 %d 张图片需要处理，请稍候~~\n",sum_file_count)

    startTime := time.Now()
    for i:=0;i<sum_file_count;i++ {
        wg.Add(1)
        shrink(url,keys,files[i])
    }
    wg.Wait()
    fmt.Printf("任务总耗时： %s\n",time.Since(startTime))
}

//上传图片，阻塞等待服务器压缩，服务器压缩成功返回结果后，去下载图片覆盖原图片
func shrink(url string, keys []string, filePath string) error {
    defer wg.Done()
    file_bytes, err := ioutil.ReadFile(filePath)
    if err != nil {
        error_msg := fmt.Sprintf("读取本地文件错误，文件路径错误! (path: %s\terror: %s)", filePath, err.Error())
        fmt.Println(error_msg)
        return err
    }

    down_url := ""
    for i:=0;i<len(keys);i++ {
        req, err := http.NewRequest("POST", url, bytes.NewReader(file_bytes))
        if err != nil {
            error_msg := fmt.Sprintf("请求 Tiny 出现网络错误! (error: %s)\n",err.Error())
            fmt.Println(error_msg)
            return errors.New(error_msg)
        }
        credentials := base64.StdEncoding.EncodeToString([]byte("api:" + keys[i]))
        req.Header.Set("Authorization", "Basic "+credentials)
        //处理返回结果
        res, err := http.DefaultClient.Do(req)
        if err != nil {
            error_msg := fmt.Sprintf("请求 Tiny 出现网络错误! (error: %s)\n",err.Error())
            fmt.Println(error_msg)
            return errors.New(error_msg)
        }
        status := res.StatusCode
        body, err := ioutil.ReadAll(res.Body)
        if err != nil {
            error_msg := fmt.Sprintf("请求 Tiny 出现网络错误! (error: %s)\n",err.Error())
            fmt.Println(error_msg)
            return errors.New(error_msg)
        }

        //判断HTTP状态码，如果是 415表示文件类型不正确；401表示证书不正确；400表示输入文件为空；5xx表示服务器异常；2xx表示成功
        if status == 401 {
            //KEY不正确，使用下一个KEY
            fmt.Println("Next Key")
            time.Sleep(time.Millisecond * 50)
            continue
        } else if status < 300 && status >= 200 {
            //正确
            right_data := new(RightData)
            json.Unmarshal(body, right_data)
            down_url = right_data.Output.Url
            break
        } else {
            //其它错误
            error_msg := fmt.Sprintf("Tiny状态码: %d\tTiny错误信息: %s\n",res.StatusCode,string(body))
            fmt.Println(error_msg)
            return errors.New(error_msg)
        }
    }
    //CompressionCount := res.Header.Get("Compression-Count")
    //fmt.Printf("Key(%s) UseCount: %s\n",key,CompressionCount)

    if down_url == "" {
        error_msg := "可能所有 KEY 都已经不可用。"
        fmt.Println(error_msg)
        return errors.New(error_msg)
    }

    //覆盖原文件
    down_bytes := []byte{}
    for i:= 0;i < 10;i++ {
        if i>0 {
            fmt.Printf("下载图片 %s 出错，正在进行第 %d 次尝试...\n",down_url,i+1)
            time.Sleep(time.Millisecond*50)
        }
        res_down, err := http.Get(down_url)
        if err != nil {
            continue
        }
        down_bytes, err = ioutil.ReadAll(res_down.Body)
        if err != nil {
            continue
        }
        break
    }
    if len(down_bytes) == 0 {
        error_msg := fmt.Sprintf("下载图片出错!(filePath: %s\turl: %s\terror: %s)\n", filePath,down_url,err.Error())
        fmt.Printf(error_msg)
        return errors.New(error_msg)
    }

    file, err := os.OpenFile(filePath,os.O_RDWR | os.O_TRUNC, 0600)
    defer file.Close()
    if err != nil {
        error_msg := fmt.Sprintf("清空原图片出错!(filePath: %s\turl: %s\terror: %s)\n", filePath,down_url,err.Error())
        fmt.Printf(error_msg)
        return errors.New(error_msg)
    }
    _, err = file.Write(down_bytes)
    if err != nil {
        error_msg := fmt.Sprintf("覆写原图片出错!(filePath: %s\turl: %s\terror: %s)\n", filePath,down_url,err.Error())
        fmt.Printf(error_msg)
        return errors.New(error_msg)
    }

    handle_file_count += 1
    fmt.Printf("任务进度[%d/%d]\n",handle_file_count,sum_file_count)
    return nil
}

//获取指定目录下的所有文件，不进入下一级目录搜索，可以匹配后缀过滤。
func ListDir(dirPth string, suffix string) (files []string, err error) {
    files = make([]string, 0, 10)
    dir, err := ioutil.ReadDir(dirPth)
    if err != nil {
        return nil, err
    }
    PthSep := string(os.PathSeparator)
    suffix = strings.ToUpper(suffix) //忽略后缀匹配的大小写
    for _, fi := range dir {
        if fi.IsDir() { // 忽略目录
            continue
        }
        if strings.HasSuffix(strings.ToUpper(fi.Name()), suffix) { //匹配文件
            files = append(files, dirPth+PthSep+fi.Name())
        }
    }
    return files, nil
}

//获取指定目录及所有子目录下的所有文件，可以匹配后缀过滤。
func WalkDir(dirPth, suffix string) (files []string, err error) {
    files = make([]string, 0, 30)
    suffix = strings.ToUpper(suffix) //忽略后缀匹配的大小写
    err = filepath.Walk(dirPth, func(filename string, fi os.FileInfo, err error) error { //遍历目录
        //if err != nil { //忽略错误
        // return err
        //}
        if fi.IsDir() { // 忽略目录
            return nil
        }
        if strings.HasSuffix(strings.ToUpper(fi.Name()), suffix) {
            files = append(files, filename)
        }
        return nil
    })
    return files, err
}

type RightData struct {
    Input struct {
        Size int     `json:"size"`
        Type string     `json:"type"`
    } `json:"input"`
    Output struct {
        Size int    `json:"size"`
        Type string    `json:"type"`
        Width int    `json:"width"`
        Height int    `json:"height"`
        Ratio float32    `json:"ratio"`
        Url string    `json:"url"`
    }
}