A first go at gometalinter :-)

7 files changed, 143 insertions, 152 deletions

diff --git a/commits.go b/commits.go
index 6a8e43e..3381a86 100644
--- a/commits.go
+++ b/commits.go
@@ -2,7 +2,7 @@ package main
 
 import (
 	"fmt"
-	"github.com/KatolaZ/git2go"
+	"github.com/libgit2/git2go"
 	"golang.org/x/crypto/openpgp"
 	"gopkg.in/yaml.v2"
 	"log"
@@ -11,7 +11,7 @@ import (
 	//	"log"
 )
 
-func CommitToString(commit *git.Commit) string {
+func commitToString(commit *git.Commit) string {
 
 	var ret string
 
@@ -25,56 +25,56 @@ func CommitToString(commit *git.Commit) string {
 }
 
 // FIXME: RETURN THE ENTITY PROVIDED BY THE CHECK, OR nil
-func check_signature(commit *git.Commit, keyring *openpgp.KeyRing) (signature, signed string, err error) {
+func checkSignature(commit *git.Commit, keyring *openpgp.KeyRing) (signature, signed string, err error) {
 
 	signature, signed, err = commit.ExtractSignature()
 
 	if err == nil {
-		_, err_sig :=
+		_, errSig :=
 			openpgp.CheckArmoredDetachedSignature(*keyring, strings.NewReader(signed),
 				strings.NewReader(signature))
 
-		if err_sig == nil {
+		if errSig == nil {
 			debug.log("[commit: %s] Good signature \n", commit.Id())
 			return signature, signed, nil
 		}
-		err = err_sig
+		err = errSig
 	}
 
 	return "", "", err
 }
 
-func find_scorsh_message(commit *git.Commit) (string, error) {
+func findScorshMessage(commit *git.Commit) (string, error) {
 
 	sep := "---\n"
 
 	msg := commit.RawMessage()
-	debug.log("[find_scorsg_msg] found message:\n%s\n", msg)
+	debug.log("[findScorshMessage] found message:\n%s\n", msg)
 
 	// FIXME!!! replace the following with a proper regexp.Match
 	idx := strings.Index(msg, sep)
 
 	if idx < 0 {
-		return "", fmt.Errorf("no SCORSH message found\n")
+		return "", fmt.Errorf("no SCORSH message found")
 	}
 	return msg[idx:], nil
 }
 
 // return a list of keyring names which verify the signature of a given commit
-func get_valid_keys(commit *git.Commit, keys *map[string]openpgp.KeyRing) []string {
+func getValidKeys(commit *git.Commit, keys *map[string]openpgp.KeyRing) []string {
 
 	var ret []string
 
-	for k_name, k_val := range *keys {
-		_, _, err := check_signature(commit, &k_val)
+	for kname, kval := range *keys {
+		_, _, err := checkSignature(commit, &kval)
 		if err == nil {
-			ret = append(ret, k_name)
+			ret = append(ret, kname)
 		}
 	}
 	return ret
 }
 
-func intersect_keys(ref map[string]bool, keys []string) []string {
+func intersectKeys(ref map[string]bool, keys []string) []string {
 
 	var ret []string
 
@@ -87,23 +87,23 @@ func intersect_keys(ref map[string]bool, keys []string) []string {
 	return ret
 }
 
-func find_tag_config(tag_name string, w *SCORSHworker) (*SCORSHtag_cfg, bool) {
+func findTagConfig(tagName string, w *SCORSHworker) (*SCORSHtagCfg, bool) {
 
 	for _, c := range w.Tags {
-		if c.Name == tag_name {
+		if c.Name == tagName {
 			return &c, true
 		}
 	}
 	return nil, false
 }
 
-func get_author_email(c *git.Commit) string {
+func getAuthorEmail(c *git.Commit) string {
 
 	sig := c.Author()
 	return sig.Email
 }
 
-func get_committer_email(c *git.Commit) string {
+func getCommitterEmail(c *git.Commit) string {
 
 	sig := c.Committer()
 	return sig.Email
@@ -112,16 +112,16 @@ func get_committer_email(c *git.Commit) string {
 
 // walk_commits traverses all the commits between two references,
 // looking for scorsh commands, and tries to execute those if found
-func walk_commits(msg SCORSHmsg, w *SCORSHworker) error {
+func walkCommits(msg SCORSHmsg, w *SCORSHworker) error {
 
-	var tags SCORSHclient_msg
-	var commit_msg string
+	var tags SCORSHclientMsg
+	var commitMsg string
 
-	debug.log("[worker: %s] Inside parse_commits\n", w.Name)
+	debug.log("[worker: %s] Inside walkCommits\n", w.Name)
 
 	reponame := msg.Repo
-	old_rev := msg.Old_rev
-	new_rev := msg.New_rev
+	oldRev := msg.OldRev
+	newRev := msg.NewRev
 
 	repo, err := git.OpenRepository(reponame)
 	if err != nil {
@@ -130,28 +130,28 @@ func walk_commits(msg SCORSHmsg, w *SCORSHworker) error {
 		return SCORSHerr(SCORSH_ERR_NO_REPO)
 	}
 
-	old_rev_oid, err := git.NewOid(old_rev)
+	oldRevOid, err := git.NewOid(oldRev)
 
-	oldrev_commit, err := repo.LookupCommit(old_rev_oid)
+	oldrevCommit, err := repo.LookupCommit(oldRevOid)
 	if err != nil {
-		fmt.Fprintf(os.Stderr, "Commit: %s does not exist\n", old_rev)
+		fmt.Fprintf(os.Stderr, "Commit: %s does not exist\n", oldRev)
 		return SCORSHerr(SCORSH_ERR_NO_COMMIT)
 	}
 
-	new_rev_oid, err := git.NewOid(new_rev)
+	newRevOid, err := git.NewOid(newRev)
 
-	newrev_commit, err := repo.LookupCommit(new_rev_oid)
+	newrevCommit, err := repo.LookupCommit(newRevOid)
 	if err != nil {
-		fmt.Fprintf(os.Stderr, "Commit: %s does not exist\n", new_rev)
+		fmt.Fprintf(os.Stderr, "Commit: %s does not exist\n", newRev)
 		return SCORSHerr(SCORSH_ERR_NO_COMMIT)
 	}
 
-	cur_commit := newrev_commit
+	curCommit := newrevCommit
 
 	// FIXME: replace with a queue of commits
-	for cur_commit.Id().String() != oldrev_commit.Id().String() {
+	for curCommit.Id().String() != oldrevCommit.Id().String() {
 
-		commit, err := repo.LookupCommit(cur_commit.Id())
+		commit, err := repo.LookupCommit(curCommit.Id())
 		if err == nil {
 
 			// We look for scorsh-tags, and if the commit has any, check if
@@ -159,10 +159,10 @@ func walk_commits(msg SCORSHmsg, w *SCORSHworker) error {
 			// that specific scorsh-tag
 
 			// Check if the commit contains a scorsh command
-			commit_msg, err = find_scorsh_message(commit)
+			commitMsg, err = findScorshMessage(commit)
 			if err == nil {
 				// Check if is the comment contains a valid scorsh message
-				err = yaml.Unmarshal([]byte(commit_msg), &tags)
+				err = yaml.Unmarshal([]byte(commitMsg), &tags)
 
 				if err != nil {
 					// no scorsh message found
@@ -171,45 +171,45 @@ func walk_commits(msg SCORSHmsg, w *SCORSHworker) error {
 					// there is a scorsh message there so....
 
 					// 1) get the list of all the keyrings which verify the message
-					valid_keys := get_valid_keys(commit, &(w.Keys))
-					debug.log("[worker: %s] validated keyrings on commit: %s\n", w.Name, valid_keys)
+					validKeys := getValidKeys(commit, &(w.Keys))
+					debug.log("[worker: %s] validated keyrings on commit: %s\n", w.Name, validKeys)
 
 					// 2) then for each tag in the message
 					for _, t := range tags.Tags {
 						// a) check that the tag is among those accepted by the worker
-						tag_cfg, good_tag := find_tag_config(t.Tag, w)
-						debug.log("[worker: %s] good_tag: %s\n", w.Name, good_tag)
+						tagCfg, goodTag := findTagConfig(t.Tag, w)
+						debug.log("[worker: %s] goodTag: %s\n", w.Name, goodTag)
 
-						if !good_tag {
+						if !goodTag {
 							debug.log("[worker: %s] unsupported tag: %s\n", w.Name, t.Tag)
 							continue
 						}
 
 						// b) check that at least one of the accepted tag keyrings
 						// is in valid_keys
-						good_keys := intersect_keys(w.TagKeys[t.Tag], valid_keys) != nil
-						debug.log("[worker: %s] good_keys: %s\n", w.Name, good_keys)
+						goodKeys := intersectKeys(w.TagKeys[t.Tag], validKeys) != nil
+						debug.log("[worker: %s] goodKeys: %s\n", w.Name, goodKeys)
 
-						if !good_keys {
+						if !goodKeys {
 							debug.log("[worker: %s] no matching keys for tag: %s\n", w.Name, t.Tag)
 							continue
 						}
 
 						// c) If everything is OK, execute the tag
-						if good_tag && good_keys {
-							env := set_environment(&msg, t.Tag, get_author_email(commit), get_committer_email(commit))
-							errs := exec_tag(tag_cfg, t.Args, env)
+						if goodTag && goodKeys {
+							env := setEnvironment(&msg, t.Tag, getAuthorEmail(commit), getCommitterEmail(commit))
+							errs := execTag(tagCfg, t.Args, env)
 							debug.log("[worker: %s] errors in tag %s: %s\n", w.Name, t.Tag, errs)
 						}
 					}
 				}
 			} else {
-				log.Printf("[worker: %s] error parsing commit %s: %s", w.Name, cur_commit.Id().String(), err)
+				log.Printf("[worker: %s] error parsing commit %s: %s", w.Name, curCommit.Id().String(), err)
 			}
 			// FIXME: ADD ALL THE PARENTS TO THE QUEUE OF COMMITS
-			cur_commit = commit.Parent(0)
+			curCommit = commit.Parent(0)
 		} else {
-			fmt.Printf("Commit %x not found!\n", cur_commit.Id())
+			fmt.Printf("Commit %x not found!\n", curCommit.Id())
 			return SCORSHerr(SCORSH_ERR_NO_COMMIT)
 		}
 	}
diff --git a/config.go b/config.go
index 8cdd172..317940a 100644
--- a/config.go
+++ b/config.go
@@ -1,7 +1,6 @@
 package main
 
 import (
-	"fmt"
 	"gopkg.in/yaml.v2"
 	"io"
 	"io/ioutil"
@@ -11,16 +10,14 @@ import (
 
 // Read a configuration from fname or die
 
-func ReadGlobalConfig(fname string) *SCORSHmaster {
+func readGlobalConfig(fname string) *SCORSHmaster {
 
 	data, err := ioutil.ReadFile(fname)
 	if err != nil {
 		log.Fatal("Error while reading file: ", err)
 	}
 
-	var cfg *SCORSHmaster
-
-	cfg = new(SCORSHmaster)
+	var cfg = new(SCORSHmaster)
 
 	// Unmarshal the YAML configuration file into a SCORSHcfg structure
 	err = yaml.Unmarshal(data, cfg)
@@ -28,7 +25,7 @@ func ReadGlobalConfig(fname string) *SCORSHmaster {
 		log.Fatal("Error while reading configuration: ", err)
 	}
 
-	fmt.Printf("%s", cfg)
+	//fmt.Printf("%s", cfg)
 
 	if cfg.Logfile != "" {
 		f, err := os.OpenFile(cfg.Logfile, os.O_APPEND|os.O_CREATE|os.O_RDWR, 0600)
diff --git a/exec.go b/exec.go
index dc7563c..88f878f 100644
--- a/exec.go
+++ b/exec.go
@@ -11,9 +11,9 @@ import (
 	"os/exec"
 )
 
-func exec_local_file(cmd_url *url.URL, args, env []string) error {
+func execLocalFile(cmdURL *url.URL, args, env []string) error {
 
-	cmd := exec.Command(cmd_url.Path, args...)
+	cmd := exec.Command(cmdURL.Path, args...)
 	cmd.Env = env
 	stdout, err := cmd.StdoutPipe()
 
@@ -34,44 +34,42 @@ func exec_local_file(cmd_url *url.URL, args, env []string) error {
 	return err
 }
 
-func check_hash(file, hash string) error {
+func checkHash(file, hash string) error {
 
 	data, err := ioutil.ReadFile(file)
 	if err != nil {
 		return err
 	}
-	hash_bytes := sha256.Sum256(data)
-	computed_hash := fmt.Sprintf("%x", string(hash_bytes[:sha256.Size]))
-	debug.log("[check_hash] configured hash string: %s\n", hash)
-	debug.log("[check_hash] computed hash string: %s\n", computed_hash)
-	if computed_hash == hash {
+	hashBytes := sha256.Sum256(data)
+	computedHash := fmt.Sprintf("%x", string(hashBytes[:sha256.Size]))
+	debug.log("[checkHash] configured hash string: %s\n", hash)
+	debug.log("[checkHash] computed hash string: %s\n", computedHash)
+	if computedHash == hash {
 		return nil
-	} else {
-		return fmt.Errorf("WARNING!!! HASH MISMATCH FOR %s", file)
 	}
-
+	return fmt.Errorf("WARNING!!! HASH MISMATCH FOR %s", file)
 }
 
-func exec_url(cmd_url *url.URL, args, env []string) error {
+func execURL(cmdURL *url.URL, args, env []string) error {
 
 	return nil
 }
 
-func exec_tag(tag *SCORSHtag_cfg, args []string, env []string) []error {
+func execTag(tag *SCORSHtagCfg, args []string, env []string) []error {
 
 	var ret []error
 
 	for _, c := range tag.Commands {
 		debug.log("[tag: %s] attempting command: %s\n", tag.Name, c.URL)
-		cmd_url, err := url.Parse(c.URL)
+		cmdURL, err := url.Parse(c.URL)
 		if err != nil {
 			log.Printf("[tag: %s] error parsing URL: %s", tag.Name, err)
 		} else {
-			if cmd_url.Scheme == "file" {
+			if cmdURL.Scheme == "file" {
 				err = nil
 				// if a hash is specified, check that it matches
 				if c.Hash != "" {
-					err = check_hash(cmd_url.Path, c.Hash)
+					err = checkHash(cmdURL.Path, c.Hash)
 				}
 				// if the hash does not match, abort the command
 				if err != nil {
@@ -80,11 +78,11 @@ func exec_tag(tag *SCORSHtag_cfg, args []string, env []string) []error {
 					continue
 				} else {
 					// finally, the command can be executed
-					err = exec_local_file(cmd_url, args, env)
+					err = execLocalFile(cmdURL, args, env)
 				}
 
-			} else if cmd_url.Scheme == "http" || cmd_url.Scheme == "https" {
-				err = exec_url(cmd_url, args, env)
+			} else if cmdURL.Scheme == "http" || cmdURL.Scheme == "https" {
+				err = execURL(cmdURL, args, env)
 			}
 		}
 		ret = append(ret, err)
@@ -92,13 +90,13 @@ func exec_tag(tag *SCORSHtag_cfg, args []string, env []string) []error {
 	return ret
 }
 
-func set_environment(msg *SCORSHmsg, tag, author, committer string) []string {
+func setEnvironment(msg *SCORSHmsg, tag, author, committer string) []string {
 
 	env := os.Environ()
 	env = append(env, fmt.Sprintf("SCORSH_REPO=%s", msg.Repo))
 	env = append(env, fmt.Sprintf("SCORSH_BRANCH=%s", msg.Branch))
-	env = append(env, fmt.Sprintf("SCORSH_OLDREV=%s", msg.Old_rev))
-	env = append(env, fmt.Sprintf("SCORSH_NEWREV=%s", msg.New_rev))
+	env = append(env, fmt.Sprintf("SCORSH_OLDREV=%s", msg.OldRev))
+	env = append(env, fmt.Sprintf("SCORSH_NEWREV=%s", msg.NewRev))
 	env = append(env, fmt.Sprintf("SCORSH_ID=%s", msg.Id))
 	env = append(env, fmt.Sprintf("SCORSH_TAG=%s", tag))
 	env = append(env, fmt.Sprintf("SCORSH_AUTHOR=%s", author))
diff --git a/scorshd.go b/scorshd.go
index d36b646..c9ad835 100644
--- a/scorshd.go
+++ b/scorshd.go
@@ -20,31 +20,31 @@ func (d debugging) log(format string, args ...interface{}) {
 
 ///////////
 
-var conf_file = flag.String("c", "./scorsh.cfg", "Configuration file for SCORSH")
+var confFile = flag.String("c", "./scorsh.cfg", "Configuration file for SCORSH")
 
 func SCORSHerr(err int) error {
 
-	var err_str string
+	var errStr string
 
 	switch err {
 	case SCORSH_ERR_NO_FILE:
-		err_str = "Invalid file name"
+		errStr = "Invalid file name"
 	case SCORSH_ERR_KEYRING:
-		err_str = "Invalid keyring"
+		errStr = "Invalid keyring"
 	case SCORSH_ERR_NO_REPO:
-		err_str = "Invalid repository"
+		errStr = "Invalid repository"
 	case SCORSH_ERR_NO_COMMIT:
-		err_str = "Invalid commit ID"
+		errStr = "Invalid commit ID"
 	case SCORSH_ERR_SIGNATURE:
-		err_str = "Invalid signature"
+		errStr = "Invalid signature"
 	default:
-		err_str = "Generic Error"
+		errStr = "Generic Error"
 	}
-	return fmt.Errorf("%s", err_str)
+	return fmt.Errorf("%s", errStr)
 
 }
 
-func FindMatchingWorkers(master *SCORSHmaster, msg *SCORSHmsg) []*SCORSHworker {
+func findMatchingWorkers(master *SCORSHmaster, msg *SCORSHmsg) []*SCORSHworker {
 
 	var ret []*SCORSHworker
 
@@ -57,62 +57,58 @@ func FindMatchingWorkers(master *SCORSHmaster, msg *SCORSHmsg) []*SCORSHworker {
 	return ret
 }
 
-func Master(master *SCORSHmaster) {
+func runMaster(master *SCORSHmaster) {
 
 	// master main loop:
 
-	var matching_workers []*SCORSHworker
-
-	matching_workers = make([]*SCORSHworker, len(master.Workers))
-
 	log.Println("[master] Master started ")
 	debug.log("[master] StatusChan: %s\n", master.StatusChan)
 
 	for {
 		debug.log("[master] Receive loop...\n")
 		select {
-		case push_msg := <-master.Spooler:
+		case pushMsg := <-master.Spooler:
 			// here we manage the stuff we receive from the spooler
-			debug.log("[master] received message: %s\n", push_msg)
+			debug.log("[master] received message: %s\n", pushMsg)
 			// - lookup the repos map for matching workers
-			matching_workers = FindMatchingWorkers(master, &push_msg)
-			debug.log("[master] matching workers: \n%s\n", matching_workers)
+			matchingWorkers := findMatchingWorkers(master, &pushMsg)
+			debug.log("[master] matching workers: \n%s\n", matchingWorkers)
 
 			// add the message to WorkingMsg, if it's not a duplicate!
-			if _, ok := master.WorkingMsg[push_msg.Id]; ok {
-				log.Printf("[master] detected duplicate message %s \n", push_msg.Id)
+			if _, ok := master.WorkingMsg[pushMsg.Id]; ok {
+				log.Printf("[master] detected duplicate message %s \n", pushMsg.Id)
 			} else {
-				master.WorkingMsg[push_msg.Id] = 0
+				master.WorkingMsg[pushMsg.Id] = 0
 				// - dispatch the message to all the matching workers
-				for _, w := range matching_workers {
+				for _, w := range matchingWorkers {
 					debug.log("[master] sending msg to worker: %s\n", w.Name)
 					// send the message to the worker
-					w.MsgChan <- push_msg
+					w.MsgChan <- pushMsg
 					// increase the counter associated to the message
-					master.WorkingMsg[push_msg.Id] += 1
-					debug.log("[master] now WorkingMsg[%s] is: %d\n", push_msg.Id, master.WorkingMsg[push_msg.Id])
+					master.WorkingMsg[pushMsg.Id]++
+					debug.log("[master] now WorkingMsg[%s] is: %d\n", pushMsg.Id, master.WorkingMsg[pushMsg.Id])
 				}
 			}
-		case done_msg := <-master.StatusChan:
+		case doneMsg := <-master.StatusChan:
 			// Here we manage a status message from a worker
-			debug.log("[master] received message from StatusChan: %s\n", done_msg)
-			if _, ok := master.WorkingMsg[done_msg.Id]; ok && master.WorkingMsg[done_msg.Id] > 0 {
-				master.WorkingMsg[done_msg.Id] -= 1
-				if master.WorkingMsg[done_msg.Id] == 0 {
-					delete(master.WorkingMsg, done_msg.Id)
-					master.Spooler <- done_msg
+			debug.log("[master] received message from StatusChan: %s\n", doneMsg)
+			if _, ok := master.WorkingMsg[doneMsg.Id]; ok && master.WorkingMsg[doneMsg.Id] > 0 {
+				master.WorkingMsg[doneMsg.Id]--
+				if master.WorkingMsg[doneMsg.Id] == 0 {
+					delete(master.WorkingMsg, doneMsg.Id)
+					master.Spooler <- doneMsg
 				}
 			} else {
-				log.Printf("[master] received completion event for non-existing message name: %s\n", done_msg.Id)
+				log.Printf("[master] received completion event for non-existing message name: %s\n", doneMsg.Id)
 			}
 		}
 	}
 	debug.log("[master] Exiting the for loop, for some mysterious reason...\n")
 }
 
-func InitMaster() *SCORSHmaster {
+func initMaster() *SCORSHmaster {
 
-	master := ReadGlobalConfig(*conf_file)
+	master := readGlobalConfig(*confFile)
 
 	master.Repos = make(map[string][]*SCORSHworker)
 	master.WorkingMsg = make(map[string]int)
@@ -123,15 +119,15 @@ func InitMaster() *SCORSHmaster {
 
 	debug.log("[InitMaster] StatusChan: %s\n", master.StatusChan)
 
-	err_workers := StartWorkers(master)
-	if err_workers != nil {
-		log.Fatal("Error starting workers: ", err_workers)
+	errWorkers := startWorkers(master)
+	if errWorkers != nil {
+		log.Fatal("Error starting workers: ", errWorkers)
 	} else {
 		log.Println("Workers started correctly")
 	}
-	err_spooler := StartSpooler(master)
-	if err_spooler != nil {
-		log.Fatal("Error starting spooler: ", err_spooler)
+	errSpooler := startSpooler(master)
+	if errSpooler != nil {
+		log.Fatal("Error starting spooler: ", errSpooler)
 	}
 	return master
 }
@@ -142,9 +138,9 @@ func main() {
 
 	flag.Parse()
 
-	master := InitMaster()
+	master := initMaster()
 
-	go Master(master)
+	go runMaster(master)
 
 	// wait indefinitely -- we should implement signal handling...
 	<-done
diff --git a/spooler.go b/spooler.go
index ccf42dc..b25167b 100644
--- a/spooler.go
+++ b/spooler.go
@@ -11,9 +11,9 @@ import (
 )
 
 // parse a request file and return a SCORSHmessage
-func parse_request(fname string, msg *SCORSHmsg) error {
+func parseRequest(fname string, msg *SCORSHmsg) error {
 
-	debug.log("[parse_request] message at start: %s\n", msg)
+	debug.log("[parseRequest] message at start: %s\n", msg)
 
 	data, err := ioutil.ReadFile(fname)
 	if err != nil {
@@ -21,15 +21,15 @@ func parse_request(fname string, msg *SCORSHmsg) error {
 		return SCORSHerr(SCORSH_ERR_NO_FILE)
 	}
 
-	debug.log("[parse_request] file contains: \n%s\n", data)
+	debug.log("[parseRequest] file contains: \n%s\n", data)
 
-	debug.log("[parse_request] reading message from file: %s\n", fname)
+	debug.log("[parseRequest] reading message from file: %s\n", fname)
 
 	err = yaml.Unmarshal([]byte(data), msg)
 	if err != nil {
 		return fmt.Errorf("Error parsing message: %s", err)
 	}
-	debug.log("[parse_request] got message: %s\n", msg)
+	debug.log("[parseRequest] got message: %s\n", msg)
 	return nil
 }
 
@@ -46,7 +46,7 @@ func spooler(watcher *fsnotify.Watcher, master chan SCORSHmsg) {
 			if event.Op == fsnotify.Write {
 				var msg SCORSHmsg
 				debug.log("[spooler] new file %s detected\n", event.Name)
-				err := parse_request(event.Name, &msg)
+				err := parseRequest(event.Name, &msg)
 				if err != nil {
 					log.Printf("Invalid packet received. [%s]\n", err)
 				}
@@ -71,7 +71,7 @@ func spooler(watcher *fsnotify.Watcher, master chan SCORSHmsg) {
 	}
 }
 
-func StartSpooler(master *SCORSHmaster) error {
+func startSpooler(master *SCORSHmaster) error {
 
 	watcher, err := fsnotify.NewWatcher()
 
diff --git a/types.go b/types.go
index 235ef8d..bbd2ecc 100644
--- a/types.go
+++ b/types.go
@@ -17,12 +17,12 @@ const (
 // the SCORSHmsg type represents messages received from the spool and
 // sent to workers
 type SCORSHmsg struct {
-	Id      string `yaml:"m_id"`
-	Repo    string `yaml:"m_repo"`
-	Branch  string `yaml:"m_branch"`
-	Old_rev string `yaml:"m_oldrev"`
-	New_rev string `yaml:"m_newrev"`
-	Path    string
+	Id     string `yaml:"m_id"`
+	Repo   string `yaml:"m_repo"`
+	Branch string `yaml:"m_branch"`
+	OldRev string `yaml:"m_oldrev"`
+	NewRev string `yaml:"m_newrev"`
+	Path   string
 }
 
 type SCORSHcmd struct {
@@ -30,26 +30,26 @@ type SCORSHcmd struct {
 	Hash string `yaml:"c_hash"`
 }
 
-type SCORSHtag_cfg struct {
+type SCORSHtagCfg struct {
 	Name     string      `yaml:"t_name"`
 	Keyrings []string    `yaml:"t_keyrings"`
 	Commands []SCORSHcmd `yaml:"t_commands"`
 }
 
 // Configuration of a worker
-type SCORSHworker_cfg struct {
+type SCORSHworkerCfg struct {
 	Name    string   `yaml:"w_name"`
 	Repos   []string `yaml:"w_repos"`
 	Folder  string   `yaml:"w_folder"`
 	Logfile string   `yaml:"w_logfile"`
 	Tagfile string   `yaml:"w_tagfile"`
 	//	Keyrings []string        `yaml:"w_keyrings"`
-	Tags    []SCORSHtag_cfg `yaml:"w_tags"`
+	Tags    []SCORSHtagCfg `yaml:"w_tags"`
 	TagKeys map[string]map[string]bool
 }
 
 // State of a worker
-type SCORSHworker_state struct {
+type SCORSHworkerState struct {
 	Keys       map[string]openpgp.KeyRing
 	MsgChan    chan SCORSHmsg
 	StatusChan chan SCORSHmsg
@@ -58,12 +58,12 @@ type SCORSHworker_state struct {
 // The type SCORSHworker represents the configuration and state of a
 // worker
 type SCORSHworker struct {
-	SCORSHworker_cfg `yaml:",inline"`
-	SCORSHworker_state
+	SCORSHworkerCfg `yaml:",inline"`
+	SCORSHworkerState
 }
 
 // Configuration of the master
-type SCORSHmaster_cfg struct {
+type SCORSHmasterCfg struct {
 	Spooldir  string         `yaml:"s_spooldir"`
 	Logfile   string         `yaml:"s_logfile"`
 	LogPrefix string         `yaml:"s_logprefix"`
@@ -71,7 +71,7 @@ type SCORSHmaster_cfg struct {
 }
 
 // State of the master
-type SCORSHmaster_state struct {
+type SCORSHmasterState struct {
 	Spooler    chan SCORSHmsg
 	StatusChan chan SCORSHmsg
 	Repos      map[string][]*SCORSHworker
@@ -81,8 +81,8 @@ type SCORSHmaster_state struct {
 // The type SCORSHmaster represents the configuration and state of the
 // master
 type SCORSHmaster struct {
-	SCORSHmaster_cfg `yaml:",inline"`
-	SCORSHmaster_state
+	SCORSHmasterCfg `yaml:",inline"`
+	SCORSHmasterState
 }
 
 // client commands
@@ -92,7 +92,7 @@ type SCORSHtag struct {
 	Args []string `yaml:"s_args"`
 }
 
-type SCORSHclient_msg struct {
+type SCORSHclientMsg struct {
 	Tags []SCORSHtag `yaml:"scorsh"`
 }
 
@@ -120,8 +120,8 @@ func (msg *SCORSHmsg) String() string {
 	fmt.Fprintf(&buff, "Id: %s\n", msg.Id)
 	fmt.Fprintf(&buff, "Repo: %s\n", msg.Repo)
 	fmt.Fprintf(&buff, "Branch: %s\n", msg.Branch)
-	fmt.Fprintf(&buff, "Old_Rev: %s\n", msg.Old_rev)
-	fmt.Fprintf(&buff, "New_rev: %s\n", msg.New_rev)
+	fmt.Fprintf(&buff, "OldRev: %s\n", msg.OldRev)
+	fmt.Fprintf(&buff, "Newrev: %s\n", msg.NewRev)
 	fmt.Fprintf(&buff, "Path: %s\n", msg.Path)
 
 	return buff.String()
@@ -141,7 +141,7 @@ func (w *SCORSHworker) String() string {
 	return buff.String()
 }
 
-func (msg *SCORSHclient_msg) String() string {
+func (msg *SCORSHclientMsg) String() string {
 
 	var buff bytes.Buffer
 
diff --git a/workers.go b/workers.go
index 66dc6b0..2562b68 100644
--- a/workers.go
+++ b/workers.go
@@ -86,7 +86,7 @@ func (w *SCORSHworker) LoadTags() error {
 }
 
 // FIXME--- still needs some work...
-func Worker(w *SCORSHworker) {
+func runWorker(w *SCORSHworker) {
 
 	var msg SCORSHmsg
 
@@ -101,7 +101,7 @@ func Worker(w *SCORSHworker) {
 		case msg = <-w.MsgChan:
 			debug.log("[worker: %s] received message %s\n", w.Name, msg.Id)
 			// process message
-			err := walk_commits(msg, w)
+			err := walkCommits(msg, w)
 			if err != nil {
 				log.Printf("[worker: %s] error in walk_commits: %s", err)
 			}
@@ -113,7 +113,7 @@ func Worker(w *SCORSHworker) {
 
 // StartWorkers starts all the workers specified in a given
 // configuration and fills in the SCORSHmaster struct
-func StartWorkers(master *SCORSHmaster) error {
+func startWorkers(master *SCORSHmaster) error {
 
 	num_workers := len(master.Workers)
 
@@ -146,7 +146,7 @@ func StartWorkers(master *SCORSHmaster) error {
 		for _, repo_name := range worker.Repos {
 			master.Repos[repo_name] = append(master.Repos[repo_name], worker)
 		}
-		go Worker(worker)
+		go runWorker(worker)
 		<-master.StatusChan
 	}
 	return nil