func TraverseFileTree(path string) ([]string, os.Error) { l := vector.StringVector(make([]string, 1, 20)) l.Push(path) d, e := IsDirectory(path) if e != nil { return nil, e } if d { c, e := GetDirectoryContent(path) if e != nil { return nil, e } for _, file := range c { s, e := TraverseFileTree(path + "/" + file) v := vector.StringVector(s) if e != nil { return nil, e } l.AppendVector(&v) } } return l, nil }
func NewOutBuffers(ctx *AutoCompleteContext) *OutBuffers { b := new(OutBuffers) b.tmpbuf = bytes.NewBuffer(make([]byte, 0, 1024)) b.names = vector.StringVector(make([]string, 0, 1024)) b.types = vector.StringVector(make([]string, 0, 1024)) b.classes = vector.StringVector(make([]string, 0, 1024)) b.ctx = ctx return b }
// ReadMIMEHeader reads a MIME-style header from r. // The header is a sequence of possibly continued Key: Value lines // ending in a blank line. // The returned map m maps CanonicalHeaderKey(key) to a // sequence of values in the same order encountered in the input. // // For example, consider this input: // // My-Key: Value 1 // Long-Key: Even // Longer Value // My-Key: Value 2 // // Given that input, ReadMIMEHeader returns the map: // // map[string][]string{ // "My-Key": []string{"Value 1", "Value 2"}, // "Long-Key": []string{"Even Longer Value"}, // } // func (r *Reader) ReadMIMEHeader() (map[string][]string, os.Error) { m := make(map[string][]string) for { kv, err := r.ReadContinuedLineBytes() if len(kv) == 0 { return m, err } // Key ends at first colon; must not have spaces. i := bytes.IndexByte(kv, ':') if i < 0 || bytes.IndexByte(kv[0:i], ' ') >= 0 { return m, ProtocolError("malformed MIME header line: " + string(kv)) } key := CanonicalHeaderKey(string(kv[0:i])) // Skip initial spaces in value. i++ // skip colon for i < len(kv) && (kv[i] == ' ' || kv[i] == '\t') { i++ } value := string(kv[i:]) v := vector.StringVector(m[key]) v.Push(value) m[key] = v if err != nil { return m, err } } panic("unreachable") }
func main() { in := bufio.NewReader(os.Stdin) lines := vector.StringVector(make([]string, 0, 500)) for { for { l, err := in.ReadString('\n') if err != nil { log.Stderr("Error reading map, expected more input\n") return } if l == "go\n" { pw := ParseGameState(lines) DoTurn(pw) pw.EndTurn() break } else { lines.Push(l) } } lines = lines[0:0] } }
func (p *wmDecisionCore) variances() []string { var v vector.StringVector var ctp []MediaTypeHandler var ep []EncodingHandler var cp []CharsetHandler arr := make([]string, 1) arr[0] = "*" ctp, p.req, p.cxt, _, _ = p.handler.ContentTypesProvided(p.req, p.cxt) ep, p.req, p.cxt, _, _ = p.handler.EncodingsProvided(arr, p.req, p.cxt) cp, p.req, p.cxt, _, _ = p.handler.CharsetsProvided(arr, p.req, p.cxt) if len(ctp) > 1 { v.Push("Accept") } if len(ep) > 1 { v.Push("Accept-Encoding") } if len(cp) > 1 { v.Push("Accept-Charset") } var headers []string headers, p.req, p.cxt, _, _ = p.handler.Variances(p.req, p.cxt) v2 := vector.StringVector(headers) v.AppendVector(&v2) return v }
// Internal. Parses headers in NNTP articles. Most of this is stolen from the http package, // and it should probably be split out into a generic RFC822 header-parsing package. func (c *Conn) readHeader(r *bufio.Reader) (res *Article, err os.Error) { res = new(Article) res.Header = make(map[string][]string) for { var key, value string if key, value, err = readKeyValue(r); err != nil { return nil, err } if key == "" { break } key = http.CanonicalHeaderKey(key) // RFC 3977 says nothing about duplicate keys' values being equivalent to // a single key joined with commas, so we keep all values seperate. oldvalue, present := res.Header[key] if present { sv := vector.StringVector(oldvalue) sv.Push(value) res.Header[key] = []string(sv) } else { res.Header[key] = []string{value} } } return res, nil }
func ChannelToSliceString(in <-chan string) []string { v := vector.StringVector(make([]string, 1, 20)) for i := range in { v.Push(i) } return v[1:v.Len()] }
func dumpResults(totMargin int, margins map[string]map[int]int) { vec := vector.StringVector(make([]string, 0, 32)) for k := range margins { vec.Push(k) } sort.StringArray(vec).Sort() for _, dice := range vec { println("Margins for", dice) dumpMargin(totMargin, margins[dice]) } }
func TraverseFileTreeFiltered(path string) ([]string, os.Error) { list, e := TraverseFileTree(path) if e != nil { return nil, e } v := vector.StringVector(make([]string, 1, 20)) for _, l := range list { if len(l) != 0 { v.Push(l) } } return v[1:v.Len()], nil }
func ParseQuery(query string) (m map[string][]string, err os.Error) { m = make(map[string][]string) for _, kv := range strings.Split(query, "&", 0) { kvPair := strings.Split(kv, "=", 2) var key, value string var e os.Error key, e = URLUnescape(kvPair[0]) if e == nil && len(kvPair) > 1 { value, e = URLUnescape(kvPair[1]) } if e != nil { err = e } vec := vector.StringVector(m[key]) vec.Push(value) m[key] = vec } return }
func parseQuery(m map[string][]string, query string) (err os.Error) { for _, kv := range strings.Split(query, "&", -1) { if len(kv) == 0 { continue } kvPair := strings.Split(kv, "=", 2) var key, value string var e os.Error key, e = URLUnescape(kvPair[0]) if e == nil && len(kvPair) > 1 { value, e = URLUnescape(kvPair[1]) } if e != nil { err = e continue } vec := vector.StringVector(m[key]) vec.Push(value) m[key] = vec } return err }
func (f *allFlags) parseOne(index int) (ok bool, next int) { s := os.Args[index] // Take care of non-flag arguments. if len(s) == 0 || s[0] != '-' || s == "-" { f.args.Push(s) return true, index + 1 } if s == "--" { v := vector.StringVector(os.Args[index+1:]) f.args.AppendVector(&v) return false, -1 } var errorStr string // Sort out flag arguments. if s[1] != '-' { for { // Deal with shortname flags sname, sz := utf8.DecodeRuneInString(s[1:]) if sname == utf8.RuneError { errorStr = "invalid UTF-8 character" goto argError } name, ok := f.snames[sname] if !ok { errorStr = fmt.Sprintf("flag provided but not defined: -%s\n", string(sname)) goto argError } rest := s[1+sz:] // Check for (bad) extraneous flags if _, ok := f.actual[name]; ok { errorStr = fmt.Sprintf("flag specified twice: -%s\n", string(sname)) goto argError } flag, ok := f.formal[name] if !ok { errorStr = fmt.Sprintf("flag provided but not defined: -%s\n", string(sname)) goto argError } // Try and understand the value of the flag if f, ok := flag.Value.(*boolValue); ok { // special case: doesn't need an arg f.set("true") s = "-" + rest continue } has_value := false if rest != "" { has_value = true } if !has_value && index < len(os.Args)-1 { has_value = true index++ rest = os.Args[index] } if !has_value { errorStr = fmt.Sprintf("flag needs an argument: -%s\n", string(sname)) goto argError } if ok = flag.Value.set(rest); !ok { errorStr = fmt.Sprintf("invalid value %s for flag: -%s\n", rest, string(sname)) goto argError } break } } else { // Long name flags name := s[2:] if name[0] == '-' || name[0] == '=' { errorStr = fmt.Sprintln("bad flag syntax:", s) goto argError } has_value := false value := "" for i, rune := range name { if rune == '=' { value = name[i+1:] // the '=' rune has len 1 has_value = true name = name[0:i] break } } // Check for (bad) extraneous flags if _, ok := f.actual[name]; ok { errorStr = fmt.Sprintf("flag specified twice: -%s\n", name) goto argError } flag, ok := f.formal[name] if !ok { errorStr = fmt.Sprintf("flag provided but not defined: -%s\n", name) goto argError } // Try and understand the value of the flag if f, ok := flag.Value.(*boolValue); ok { // special case: doesn't need an arg if has_value { if !f.set(value) { errorStr = fmt.Sprintf("invalid boolean value %t for flag: -%s\n", value, name) goto argError } } else { f.set("true") } } else { // It must have a value, which might be the next argument. if !has_value && index < len(os.Args)-1 { // value is the next arg has_value = true index++ value = os.Args[index] } if !has_value { errorStr = fmt.Sprintf("flag needs an argument: -%s\n", name) goto argError } if ok = flag.Value.set(value); !ok { errorStr = fmt.Sprintf("invalid value %s for flag: -%s\n", value, name) goto argError } } f.actual[name] = flag } return true, index + 1 argError: fmt.Fprint(os.Stderr, errorStr) Usage() os.Exit(2) return false, -1 }
func (p *Pipeline) groupImport(cs ContactsService, ds DataStoreService, dsocialUserId string, group *Group, minimumIncludes *list.List, allowAdd, allowDelete, allowUpdate bool) (*dm.Group, string, os.Error) { emptyGroup := new(dm.Group) if group == nil || group.Value == nil { return nil, "", nil } //fmt.Printf("[PIPELINE]: Syncing group: %s\n", group.Value.Name) if group.Value.ContactIds == nil { group.Value.ContactIds = make([]string, 0, 10) } if group.Value.ContactNames == nil { group.Value.ContactNames = make([]string, 0, 10) } if len(group.Value.ContactIds) == 0 && len(group.Value.ContactNames) == 0 && minimumIncludes != nil { sv1 := vector.StringVector(group.Value.ContactIds) sv2 := vector.StringVector(group.Value.ContactNames) sv1.Resize(sv1.Len(), sv1.Len()+minimumIncludes.Len()) sv2.Resize(sv2.Len(), sv2.Len()+minimumIncludes.Len()) for iter := minimumIncludes.Front(); iter != nil; iter = iter.Next() { contactRef := iter.Value.(*dm.ContactRef) sv1.Push(contactRef.Id) sv2.Push(contactRef.Name) } } else if minimumIncludes != nil { for iter := minimumIncludes.Front(); iter != nil; iter = iter.Next() { contactRef := iter.Value.(*dm.ContactRef) refLocation := -1 if contactRef.Id != "" { for i, id := range group.Value.ContactIds { if id == contactRef.Id { refLocation = i break } } } if refLocation == -1 && contactRef.Name != "" { for i, name := range group.Value.ContactNames { if name == contactRef.Name { refLocation = i break } } } if refLocation == -1 { sv1 := vector.StringVector(group.Value.ContactIds) sv2 := vector.StringVector(group.Value.ContactNames) sv1.Push(contactRef.Id) sv2.Push(contactRef.Name) } else { group.Value.ContactIds[refLocation] = contactRef.Id group.Value.ContactNames[refLocation] = contactRef.Name } } } extDsocialGroup, _, err := ds.RetrieveDsocialGroupForExternalGroup(group.ExternalServiceId, group.ExternalUserId, group.ExternalGroupId, dsocialUserId) if err != nil { return nil, "", err } var matchingGroup *dm.Group var isSame bool if extDsocialGroup == nil { // We don't have a mapping for this external group to an internal group mapping // meaning we've never imported this group previously from THIS service, but we may // already have the group in our system, so let's see if we can find it matchingGroup, isSame, err = p.findMatchingDsocialGroup(ds, dsocialUserId, group) if err != nil { return matchingGroup, "", err } if matchingGroup != nil { group.DsocialGroupId = matchingGroup.Id extGroup := cs.ConvertToExternalGroup(matchingGroup, nil, dsocialUserId) ds.StoreExternalGroup(group.ExternalServiceId, group.ExternalUserId, dsocialUserId, group.ExternalGroupId, extGroup) extDsocialGroup = cs.ConvertToDsocialGroup(extGroup, matchingGroup, dsocialUserId) if extDsocialGroup != nil { AddIdsForDsocialGroup(extDsocialGroup, ds, dsocialUserId) fmt.Printf("[PIPELINE]: groupImport() before store dsoc group ExternalGroupId: %v and extDsocialGroup.Id %v matchingGroup.Id %v\n", group.ExternalGroupId, extDsocialGroup.Id, matchingGroup.Id) //group.ExternalGroupId = extDsocialGroup.Id //extDsocialGroup.Id = group.DsocialGroupId extDsocialGroup, err = ds.StoreDsocialGroupForExternalGroup(group.ExternalServiceId, group.ExternalUserId, group.ExternalGroupId, dsocialUserId, extDsocialGroup) if extDsocialGroup == nil || err != nil { return matchingGroup, "", err } //extDsocialGroup.Id = group.DsocialGroupId fmt.Printf("[PIPELINE]: groupImport() before store mapping ExternalGroupId: %v and DsocialGroupId %v\n", group.ExternalGroupId, group.DsocialGroupId) if _, _, err = ds.StoreDsocialExternalGroupMapping(group.ExternalServiceId, group.ExternalUserId, group.ExternalGroupId, dsocialUserId, group.DsocialGroupId); err != nil { return matchingGroup, "", err } } } } else { // we have a mapping for this external group to an internal group mapping // from THIS service, therefore let's use it if group.DsocialGroupId == "" { group.DsocialGroupId, err = ds.DsocialIdForExternalGroupId(group.ExternalServiceId, group.ExternalUserId, dsocialUserId, group.ExternalGroupId) if err != nil { return nil, "", err } } if group.DsocialGroupId != "" { matchingGroup, _, err = ds.RetrieveDsocialGroup(dsocialUserId, group.DsocialGroupId) if err != nil { return nil, "", err } } } // ensure we have a contact Id if group.DsocialGroupId == "" { if matchingGroup != nil { group.DsocialGroupId = matchingGroup.Id fmt.Printf("[PIPELINE]: Will be using matchingGroup Id: %v\n", matchingGroup.Id) } if group.DsocialGroupId == "" { newGroup := &dm.Group{UserId: dsocialUserId} AddIdsForDsocialGroup(newGroup, ds, dsocialUserId) thegroup, err := ds.StoreDsocialGroup(dsocialUserId, newGroup.Id, newGroup) if err != nil { return nil, "", err } group.DsocialGroupId = thegroup.Id } } if _, isSame = emptyGroup.IsSimilarOrUpdated(extDsocialGroup, group.Value); isSame { return matchingGroup, "", nil } l := new(list.List) emptyGroup.GenerateChanges(extDsocialGroup, group.Value, nil, l) l = p.removeUnacceptedChanges(l, allowAdd, allowDelete, allowUpdate) changes := make([]*dm.Change, l.Len()) for i, iter := 0, l.Front(); iter != nil; i, iter = i+1, iter.Next() { changes[i] = iter.Value.(*dm.Change) } changeset := &dm.ChangeSet{ CreatedAt: time.UTC().Format(dm.UTC_DATETIME_FORMAT), ChangedBy: group.ExternalServiceId, ChangeImportId: group.ExternalGroupId, RecordId: group.DsocialGroupId, Changes: changes, } _, err = ds.StoreGroupChangeSet(dsocialUserId, changeset) if err != nil { return matchingGroup, changeset.Id, nil } if extDsocialGroup == nil { fmt.Printf("[PIPELINE]: OriginalExternalGroup is nil and group.DsocialGroupId is %v and group.Value.Id was %v\n", group.DsocialGroupId, group.Value.Id) group.Value.Id = group.DsocialGroupId AddIdsForDsocialGroup(group.Value, ds, dsocialUserId) group.Value, err = ds.StoreDsocialGroup(dsocialUserId, group.DsocialGroupId, group.Value) if err != nil { return matchingGroup, changeset.Id, err } storedDsocialGroup, err := ds.StoreDsocialGroupForExternalGroup(group.ExternalServiceId, group.ExternalUserId, group.ExternalGroupId, dsocialUserId, group.Value) _, _, err2 := ds.StoreDsocialExternalGroupMapping(group.ExternalServiceId, group.ExternalUserId, group.ExternalGroupId, dsocialUserId, group.DsocialGroupId) if err == nil { err = err2 } return storedDsocialGroup, changeset.Id, err } var storedDsocialGroup *dm.Group = nil if group.DsocialGroupId != "" { if storedDsocialGroup, _, err = ds.RetrieveDsocialGroup(dsocialUserId, group.DsocialGroupId); err != nil { return matchingGroup, changeset.Id, err } } if storedDsocialGroup == nil { storedDsocialGroup = new(dm.Group) } for j, iter := 0, l.Front(); iter != nil; j, iter = j+1, iter.Next() { change := iter.Value.(*dm.Change) dm.ApplyChange(storedDsocialGroup, change) changes[j] = change } AddIdsForDsocialGroup(storedDsocialGroup, ds, dsocialUserId) _, err = ds.StoreDsocialGroup(dsocialUserId, group.DsocialGroupId, storedDsocialGroup) return storedDsocialGroup, changeset.Id, err }
// ForkExec runs `cmd` in a child process, with all configuration options as // specified in `cx` and the listen fds `lf` in its initial set of fds. func (cx *Context) ForkExec(cmd string, lf []*os.File) (pid int, err os.Error) { // This is not easy to do, because Go does not give us a plain fork // function. Here's the trick: we fork/exec the same program currently // running in this process, then send configuration parameters to it over a // pipe. // // After the first exec, the child process will be running this program, // almost as if we had simply forked, but with a fresh address space. Once // the child reads the configuration data from its pipe, it has enough // information to set up the process environment and exec a second time, // starting the program we really want. if !hasProc() { return 0, os.NewError("doozer: Your OS doesn't have /proc") } var r run r.Context = *cx r.cmd = cmd var ir, iw, sr, sw *os.File sb := make([]byte, 4) // These pipe fds are already close-on-exec, which is what we want for iw // and sr. It's also okay for ir and sw, because we explicitly supply them // to os.ForkExec. ir, iw, err = os.Pipe() if err != nil { return } defer ir.Close() defer iw.Close() sr, sw, err = os.Pipe() if err != nil { return } defer sr.Close() defer sw.Close() // Boring, ugly code to set up the list of child fds. files := make([]*os.File, passListenFdsStart+len(lf)) files[0] = os.Stdin files[1] = os.Stdout files[2] = os.Stderr files[inputReadFd] = ir files[statusWriteFd] = sw copy(files[passListenFdsStart:], lf) // Boring, ugly code to set up the child environment vars. envv := vector.StringVector(os.Environ()) // See if we are giving it any listen fds. if lf != nil { envv.Push(fmt.Sprintf("LISTEN_FDS=%d", len(lf))) } // Okay, here we go... // Fork and exec the same program we're currently running. Give it `cookie` // as its only arg, telling it to behave as our helper program and run // function `execInChild`. pid, err = os.ForkExec("/proc/self/exe", []string{cookie}, envv, "", files) if err != nil { return 0, err } // Send it the configuration data. en := gob.NewEncoder(iw) err = en.Encode(&r) if err != nil { goto parenterror } // Be sure not to deadlock if the child is successful. sw.Close() // Check if the child had an error. var n int n, err = sr.Read(sb) if err != os.EOF || n != 0 { // got a full error code? if n == len(sb) { // decode it (big-endian) errno := 0 | // this 0 is to trick gofmt (int32(sb[0]) << 24) | (int32(sb[1]) << 16) | (int32(sb[2]) << 8) | (int32(sb[3]) << 0) err = &ChildError{os.Errno(errno)} } if err == nil { err = os.EPIPE } goto parenterror } // Read got EOF, so status pipe closed on exec, so exec succeeded. return pid, nil parenterror: // error of some sort after creating the child // make sure the child is well and truly dead syscall.Kill(pid, syscall.SIGKILL) // wait for it to exit, so we don't accumulate zombies var wstatus syscall.WaitStatus _, e1 := syscall.Wait4(pid, &wstatus, 0, nil) for e1 == syscall.EINTR { _, e1 = syscall.Wait4(pid, &wstatus, 0, nil) } return 0, err }
// Append value to slice for given key. func (m StringsMap) Append(key string, value string) { v := vector.StringVector(m[key]) v.Push(value) m[key] = v }