Add validation of git connection

Adds a validation of the connection to the corresponding git provider
before starting with a "commit" or "finalize" (as the proposer), in
order to prevent failures during these processes.

Closes #2

Author: marvinkruse

demo/demo.go

@@ -108,7 +108,7 @@ func _executeVote(_proposalID string, _choice string, _salt string, _demoVoter i
 	}
 
 	if proposal.Proposer == myAddress {
-		return errors.New("You can't vote on your own proposal")
+		return errors.New("The demo voter can't vote on his own proposal")
 	}
 
 	// Retrieving the default stake from the ditContract
@@ -157,7 +157,7 @@ func _executeVote(_proposalID string, _choice string, _salt string, _demoVoter i
 
 	// If this is the case, the user can not vote again
 	if oldDidCommit {
-		return errors.New("You already voted on this proposal")
+		return errors.New("The demo voter already voted on this proposal")
 	}
 
 	var auth *bind.TransactOpts
@@ -174,7 +174,7 @@ func _executeVote(_proposalID string, _choice string, _salt string, _demoVoter i
 	_, err = ditCoordingatorInstance.VoteOnProposal(auth, repoHash, big.NewInt(int64(proposalID)), voteHash)
 	if err != nil {
 		if strings.Contains(err.Error(), "insufficient funds") {
-			return errors.New("Your account doesn't have enough ETH to pay for the transaction")
+			return errors.New("The demo voters account doesn't have enough ETH to pay for the transaction")
 		}
 		return errors.New("Failed to commit the vote: " + err.Error())
 	}
@@ -276,7 +276,7 @@ func Open(_proposalID string, _demoVoter int) error {
 
 	// If this is not the case the user never participated in this proposal through a vote
 	if !didCommit {
-		return errors.New("You didn't vote on this proposal")
+		return errors.New("The demo voter didn't vote on this proposal")
 	}
 
 	// Verifying whether the user has revealed his vote on this proposal
@@ -287,7 +287,7 @@ func Open(_proposalID string, _demoVoter int) error {
 
 	// If this is the case, the user already revealed his vote
 	if oldDidReveal {
-		return errors.New("You already opened your vote on this proposal")
+		return errors.New("The demo voter already opened the vote on this proposal")
 	}
 
 	// Crerating the transaction (basic values)
@@ -304,7 +304,7 @@ func Open(_proposalID string, _demoVoter int) error {
 	_, err = ditCoordinatorInstance.OpenVoteOnProposal(auth, repoHash, big.NewInt(int64(proposalID)), choice, salt)
 	if err != nil {
 		if strings.Contains(err.Error(), "insufficient funds") {
-			return errors.New("Your account doesn't have enough ETH to pay for the transaction")
+			return errors.New("The demo voters account doesn't have enough ETH to pay for the transaction")
 		}
 		return errors.New("Failed to open the vote: " + err.Error())
 	}
@@ -405,7 +405,7 @@ func Finalize(_proposalID string, _demoVoter int) (bool, error) {
 
 	// If not, we are not allowed to call this function (it would fail)
 	if !didCommit && myAddress != proposal.Proposer {
-		return false, errors.New("You didn't participate in this vote")
+		return false, errors.New("The demo voter didn't participate in this vote")
 	}
 
 	// Crerating the transaction (basic values)
@@ -418,7 +418,7 @@ func Finalize(_proposalID string, _demoVoter int) (bool, error) {
 	_, err = ditCoordinatorInstance.FinalizeVote(auth, repoHash, big.NewInt(int64(proposalID)))
 	if err != nil {
 		if strings.Contains(err.Error(), "insufficient funds") {
-			return false, errors.New("Your account doesn't have enough ETH to pay for the transaction")
+			return false, errors.New("The demo voters account doesn't have enough ETH to pay for the transaction")
 		}
 		return false, errors.New("Failed to finalize the vote: " + err.Error())
 	}

ethereum/ethereum.go

@@ -264,7 +264,7 @@ func ProposeCommit(_commitMessage string) (string, int, error) {
 	}
 
 	// Proposing the commit
-	transaction, err := ditCoordinatorInstance.ProposeCommit(auth, repoHash, big.NewInt(int64(answerKnowledgeLabel-1)), big.NewInt(int64(120)), big.NewInt(int64(120)))
+	transaction, err := ditCoordinatorInstance.ProposeCommit(auth, repoHash, big.NewInt(int64(answerKnowledgeLabel-1)), big.NewInt(int64(180)), big.NewInt(int64(180)))
 	if err != nil {
 		if strings.Contains(err.Error(), "insufficient funds") {
 			return "", 0, errors.New("Your account doesn't have enough ETH to pay for the transaction")
@@ -667,21 +667,21 @@ func Open(_proposalID string) error {
 // including the ETH and KNW reward in case of a voting for the winning decision
 // or the losing of ETH and KNW in case of a voting for the losing decision
 // The first caller who executes this will also trigger the calculation whether the vote passed or not
-func Finalize(_proposalID string) (bool, error) {
+func Finalize(_proposalID string) (bool, bool, error) {
 	// Converting the stdin string input of the user into an int
 	proposalID, _ := strconv.Atoi(_proposalID)
 
 	// Searching for this repositories object in the config
 	repoIndex, err := searchForRepoInConfig()
 	if err != nil {
-		return false, err
+		return false, false, err
 	}
 
 	repoHash := GetHashOfString(config.DitConfig.Repositories[repoIndex].Name)
 
 	connection, err := getConnection()
 	if err != nil {
-		return false, err
+		return false, false, err
 	}
 
 	// Convertig the hex-string-formatted address into an address object
@@ -690,19 +690,19 @@ func Finalize(_proposalID string) (bool, error) {
 	// Create a new instance of the ditContract to access it
 	ditCooordinatorInstance, err := getDitCoordinatorInstance(connection)
 	if err != nil {
-		return false, err
+		return false, false, err
 	}
 
 	// Create a new instance of the KNWToken contract to access it
 	KNWTokenInstance, err := getKNWTokenInstance(connection)
 	if err != nil {
-		return false, err
+		return false, false, err
 	}
 
 	// Create a new instance of the KNWVoting contract to access it
 	KNWVotingInstance, err := getKNWVotingInstance(connection)
 	if err != nil {
-		return false, err
+		return false, false, err
 	}
 
 	// Searching for the corresponding vote in the votes stored in the config
@@ -716,62 +716,65 @@ func Finalize(_proposalID string) (bool, error) {
 
 	// If this user already called the Resolve function for this vote it's not possible anymore
 	if config.DitConfig.Repositories[repoIndex].ActiveVotes[voteIndex].Resolved {
-		return false, errors.New("You already finalized this vote")
+		return false, false, errors.New("You already finalized this vote")
 	}
 
 	// Verifying whether the vote has already ended
 	pollEnded, err := KNWVotingInstance.PollEnded(nil, big.NewInt(int64(config.DitConfig.Repositories[repoIndex].ActiveVotes[voteIndex].KNWVoteID)))
 	if err != nil {
-		return false, errors.New("Failed to retrieve vote status")
+		return false, false, errors.New("Failed to retrieve vote status")
 	}
 
 	// If not, we can't resolve it
 	if !pollEnded {
-		return false, errors.New("The vote hasn't ended yet")
+		return false, false, errors.New("The vote hasn't ended yet")
 	}
 
 	// Verifying whether the user is a participant of this vote
 	didCommit, err := KNWVotingInstance.DidCommit(nil, myAddress, big.NewInt(int64(config.DitConfig.Repositories[repoIndex].ActiveVotes[voteIndex].KNWVoteID)))
 	if err != nil {
-		return false, errors.New("Failed to retrieve commit status")
+		return false, false, errors.New("Failed to retrieve commit status")
 	}
 
 	// Retrieve the selected proposal obkect
 	proposal, err := ditCooordinatorInstance.ProposalsOfRepository(nil, repoHash, big.NewInt(int64(proposalID)))
 	if err != nil {
-		return false, errors.New("Failed to retrieve the new proposal")
+		return false, false, errors.New("Failed to retrieve the new proposal")
 	}
 
+	// Indicates whether the called was the proposer or not
+	isProposer := (proposal.Proposer == myAddress)
+
 	// If not, we are not allowed to call this function (it would fail)
 	if !didCommit && myAddress != proposal.Proposer {
-		return false, errors.New("You didn't participate in this vote")
+		return false, false, errors.New("You didn't participate in this vote")
 	}
 
 	// Saving the old ETH balance
 	oldEthBalance, err := connection.BalanceAt(context.Background(), myAddress, nil)
 	if err != nil {
-		return false, errors.New("Failed to retrieve ETH balance")
+		return false, false, errors.New("Failed to retrieve ETH balance")
 	}
 
 	// Saving the old KNW balance
 	oldKNWBalance, err := KNWTokenInstance.BalanceOfLabel(nil, myAddress, config.DitConfig.Repositories[repoIndex].ActiveVotes[voteIndex].KnowledgeLabel)
 	if err != nil {
-		return false, errors.New("Failed to retrieve KNW balance")
+		return false, false, errors.New("Failed to retrieve KNW balance")
 	}
 
 	// Crerating the transaction (basic values)
 	auth, err := populateTx(connection)
 	if err != nil {
-		return false, err
+		return false, false, err
 	}
 
 	// Resolving the vote
 	transaction, err := ditCooordinatorInstance.FinalizeVote(auth, repoHash, big.NewInt(int64(proposalID)))
 	if err != nil {
 		if strings.Contains(err.Error(), "insufficient funds") {
-			return false, errors.New("Your account doesn't have enough ETH to pay for the transaction")
+			return false, false, errors.New("Your account doesn't have enough ETH to pay for the transaction")
 		}
-		return false, errors.New("Failed to finalize the vote: " + err.Error())
+		return false, false, errors.New("Failed to finalize the vote: " + err.Error())
 	}
 
 	// Waiting for the resolve transaction to be mined
@@ -785,7 +788,7 @@ func Finalize(_proposalID string) (bool, error) {
 		// Checking the balance of the user every 5 seconds, if it changed, a transaction was executed
 		newEthBalance, err = connection.BalanceAt(context.Background(), myAddress, nil)
 		if err != nil {
-			return false, errors.New("Failed to retrieve opening status")
+			return false, false, errors.New("Failed to retrieve opening status")
 		}
 		// If we are waiting for more than 2 minutes, the transaction might have failed
 		if waitingFor > 180 {
@@ -800,13 +803,13 @@ func Finalize(_proposalID string) (bool, error) {
 	// Saving the new KNW balance after resolving the vote
 	newKNWBalance, err := KNWTokenInstance.BalanceOfLabel(nil, myAddress, config.DitConfig.Repositories[repoIndex].ActiveVotes[voteIndex].KnowledgeLabel)
 	if err != nil {
-		return false, errors.New("Failed to retrieve KNW balance")
+		return false, false, errors.New("Failed to retrieve KNW balance")
 	}
 
 	// Retrieving the outcome of the vote
 	pollPassed, err := KNWVotingInstance.IsPassed(nil, big.NewInt(int64(config.DitConfig.Repositories[repoIndex].ActiveVotes[voteIndex].KNWVoteID)))
 	if err != nil {
-		return false, errors.New("Failed to retrieve vote outcome")
+		return false, false, errors.New("Failed to retrieve vote outcome")
 	}
 
 	fmt.Printf("\n")
@@ -847,7 +850,7 @@ func Finalize(_proposalID string) (bool, error) {
 	// Saving the config back to the file
 	err = config.Save()
 	if err != nil {
-		return false, nil
+		return false, false, err
 	}
 
 	if config.DitConfig.DemoModeActive && len(config.DitConfig.Repositories[repoIndex].ActiveVotes[voteIndex].DemoChoices) == 3 {
@@ -858,7 +861,7 @@ func Finalize(_proposalID string) (bool, error) {
 			}
 		}
 	}
-	return pollPassed, nil
+	return pollPassed, isProposer, nil
 }
 
 // GetVoteInfo will print information about a vote
@@ -1125,16 +1128,16 @@ func initDitRepository(_ditCoordinatorInstance *ditCoordinator.DitCoordinator, _
 	voteSettings[2] = big.NewInt(0)
 
 	// TODO
-	voteSettings[3] = big.NewInt(120)
+	voteSettings[3] = big.NewInt(150)
 
 	// TODO
-	voteSettings[4] = big.NewInt(121)
+	voteSettings[4] = big.NewInt(86400)
 
 	// TODO
-	voteSettings[5] = big.NewInt(120)
+	voteSettings[5] = big.NewInt(150)
 
 	// TODO
-	voteSettings[6] = big.NewInt(121)
+	voteSettings[6] = big.NewInt(86400)
 
 	// Prompting the user to provide 1 to 3 knowledge-labels for this repository
 	helpers.PrintLine("Please provide knowledge labels that will be used for this repository:", 0)

git/git.go

@@ -111,6 +111,33 @@ func checkGitSetup() error {
 	return nil
 }
 
+// Validate will return an error when the connection to
+// the git provider fails (validated through a git fetch)
+func Validate() error {
+	repoName, err := GetRepository()
+	if err != nil {
+		return err
+	}
+
+	// Verifying whether a master branch (or any branch) exists
+	cmdName := "git"
+	cmdArgs := []string{"branch"}
+	cmdOutBranch, err := exec.Command(cmdName, cmdArgs...).CombinedOutput()
+	if err != nil {
+		return errors.New("There was an error running git branch")
+	}
+
+	// Verifying whether the connection works correctly
+	cmdName = "git"
+	cmdArgs = []string{"fetch", "-v"}
+	cmdOutFetch, err := exec.Command(cmdName, cmdArgs...).CombinedOutput()
+	if (!strings.Contains(string(cmdOutFetch), repoName) && len(cmdOutBranch) > 0) || err != nil {
+		return errors.New("The connection to the git provider failed - please ensure that the repository is configured correctly")
+	}
+
+	return nil
+}
+
 // CheckForChanges will return an error if there are no new files to commit
 func CheckForChanges() error {
 	// Verifying whether files have been added

main.go

@@ -105,21 +105,24 @@ func main() {
 		break
 	case "commit", "propose_commit", "demo_commit":
 		checkIfExists(args, 1, "a commit message")
-		var voteDetails string
-		var proposalID int
-
-		err = git.CheckForChanges()
+		err = git.Validate()
 		if err == nil {
-			// Propose a new commit
-			voteDetails, proposalID, err = ethereum.ProposeCommit(args[1])
+			var voteDetails string
+			var proposalID int
+
+			err = git.CheckForChanges()
 			if err == nil {
-				// Push the commit into a proposal branch
-				err = git.Commit(proposalID, args[1])
+				// Propose a new commit
+				voteDetails, proposalID, err = ethereum.ProposeCommit(args[1])
 				if err == nil {
-					// Print the details of the vote
-					stringLines := strings.Split(voteDetails, "\n")
-					for i := range stringLines {
-						helpers.PrintLine(stringLines[i], 0)
+					// Push the commit into a proposal branch
+					err = git.Commit(proposalID, args[1])
+					if err == nil {
+						// Print the details of the vote
+						stringLines := strings.Split(voteDetails, "\n")
+						for i := range stringLines {
+							helpers.PrintLine(stringLines[i], 0)
+						}
 					}
 				}
 			}
@@ -160,26 +163,29 @@ func main() {
 		break
 	case "finalize", "finalize_vote":
 		checkIfExists(args, 1, "a proposal ID")
-		var pollPassed bool
-		// Resolves a proposal
-		pollPassed, err = ethereum.Finalize(args[1])
+		err = git.Validate()
 		if err == nil {
-			fmt.Println()
-			if pollPassed {
-				// Merges the proposal branch into master after a successful vote
-				err = git.Merge(args[1])
-				if err == nil {
-					helpers.PrintLine("Successfully merged dit proposal "+args[1]+" into the master branch", 0)
-				}
-			} else {
-				// Deletes the proposal branch after an unsuccessful vote
-				err = git.DeleteBranch(args[1])
-				if err == nil {
-					helpers.PrintLine("Removed the dit proposal "+args[1]+" from the repository", 0)
+			var pollPassed bool
+			var isProposer bool
+			// Finalizes a proposal
+			pollPassed, isProposer, err = ethereum.Finalize(args[1])
+			if err == nil && isProposer {
+				fmt.Println()
+				if pollPassed {
+					// Merges the proposal branch into master after a successful vote
+					err = git.Merge(args[1])
+					if err == nil {
+						helpers.PrintLine("Successfully merged dit proposal "+args[1]+" into the master branch", 0)
+					}
+				} else {
+					// Deletes the proposal branch after an unsuccessful vote
+					err = git.DeleteBranch(args[1])
+					if err == nil {
+						helpers.PrintLine("Removed the dit proposal "+args[1]+" from the repository", 0)
+					}
 				}
 			}
 		}
-
 		break
 	default:
 		printUsage()