golang解析磁力链为torrent相关的信息

其实通过http请求已经获得了种子的信息了，但是传播存储种子好像是违法的，所以就存储些描述信息吧。

之前 python 跑的太慢了。这个 go 并发不知道写的有没有问题？！

package main

import (
	"bufio"
	"bytes"
	"crypto/sha1"
	"database/sql"
	"fmt"
	_ "github.com/go-sql-driver/mysql"
	"io"
	"log"
	"net"
	"net/http"
	"os"
	"strconv"
	"strings"
	"time"
)

import bencode "code.google.com/p/bencode-go"

type FileDict struct {
	Length int64    "length"
	Path   []string "path"
	Md5sum string   "md5sum"
}

type InfoDict struct {
	FileDuration []int64 "file-duration"
	FileMedia    []int64 "file-media"

	// Single file
	Name   string "name"
	Length int64  "length"
	Md5sum string "md5sum"

	// Multiple files
	Files       []FileDict "files"
	PieceLength int64      "piece length"
	Pieces      string     "pieces"
	Private     int64      "private"
}

type MetaInfo struct {
	Info         InfoDict   "info"
	InfoHash     string     "info hash"
	Announce     string     "announce"
	AnnounceList [][]string "announce-list"
	CreationDate int64      "creation date"
	Comment      string     "comment"
	CreatedBy    string     "created by"
	Encoding     string     "encoding"
}

func (metaInfo *MetaInfo) ReadTorrentMetaInfoFile(r io.Reader) bool {

	fileMetaData, er := bencode.Decode(r)
	if er != nil {
		return false
	}

	metaInfoMap, ok := fileMetaData.(map[string]interface{})
	if !ok {
		return false
	}

	var bytesBuf bytes.Buffer
	for mapKey, mapVal := range metaInfoMap {
		switch mapKey {
		case "info":
			if er = bencode.Marshal(&bytesBuf, mapVal); er != nil {
				return false
			}

			infoHash := sha1.New()
			infoHash.Write(bytesBuf.Bytes())
			metaInfo.InfoHash = string(infoHash.Sum(nil))

			if er = bencode.Unmarshal(&bytesBuf, &metaInfo.Info); er != nil {
				return false
			}

		case "announce-list":
			if er = bencode.Marshal(&bytesBuf, mapVal); er != nil {
				return false
			}
			if er = bencode.Unmarshal(&bytesBuf, &metaInfo.AnnounceList); er != nil {
				return false
			}

		case "announce":
			if aa, ok := mapVal.(string); ok {
				metaInfo.Announce = aa
			}

		case "creation date":

			if tt, ok := mapVal.(int64); ok {
				metaInfo.CreatiOnDate= tt
			}

		case "comment":
			if cc, ok := mapVal.(string); ok {
				metaInfo.Comment = cc
			}

		case "created by":
			if cb, ok := mapVal.(string); ok {
				metaInfo.CreatedBy = cb
			}

		case "encoding":
			if ed, ok := mapVal.(string); ok {
				metaInfo.Encoding = ed
			}
		}
	}

	return true
}

func makeUrl(hashinfo string) string {
	url := "http://bt.box.n0808.com/%s/%s/%s.torrent"
	str := strings.ToUpper(hashinfo)
	return fmt.Sprintf(url, str[0:2], str[len(str)-2:], str)
}

func logFile(msg string) {
	f, err := os.OpenFile("logfile_torrent.txt", os.O_RDWR|os.O_CREATE|os.O_APPEND, 0666)
	if err != nil {
		return
	}
	defer f.Close()

	log.SetOutput(f)
	log.Println(msg)
}

var timeout = time.Duration(2 * time.Second)

func dialTimeout(network, addr string) (net.Conn, error) {
	return net.DialTimeout(network, addr, timeout)
}

func pullTorrent(url string) (int, error) {

	req, err := http.NewRequest("GET", url, nil)
	if err != nil {
		return 1, err
	}

	req.Header.Add("User-Agent", "Mozilla/5.0")
	req.Header.Add("Host", "bt.box.n0808.com")
	req.Header.Add("Accept", "*/*")
	req.Header.Add("Connection", "Keep-Alive")

	transport := http.Transport{
		Dial: dialTimeout,
	}

	client := &http.Client{
		Transport: &transport,
	}

	resp, err := client.Do(req)

	if err != nil {
		return 2, err
	}
	defer resp.Body.Close()

	var metaTorrent MetaInfo
	ok := metaTorrent.ReadTorrentMetaInfoFile(resp.Body)
	if !ok {
		return 3, nil
	}

	name := metaTorrent.Info.Name
	hashInfo := fmt.Sprintf("%X", metaTorrent.InfoHash)
	created := metaTorrent.CreationDate

	var fileLength int64
	var fileDownLoadList bytes.Buffer
	var fileList string

	for _, fileDict := range metaTorrent.Info.Files {
		fileLength += fileDict.Length
		for _, path := range fileDict.Path {
			fileDownLoadList.WriteString(path)
			fileDownLoadList.WriteString("\r\n")
		}
	}
	fileList = fileDownLoadList.String()

	var fileLengthTotal int64
	if fileLength > 0 {
		fileLengthTotal = fileLength / (1024 * 1024)
	}

	if fileLengthTotal > 0 {
		db, err := sql.Open("mysql", "root:admin@tcp(127.0.0.1:3306)/678BT?charset=utf8&timeout=3s")
		if err != nil {
			return 4, err
		}
		defer db.Close()

		stmtIns, err := db.Prepare("INSERT INTO magnet (hashinfo,name,files,length,created,indexd) VALUES(?,?,?,?,?,?)")
		if err != nil {
			return 5, err
		}
		defer stmtIns.Close()

		timestamp := time.Now().Unix()
		_, error := stmtIns.Exec(hashInfo, name, fileList, fileLengthTotal, created, timestamp)
		if error != nil {
			return 6, error
		}
	}

	return 0, nil
}

func popChan(chs []chan int) {
	for _, vv := range chs {
		tmp := <-vv
		fmt.Println(tmp)
	}
}

func main() {
	f, err := os.Open("torrent.txt")
	if err != nil {
		log.Fatal(err)
	}
	defer f.Close()

	bf := bufio.NewReader(f)

	no := 0
	ch := make([]chan int, 128)
	op := 0

	for {

		if no >= 128 {
			popChan(ch)
			no = 0
		}

		ch[no] = make(chan int)

		line, isPrefix, err := bf.ReadLine()
		if err == io.EOF {
			break
		}

		if err != nil {
			logFile(err.Error())
		}

		if isPrefix {
			logFile("LINE TOO LONG")
		}

		torrent := strings.Trim(string(line), "\r\n")
		torrent1 := strings.Trim(torrent, "\r")
		torrent2 := strings.Trim(torrent1, "\n")

		if len(torrent2) > 10 {

			go func(chx chan int, nox int) {

				ret, err := pullTorrent(makeUrl(torrent2))
				if ret != 0 {
					logFile(strconv.Itoa(ret))
					if err != nil {
						logFile(err.Error())
					}
				}

				chx <- nox

			}(ch[no], no)

			no++
		}

		op++

		if op%1000 == 0 {
			fmt.Println(no)
		}
	}
}