magnetico-go-migrator/magnetico-migrator.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
}