func (ls *libstore) deletelist() { now := time.Now() // ls.mutex.Lock() // // fmt.Println("deleteinvalid") // defer ls.mutex.Unlock() for key, list := range ls.keyValudhistory { ls.initiateKeyValueMutex(key) ls.keyValueMutex[key].Lock() for list.Len() > 0 { e := list.Front() if e.Value.(time.Time).Add(time.Duration(storagerpc.QueryCacheSeconds)*time.Second).After(now) && list.Len() <= storagerpc.QueryCacheThresh { break } list.Remove(list.Front()) } ls.keyValueMutex[key].Unlock() } for key, list := range ls.keyListhistory { ls.initiateKeyListMutex(key) ls.keyListMutex[key].Lock() for list.Len() > 0 { e := list.Front() if e.Value.(time.Time).Add(time.Duration(storagerpc.QueryCacheSeconds)*time.Second).After(now) && list.Len() <= storagerpc.QueryCacheThresh { break } list.Remove(list.Front()) } ls.keyListMutex[key].Unlock() } }
// Reads a list of ASN1Cert types from |r| func readASN1CertList(r io.Reader, totalLenBytes int, elementLenBytes int) ([]ASN1Cert, error) { listBytes, err := readVarBytes(r, totalLenBytes) if err != nil { return []ASN1Cert{}, err } list := list.New() listReader := bytes.NewReader(listBytes) var entry []byte for err == nil { entry, err = readVarBytes(listReader, elementLenBytes) if err != nil { if err != io.EOF { return []ASN1Cert{}, err } } else { list.PushBack(entry) } } ret := make([]ASN1Cert, list.Len()) i := 0 for e := list.Front(); e != nil; e = e.Next() { ret[i] = e.Value.([]byte) i++ } return ret, nil }
func (ss *storageServer) GetList(args *storagerpc.GetArgs, reply *storagerpc.GetListReply) error { if !ss.isInServerRange(args.Key) { reply.Status = storagerpc.WrongServer return nil } //get the lock for current key ss.mutex.Lock() lock, exist := ss.lockMap[args.Key] if !exist { lock = new(sync.Mutex) ss.lockMap[args.Key] = lock } ss.mutex.Unlock() //Lock current key we are going to work on lock.Lock() //process lease request grantLease := false if args.WantLease { //add to lease map var libServerList *list.List libServerList, exist := ss.leaseMap[args.Key] if !exist { libServerList = new(list.List) } leaseRecord := LeaseRecord{args.HostPort, time.Now()} libServerList.PushBack(leaseRecord) ss.leaseMap[args.Key] = libServerList grantLease = true } reply.Lease = storagerpc.Lease{grantLease, storagerpc.LeaseSeconds} //retrieve list list, exist := ss.keyListMap[args.Key] if !exist { reply.Status = storagerpc.KeyNotFound } else { //convert list format from "map" to "[]string" listSize := list.Len() replyList := make([]string, listSize) i := 0 for e := list.Front(); e != nil; e = e.Next() { val := (e.Value).(string) replyList[i] = val i = i + 1 } reply.Value = replyList reply.Status = storagerpc.OK } lock.Unlock() return nil }
func MatchAll(m *Matcher, text string) []Match { list := list.New() ch := m.Match(text) for n := range ch { list.PushBack(n) } all := make([]Match, list.Len()) idx := 0 for e := list.Front(); e != nil; e = e.Next() { all[idx] = e.Value.(Match) idx++ } return all }
func daythirteen() { file, _ := os.Open("input-day13") list := list.New() scanner := bufio.NewScanner(file) for scanner.Scan() { text := scanner.Text() list.PushFront(text) } arr := make([]string, list.Len()) count := 0 for e := list.Front(); e != nil; e = e.Next() { arr[count] = e.Value.(string) count++ } fmt.Printf("Best = %d\n", ProcSeatingArray(arr, 0)) fmt.Printf("Best = %d\n", ProcSeatingArray(arr, 1)) }
func reconstructPath(came_from map[Coord]Coord, current_node Coord) []*Move { list := list.New() for present := true; present; _, present = came_from[current_node] { next_node := came_from[current_node] list.PushFront(findMove(current_node, next_node)) current_node = next_node } // Convert to a list and return rtn := make([]*Move, list.Len()) i := 0 for e := list.Front(); e != nil; e = e.Next() { move := e.Value.(Move) rtn[i] = &move i++ } return rtn }
//根据taskId查看某一个task func task(w http.ResponseWriter, r *http.Request) { taskId := r.FormValue("taskId") mark, list := dbutil.FetchTaskById(taskId) if list.Len() == 0 { io.WriteString(w, "without this task !") return } if mark == 1 { var listHtml string = "<body><ol>" for e := list.Front(); e != nil; e = e.Next() { task, ok := e.Value.(dbutil.Task) if ok { //获取task信息 host := task.Host port := task.Port filterLength := task.FilterLength filterKey := task.FilterKey taskId := task.TaskId priority := task.Priority status := task.Status createTime := task.CreateTime listHtml += "<li>" + "host:" + host + ";port:" + port + ";filterLength:" + strconv.FormatInt(int64(filterLength), 10) + ";filter_key:" + filterKey + ";taskId:" + taskId + ";priority:" + strconv.FormatInt(int64(priority), 10) + ";status:" + strconv.FormatInt(int64(status), 10) + ";create_time:" + createTime + "</li>" } else { //task的类型不正确 return } listHtml = listHtml + "</ol></body>" } io.WriteString(w, listHtml) } else { io.WriteString(w, "error occure !") logs.Log("error occure in taskView!") } }
// The command module takes as input a map, and runs that command. // // Parameters in the input map are: // :command, a list or vector, giving the command to run. Required. // :env, a map of names to values; if specified, these are added to the environment when running the command; optional // :input, a string to pass to the command's stdin; optional func (this Command) Exec(input types.Value) (output types.Value, err error) { var command []string var commandMap types.Map if m, ok := input.(types.Map); ok { commandMap = m } else { err = errors.New("input must be a map") return } var commandEntry = commandMap[types.Keyword("command")] if commandEntry == nil { err = errors.New("require at least :command in input") return } else if l, ok := commandEntry.(*types.List); ok { var list = (*list.List)(l) command = make([]string, list.Len()) var i = 0 for e := list.Front(); e != nil; e = e.Next() { if elem, ok := e.Value.(types.String); ok { command[i] = string(elem) i++ } else { err = errors.New(":command must be a list of strings") return } } } else if v, ok := commandEntry.(types.Vector); ok { var vect = ([]types.Value)(v) command = make([]string, len(vect)) for i, e := range vect { if elem, ok := e.(types.String); ok { command[i] = string(elem) } else { err = errors.New(":command must be a vector of strings") return } } } else { err = errors.New("expected a list or vector as :command") return } var cmd = exec.Command(command[0], command[1:]...) var envEntry = commandMap[types.Keyword("env")] if envEntry != nil { if e, ok := envEntry.(types.Map); ok { var env = make([]string, len(e)) var i = 0 for k := range e { v := e[k] if kk, ok := k.(types.String); ok && len(kk) > 0 { if vv, ok := v.(types.String); ok && len(vv) > 0 { env[i] = fmt.Sprint(string(kk), "=", string(vv)) } else { err = errors.New(":env values must be nonempty strings") return } } else { err = errors.New(":env keys must be nonempty strings") return } i++ } cmd.Env = env } else { err = errors.New(":env must be a map if specified") return } } var stdinEntry = commandMap[types.Keyword("input")] if stdinEntry != nil { if stdin, ok := stdinEntry.(types.String); ok { cmd.Stdin = strings.NewReader(string(stdin)) } else { err = errors.New(":input must be a string if specified") return } } var stderr = new(bytes.Buffer) var stdout = new(bytes.Buffer) cmd.Stderr = stderr cmd.Stdout = stdout err = cmd.Run() if err != nil { output = types.Map{ types.Keyword("success"): types.Bool(false), types.Keyword("err"): types.String(stderr.String()), types.Keyword("out"): types.String(stdout.String()), types.Keyword("system-time"): types.Float(cmd.ProcessState.SystemTime().Seconds()), types.Keyword("user-time"): types.Float(cmd.ProcessState.UserTime().Seconds()), } return } output = types.Map{ types.Keyword("success"): types.Bool(true), types.Keyword("err"): types.String(stderr.String()), types.Keyword("out"): types.String(stdout.String()), types.Keyword("system-time"): types.Float(cmd.ProcessState.SystemTime().Seconds()), types.Keyword("user-time"): types.Float(cmd.ProcessState.UserTime().Seconds()), } return }
func (ls *libstore) GetList(key string) ([]string, error) { now := time.Now() ls.initiateKeyListMutex(key) ls.keyListMutex[key].Lock() defer ls.keyListMutex[key].Unlock() value, ok := ls.keylist[key] if ok { validUntil := value.lease.startFrom.Add(time.Duration(value.lease.validSeconds) * time.Second) if now.After(validUntil) { delete(ls.keylist, key) ok = !ok } } list, list_ok := ls.keyListhistory[key] if list_ok { for list.Len() > 0 { e := list.Front() pretime := e.Value.(time.Time) judgetime := pretime.Add(time.Duration(storagerpc.QueryCacheSeconds) * time.Second) if judgetime.After(now) && list.Len() <= storagerpc.QueryCacheThresh { break } list.Remove(list.Front()) } list.PushBack(now) // do not know wether count cache or not } if ok { //use cache return value.list, nil } else { // use the storage want := false if ls.mode == Always { want = true } if ls.mode == Normal && list_ok && ls.keyListhistory[key].Len() >= storagerpc.QueryCacheThresh { want = true } args := &storagerpc.GetArgs{ Key: key, WantLease: want, HostPort: ls.myHostPort, } reply := &storagerpc.GetListReply{} server := ls.Findshashring(key) client, ok := ls.clientmap[server] if !ok { clienttemp, err := rpc.DialHTTP("tcp", server) if err != nil { return nil, errors.New("meet error when DialHTTP") } ls.clientmap[server] = clienttemp client = clienttemp } err := client.Call("StorageServer.GetList", args, &reply) if err != nil { return nil, errors.New("error when libstore call get to storageserver") } if reply.Status == storagerpc.OK { if reply.Lease.Granted == true { // update cache ls.keylist[key] = &listlib{ list: reply.Value, lease: leasetype{ startFrom: now, validSeconds: reply.Lease.ValidSeconds, }, } } } else if reply.Status == storagerpc.KeyNotFound { return make([]string, 0), nil } else { return nil, errors.New("reply not ready getlist: " + string(reply.Status)) } return reply.Value, nil } }
func (stack *Stack) Len() int { list := (*list.List)(stack) return list.Len() }