116 lines
2.9 KiB
Go
116 lines
2.9 KiB
Go
package main
|
|
|
|
import (
|
|
"database/sql"
|
|
"encoding/hex"
|
|
"gitlab.com/skobkin/magnetico-go-migrator/old"
|
|
|
|
"github.com/cheggaaa/pb/v3"
|
|
_ "github.com/mattn/go-sqlite3"
|
|
"github.com/skobkin/magnetico/pkg/persistence"
|
|
"go.uber.org/zap"
|
|
"gopkg.in/alecthomas/kingpin.v2"
|
|
"net/url"
|
|
"time"
|
|
)
|
|
|
|
var (
|
|
goDatabaseUrl = kingpin.Flag("go-database", "magneticod Go version database URL.").Short('g').String()
|
|
pyDatabaseUrl = kingpin.Flag("py-database", "Python version database URL.").Short('p').Required().String()
|
|
|
|
progress pb.ProgressBar
|
|
)
|
|
|
|
func main() {
|
|
logger, _ := zap.NewDevelopment()
|
|
defer logger.Sync()
|
|
zap.ReplaceGlobals(logger)
|
|
|
|
kingpin.Parse()
|
|
|
|
goDatabase, err := persistence.MakeDatabase(*goDatabaseUrl, logger)
|
|
if err != nil {
|
|
logger.Panic("Could not open Go database.", zap.String("url", *goDatabaseUrl), zap.Error(err))
|
|
}
|
|
defer goDatabase.Close()
|
|
|
|
oldSqliteUrl, err := url.Parse(*pyDatabaseUrl)
|
|
if err != nil {
|
|
logger.Panic("Can't parse Python database URL.", zap.String("url", *pyDatabaseUrl), zap.Error(err))
|
|
}
|
|
|
|
pyDatabase, err := old.OpenSqliteDb(*oldSqliteUrl)
|
|
if err != nil {
|
|
logger.Panic("Couldn't open Python database.", zap.String("url", *pyDatabaseUrl), zap.Error(err))
|
|
}
|
|
defer pyDatabase.Close()
|
|
|
|
torrentsTotal, err := old.GetNumberOfTorrents(*pyDatabase)
|
|
if err != nil {
|
|
zap.L().Panic("Couldn't count torrents", zap.Error(err))
|
|
}
|
|
|
|
progress = *pb.Full.New(int(torrentsTotal))
|
|
progress.SetRefreshRate(time.Second)
|
|
progress.Start()
|
|
|
|
err = mergeDatabases(*pyDatabase, goDatabase)
|
|
if err != nil {
|
|
logger.Error("Error while processing data", zap.Error(err))
|
|
}
|
|
|
|
progress.Finish()
|
|
}
|
|
|
|
func mergeDatabases(pyDb sql.DB, goDb persistence.Database) error {
|
|
// Selecting torrents
|
|
tRows, err := pyDb.Query("SELECT id, info_hash, name, total_size, discovered_on FROM torrents ORDER BY id ASC;")
|
|
if err != nil {
|
|
zap.L().Fatal("Error when querying torrents from old database.")
|
|
}
|
|
defer tRows.Close()
|
|
|
|
for tRows.Next() {
|
|
var torrent persistence.TorrentMetadata
|
|
|
|
progress.Increment()
|
|
|
|
err := tRows.Scan(&torrent.ID, &torrent.InfoHash, &torrent.Name, &torrent.Size, &torrent.DiscoveredOn)
|
|
if err != nil {
|
|
zap.L().Error("Error scanning torrent row.", zap.Error(err))
|
|
|
|
continue
|
|
}
|
|
|
|
files, err := old.GetFilesForTorrent(pyDb, torrent)
|
|
if err != nil {
|
|
zap.L().Error("Error getting files for torrent.", zap.String("hash", hex.EncodeToString(torrent.InfoHash)), zap.Error(err))
|
|
|
|
continue
|
|
}
|
|
|
|
err = importTorrent(goDb, torrent, files)
|
|
if err != nil {
|
|
zap.L().Error("Error when importing torrent to Go database.", zap.String("hash", hex.EncodeToString(torrent.InfoHash)), zap.Error(err))
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func importTorrent(goDb persistence.Database, torrent persistence.TorrentMetadata, files []persistence.File) error {
|
|
exists, err := goDb.DoesTorrentExist(torrent.InfoHash)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if !exists {
|
|
err = goDb.AddNewTorrent(torrent.InfoHash, torrent.Name, files)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|