katolaz
/
scorsh
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

A first go at gometalinter :-)

Browse Source
lint-refactor
KatolaZ 8 years ago
parent e6af4d1a5c
commit 3fcaf22bbb
7 changed files with 143 additions and 152 deletions
Show Stats Download Patch File Download Diff File

98
commits.go
Unescape View File

@ -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)
}
}

9
config.go
Unescape View File

@ -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)

42
exec.go
Unescape View File

@ -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))

84
scorshd.go
Unescape View File

@ -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

14
spooler.go
Unescape View File

@ -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()

40
types.go
Unescape View File

@ -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

8
workers.go
Unescape View File

@ -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

Write Preview
Loading…
Cancel
Save