Use transaction for repositores + issues and PRs

Since the issues, PRs and the reposity are all commited at
the same time, we can remove the FindOne checks for issues
and because we already know the repository was not found

Signed-off-by: Carlos Martín <carlos.martin.sanchez@gmail.com>

Author: carlosms

shallow/issue.go

@@ -2,31 +2,28 @@ package shallow
 
 import (
 	"context"
-	"database/sql"
 	"fmt"
 
 	"github.com/src-d/ghsync/models"
 
 	"github.com/google/go-github/github"
-	"gopkg.in/src-d/go-kallax.v1"
 	"gopkg.in/src-d/go-log.v1"
 )
 
 type IssueSyncer struct {
-	db     *sql.DB
+	store  *models.IssueStore
 	client *github.Client
 }
 
-func NewIssueSyncer(db *sql.DB, c *github.Client) *IssueSyncer {
+func NewIssueSyncer(s *models.IssueStore, c *github.Client) *IssueSyncer {
 	return &IssueSyncer{
-		db:     db,
+		store:  s,
 		client: c,
 	}
 }
 
 func (s *IssueSyncer) Sync(owner, repo string, logger log.Logger) error {
-	store := models.NewIssueStore(s.db)
-	return store.Transaction(func(store *models.IssueStore) error {
+	return s.store.Transaction(func(store *models.IssueStore) error {
 		return s.doIssues(store, owner, repo, logger)
 	})
 }
@@ -52,24 +49,6 @@ func (s *IssueSyncer) doIssues(store *models.IssueStore, owner, repo string, log
 
 			logger := logger.With(log.Fields{"issue": i.GetNumber()})
 
-			_, err := store.FindOne(models.NewIssueQuery().
-				Where(kallax.And(
-					kallax.Eq(models.Schema.Issue.RepositoryOwner, owner),
-					kallax.Eq(models.Schema.Issue.RepositoryName, repo),
-					kallax.Eq(models.Schema.Issue.Number, i.GetNumber()),
-				)),
-			)
-
-			if err != nil && err != kallax.ErrNotFound {
-				logger.Errorf(err, "failed to read the resource from the DB")
-				return fmt.Errorf("failed to read the resource from the DB: %v", err)
-			}
-
-			if err == nil {
-				logger.Infof("resource already exists, skipping")
-				continue
-			}
-
 			record := models.NewIssue()
 			record.Issue = *i
 

shallow/pull_request.go

@@ -2,31 +2,28 @@ package shallow
 
 import (
 	"context"
-	"database/sql"
 	"fmt"
 
 	"github.com/src-d/ghsync/models"
 
 	"github.com/google/go-github/github"
-	"gopkg.in/src-d/go-kallax.v1"
 	"gopkg.in/src-d/go-log.v1"
 )
 
 type PullRequestSyncer struct {
-	db     *sql.DB
+	store  *models.PullRequestStore
 	client *github.Client
 }
 
-func NewPullRequestSyncer(db *sql.DB, c *github.Client) *PullRequestSyncer {
+func NewPullRequestSyncer(s *models.PullRequestStore, c *github.Client) *PullRequestSyncer {
 	return &PullRequestSyncer{
-		db:     db,
+		store:  s,
 		client: c,
 	}
 }
 
 func (s *PullRequestSyncer) Sync(owner, repo string, logger log.Logger) error {
-	store := models.NewPullRequestStore(s.db)
-	return store.Transaction(func(store *models.PullRequestStore) error {
+	return s.store.Transaction(func(store *models.PullRequestStore) error {
 		return s.doPRs(store, owner, repo, logger)
 	})
 }
@@ -48,24 +45,6 @@ func (s *PullRequestSyncer) doPRs(store *models.PullRequestStore, owner, repo st
 		for _, pr := range prs {
 			logger := logger.With(log.Fields{"pr": pr.GetNumber()})
 
-			_, err := store.FindOne(models.NewPullRequestQuery().
-				Where(kallax.And(
-					kallax.Eq(models.Schema.Issue.RepositoryOwner, owner),
-					kallax.Eq(models.Schema.Issue.RepositoryName, repo),
-					kallax.Eq(models.Schema.Issue.Number, pr.GetNumber()),
-				)),
-			)
-
-			if err != nil && err != kallax.ErrNotFound {
-				logger.Errorf(err, "failed to read the resource from the DB")
-				return fmt.Errorf("failed to read the resource from the DB: %v", err)
-			}
-
-			if err == nil {
-				logger.Infof("resource already exists, skipping")
-				continue
-			}
-
 			record := models.NewPullRequest()
 			record.PullRequest = *pr
 

shallow/repository.go

@@ -82,28 +82,36 @@ func (s *RepositorySyncer) doRepo(repository *github.Repository, parentLogger lo
 		return nil
 	}
 
-	issueSyncer := NewIssueSyncer(s.db, s.client)
-	err = issueSyncer.Sync(repository.GetOwner().GetLogin(), repository.GetName(), logger)
-	if err != nil {
-		return err
-	}
+	return s.store.Transaction(func(store *models.RepositoryStore) error {
+		var issueStore models.IssueStore
+		kallax.StoreFrom(&issueStore, store)
 
-	prSyncer := NewPullRequestSyncer(s.db, s.client)
-	err = prSyncer.Sync(repository.GetOwner().GetLogin(), repository.GetName(), logger)
-	if err != nil {
-		return err
-	}
+		issueSyncer := NewIssueSyncer(&issueStore, s.client)
+		err = issueSyncer.Sync(repository.GetOwner().GetLogin(), repository.GetName(), logger)
+		if err != nil {
+			return err
+		}
 
-	record := models.NewRepository()
-	record.Repository = *repository
+		var prStore models.PullRequestStore
+		kallax.StoreFrom(&prStore, store)
 
-	err = s.store.Insert(record)
-	if err != nil {
-		logger.Errorf(err, "failed to write the resource into the DB")
-		return fmt.Errorf("failed to write the resource into the DB: %v", err)
-	}
+		prSyncer := NewPullRequestSyncer(&prStore, s.client)
+		err = prSyncer.Sync(repository.GetOwner().GetLogin(), repository.GetName(), logger)
+		if err != nil {
+			return err
+		}
 
-	logger.Debugf("resource written in the DB")
+		record := models.NewRepository()
+		record.Repository = *repository
 
-	return nil
+		err = s.store.Insert(record)
+		if err != nil {
+			logger.Errorf(err, "failed to write the resource into the DB")
+			return fmt.Errorf("failed to write the resource into the DB: %v", err)
+		}
+
+		logger.Debugf("resource written in the DB")
+
+		return nil
+	})
 }