func xmlToSocketLogWriter(filename string, props []xmlProperty, enabled bool) (SocketLogWriter, bool) { endpoint := "" protocol := "udp" for _, prop := range props { switch prop.Name { case "endpoint": endpoint = strings.Trim(prop.Value, " \r\n") case "protocol": protocol = strings.Trim(prop.Value, " \r\n") default: fmt.Fprintf(os.Stderr, "LoadConfiguration: Warning: Unknown property \"%s\" for file filter in %s\n", prop.Name, filename) } } if len(endpoint) == 0 { fmt.Fprintf(os.Stderr, "LoadConfiguration: Error: Required property \"%s\" for file filter missing in %s\n", "endpoint", filename) return nil, false } if !enabled { return nil, true } return NewSocketLogWriter(protocol, endpoint), true }
func (p *Problem) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error { pp := struct { Id string `xml:"id"` Name string `xml:"name"` Available string `xml:"available"` ProblemTimeLimit string `xml:"problemtimelimit"` ProblemMemoryLimit string `xml:"problemmemorylimit"` Status Status `xml:"status"` SolvedList []SolvedUser `xml:"solved_list>user"` }{} if err := d.DecodeElement(&pp, &start); err != nil { return err } available, err := strconv.Atoi(strings.Trim(pp.Available, "\n")) problemTimeLimit, err := strconv.Atoi(strings.Trim(pp.ProblemTimeLimit, "\n")) problemMemoryLimit, err := strconv.Atoi(strings.Trim(pp.ProblemMemoryLimit, "\n")) if err != nil { return err } *p = Problem{ Id: strings.Trim(pp.Id, "\n"), Name: strings.Trim(pp.Name, "\n"), Available: available, ProblemTimeLimit: problemTimeLimit, ProblemMemoryLimit: problemMemoryLimit, Status: pp.Status, SolvedList: pp.SolvedList, } return nil }
func cleanRawValue(s string) string { s = strings.Trim(s, " \t\n\r") if len(s) == 0 { return "" } inString := false escape := false for i := 0; i < len(s); i++ { c := s[i] if escape { escape = false continue } if c == '"' { inString = !inString continue } if inString && c == '\\' { escape = true continue } if c == '#' && !inString { return strings.Trim(s[0:i], " \t\n\r") } } return s }
func (b *buildFile) Build(context io.Reader) (string, error) { // FIXME: @creack "name" is a terrible variable name name, err := ioutil.TempDir("", "docker-build") if err != nil { return "", err } if err := Untar(context, name); err != nil { return "", err } defer os.RemoveAll(name) b.context = name filename := path.Join(name, "Dockerfile") if _, err := os.Stat(filename); os.IsNotExist(err) { return "", fmt.Errorf("Can't build a directory with no Dockerfile") } fileBytes, err := ioutil.ReadFile(filename) if err != nil { return "", err } dockerfile := string(fileBytes) dockerfile = lineContinuation.ReplaceAllString(dockerfile, "") stepN := 0 for _, line := range strings.Split(dockerfile, "\n") { line = strings.Trim(strings.Replace(line, "\t", " ", -1), " \t\r\n") // Skip comments and empty line if len(line) == 0 || line[0] == '#' { continue } tmp := strings.SplitN(line, " ", 2) if len(tmp) != 2 { return "", fmt.Errorf("Invalid Dockerfile format") } instruction := strings.ToLower(strings.Trim(tmp[0], " ")) arguments := strings.Trim(tmp[1], " ") method, exists := reflect.TypeOf(b).MethodByName("Cmd" + strings.ToUpper(instruction[:1]) + strings.ToLower(instruction[1:])) if !exists { fmt.Fprintf(b.out, "# Skipping unknown instruction %s\n", strings.ToUpper(instruction)) continue } stepN += 1 fmt.Fprintf(b.out, "Step %d : %s %s\n", stepN, strings.ToUpper(instruction), arguments) ret := method.Func.Call([]reflect.Value{reflect.ValueOf(b), reflect.ValueOf(arguments)})[0].Interface() if ret != nil { return "", ret.(error) } fmt.Fprintf(b.out, " ---> %v\n", utils.TruncateID(b.image)) } if b.image != "" { fmt.Fprintf(b.out, "Successfully built %s\n", utils.TruncateID(b.image)) if b.rm { b.clearTmp(b.tmpContainers) } return b.image, nil } return "", fmt.Errorf("An error occurred during the build\n") }
func (p linux) findRootDevicePath() (string, error) { mounts, err := p.diskManager.GetMountsSearcher().SearchMounts() if err != nil { return "", bosherr.WrapError(err, "Searching mounts") } for _, mount := range mounts { if mount.MountPoint == "/" && strings.HasPrefix(mount.PartitionPath, "/dev/") { p.logger.Debug(logTag, "Found root partition: `%s'", mount.PartitionPath) stdout, _, _, err := p.cmdRunner.RunCommand("readlink", "-f", mount.PartitionPath) if err != nil { return "", bosherr.WrapError(err, "Shelling out to readlink") } rootPartition := strings.Trim(stdout, "\n") p.logger.Debug(logTag, "Symlink is: `%s'", rootPartition) validRootPartition := regexp.MustCompile(`^/dev/[a-z]+1$`) if !validRootPartition.MatchString(rootPartition) { return "", bosherr.Error("Root partition is not the first partition") } return strings.Trim(rootPartition, "1"), nil } } return "", bosherr.Error("Getting root partition device") }
// as per http://www.mssqltips.com/sqlservertip/2563/understanding-the-sql-server-select-version-command/ func serverVersion(db *sql.DB) (sqlVersion, sqlPartNumber, osVersion string, err error) { var v string if err = db.QueryRow("select @@version").Scan(&v); err != nil { return "", "", "", err } a := strings.SplitN(v, "\n", -1) if len(a) < 4 { return "", "", "", errors.New("SQL Server version string must have at least 4 lines: " + v) } for i := range a { a[i] = strings.Trim(a[i], " \t") } l1 := strings.SplitN(a[0], "-", -1) if len(l1) != 2 { return "", "", "", errors.New("SQL Server version first line must have - in it: " + v) } i := strings.Index(a[3], " on ") if i < 0 { return "", "", "", errors.New("SQL Server version fourth line must have 'on' in it: " + v) } sqlVersion = l1[0] + a[3][:i] osVersion = a[3][i+4:] sqlPartNumber = strings.Trim(l1[1], " ") l12 := strings.SplitN(sqlPartNumber, " ", -1) if len(l12) < 2 { return "", "", "", errors.New("SQL Server version first line must have space after part number in it: " + v) } sqlPartNumber = l12[0] return sqlVersion, sqlPartNumber, osVersion, nil }
func parsePortRange(ports string) (uint16, uint16, error) { segments := strings.Split(ports, "-") fromPortStr := "" toPortStr := "" if len(segments) == 1 { fromPortStr = segments[0] toPortStr = fromPortStr } else if len(segments) == 2 { fromPortStr = segments[0] toPortStr = segments[1] } fromPort, err := strconv.Atoi(strings.Trim(fromPortStr, " ")) if err != nil { return 0, 0, err } toPort, err := strconv.Atoi(strings.Trim(toPortStr, " ")) if err != nil { return 0, 0, err } return uint16(fromPort), uint16(toPort), nil }
//initial the configure by .properties file. func (f *Fcfg) InitWithReader(reader *bufio.Reader) error { for { //read one line bys, err := ReadLine(reader, 10000, false) if err != nil { break } // line := string(bys) line = strings.Trim(line, " ") if len(line) < 1 { continue } ps := strings.Split(line, "#") if len(ps) < 1 || len(ps[0]) < 1 { continue } line = ps[0] ps = strings.SplitN(line, "=", 2) if len(ps) < 2 { fmt.Println(os.Stderr, "found not value key:", ps[0]) continue } key := f.EnvReplace(strings.Trim(ps[0], " ")) val := f.EnvReplace(strings.Trim(ps[1], " ")) (*f)[key] = val } return nil }
//连接服务器 func connectServer() { //接通 conn, err := net.Dial("tcp", "localhost:7777") checkError(err) fmt.Println("连接成功!\n") //输入 inputReader := bufio.NewReader(os.Stdin) fmt.Println("你是谁?") name, _ := inputReader.ReadString('\n') // trimName := strings.Trim(name, "\r\n") conn.Write([]byte(trimName + " 接入了\n ")) fmt.Println("我们来聊天吧!按quit退出") for { //读一行 input, _ := inputReader.ReadString('\n') trimInput := strings.Trim(input, "\r\n") //如果quit就退出 if trimInput == "quit" { fmt.Println("再见") conn.Write([]byte(trimName + " 退出了 ")) return } //写出来 _, err = conn.Write([]byte(trimName + " says: " + trimInput)) go doServerStuff(conn) } }
func (s systemctl) parseStatus(sData string, err error) (Status, error) { var st Status lines := strings.Split(sData, "\n") if err != nil { errString := err.Error() idx := strings.LastIndex(errString, " ") exitCode, _ := strconv.Atoi(errString[idx+1 : len(errString)]) // SystemD status is 3 when service is stopped or does not exists if exitCode != 3 { return st, err } for _, line := range lines { line = strings.Trim(line, " ") // When services does not exists then "Loaded" contains "not-found" if strings.HasPrefix(line, "Loaded") && strings.Contains(line, "not-found") { return st, err } } } for _, line := range lines { line = strings.Trim(line, " ") if strings.HasPrefix(line, "Active") { st.Running = strings.Contains(line, "active (running)") if !st.Running { break } } else if strings.HasPrefix(line, "Main PID") { pid := line[10:len(line)] idx := strings.Index(pid, " ") pid = pid[0:idx] st.PID, _ = strconv.Atoi(pid) } } return st, nil }
// https://www.hackerrank.com/challenges/angry-professor func angryprof() { t, reader := readFirstIntLine() for i := 0; i < t; i++ { // Read in N and K line, _ := reader.ReadString('\n') row := strings.Split(strings.Trim(line, "\n"), " ") strconv.Atoi(row[0]) k, _ := strconv.Atoi(row[1]) // Read in the students line, _ = reader.ReadString('\n') var nArrived int for _, s := range splitInt(strings.Trim(line, "\n")) { if s <= 0 { nArrived++ } } if nArrived >= k { fmt.Println("NO") } else { fmt.Println("YES") } } }
// Chain performs all the child derivations necessary to end up with the key // described with BIP32 notations, eg. m/44'/0'/1'/0/3. func (k *Key) Chain(chain string) (*Key, error) { low := strings.ToLower(chain) splits := strings.Split(low, "/") m := strings.Trim(splits[0], " ") if m == "m" { if k.depth != 0 { return nil, fmt.Errorf("Origin key isn't a master.") } if len(splits) == 1 { return k, nil } splits = splits[1:] } key := k for i, s := range splits { t := strings.Trim(s, " ") var harden uint32 end := t[len(t)-1] if end == 'h' || end == '\'' { harden = 0x80000000 t = t[:len(t)-1] } u, err := strconv.ParseUint(strings.Trim(t, " "), 10, 32) if err != nil { return nil, fmt.Errorf("Couldn't parse number at position %d (%s): %v", i, t, err) } key, err = key.Child(uint32(u) + harden) if err != nil { return nil, fmt.Errorf("Couldn't derive child #%d (%s): %v", i, s, err) } } return key, nil }
func (d *pgDataStore) addCertWithTx(tx *pgx.Tx, c *router.Certificate) error { c.Cert = strings.Trim(c.Cert, " \n") c.Key = strings.Trim(c.Key, " \n") if _, err := tls.X509KeyPair([]byte(c.Cert), []byte(c.Key)); err != nil { return httphelper.JSONError{ Code: httphelper.ValidationErrorCode, Message: "Certificate invalid: " + err.Error(), } } tlsCertSHA256 := sha256.Sum256([]byte(c.Cert)) if err := tx.QueryRow("select_certificate_by_sha", tlsCertSHA256[:]).Scan(&c.ID, &c.CreatedAt, &c.UpdatedAt); err != nil { if err := tx.QueryRow("insert_certificate", c.Cert, c.Key, tlsCertSHA256[:]).Scan(&c.ID, &c.CreatedAt, &c.UpdatedAt); err != nil { return err } } for _, rid := range c.Routes { if _, err := tx.Exec("delete_route_certificate_by_route_id", rid); err != nil { return err } if _, err := tx.Exec("insert_route_certificate", rid, c.ID); err != nil { return err } } return nil }
func InspectJson(ins []string) (out []string) { var re []string for _, in := range ins { if JsonPart != "" { in = JsonPart + in } in = strings.Trim(strings.TrimSpace(in), " ,") charopen := 0 charclose := 0 for i, r := range in { c := string(r) if c == "{" { charopen += 1 } else if c == "}" { charclose += 1 } if charopen == charclose && (charclose != 0 && charopen != 0) { if len(in) == i+1 { JsonPart = "" } else { JsonPart = in[i+1:] } re = append(re, strings.Trim(strings.TrimSpace(in[:i+1]), " ,")) break } if charopen != charclose || (charclose == 0 && charopen == 0) { JsonPart = in } } } return re }
func SMSHandler(w http.ResponseWriter, r *http.Request) { sms := r.URL.Query().Get("Body") sms = strings.Trim(sms, "8575-2838") if sms == "" { log.Println("Blank body.") SendSMS(w, r, "Please send a text with: \"Name\" \"email@address\"") return } info := strings.Fields(sms) name := strings.Join(info[:len(info)-1], " ") email := info[len(info)-1] name = strings.Trim(name, "\"") if name == "" { log.Println("Blank name.") SendSMS(w, r, "Please send a text with: \"Name\" \"email@address\"") return } email = strings.Trim(email, "\"") address := fmt.Sprintf("%s <%s>", name, email) _, err := mail.ParseAddress(address) if err != nil { SendSMS(w, r, "Please try again with a valid email address.") return } signup := Signup{Name: name, Email: email, Raw: sms, Timestamp: time.Now()} log.Println(signup) c := mgoSession.DB("sms_signup").C("signups") err = c.Insert(signup) if err != nil { log.Println(err.Error()) } SendSMS(w, r, fmt.Sprintf("Thanks for signing up, %s!", info[0])) }
func decodeCustomValues(incoming reflect.Value, incomingField reflect.StructField, data string) error { /* Incoming is a slice */ underlyingType := incoming.Type().Elem() var delim = " " if it := incomingField.Tag.Get("delim"); it != "" { delim = it } var strip = "" if it := incomingField.Tag.Get("strip"); it != "" { strip = it } if strip != "" { data = strings.Trim(data, strip) } for _, el := range strings.Split(data, delim) { if strip != "" { el = strings.Trim(el, strip) } targetValue := reflect.New(underlyingType) err := decodeValue(targetValue.Elem(), incomingField, el) if err != nil { return err } incoming.Set(reflect.Append(incoming, targetValue.Elem())) } return nil }
func normalizeFlags(flags []Flag, set *flag.FlagSet) error { visited := make(map[string]bool) set.Visit(func(f *flag.Flag) { visited[f.Name] = true }) for _, f := range flags { parts := strings.Split(f.getName(), ",") if len(parts) == 1 { continue } var ff *flag.Flag for _, name := range parts { name = strings.Trim(name, " ") if visited[name] { if ff != nil { return errors.New("Cannot use two forms of the same flag: " + name + " " + ff.Name) } ff = set.Lookup(name) } } if ff == nil { continue } for _, name := range parts { name = strings.Trim(name, " ") if !visited[name] { copyFlag(name, ff, set) } } } return nil }
// parseTags parses all individual tags found within a struct tag. func (mv *Validator) parseTags(t string) ([]tag, error) { r := csv.NewReader(strings.NewReader(t)) records, err := r.ReadAll() if err != nil || len(records) != 1 { return []tag{}, ErrUnknownTag } tl := records[0] tags := make([]tag, 0, len(tl)) for _, i := range tl { tg := tag{} v := strings.SplitN(i, "=", 2) tg.Name = strings.Trim(v[0], " ") if tg.Name == "" { return []tag{}, ErrUnknownTag } if len(v) > 1 { tg.Param = strings.Trim(v[1], " ") } var found bool if tg.Fn, found = mv.validationFuncs[tg.Name]; !found { return []tag{}, ErrUnknownTag } tags = append(tags, tg) } return tags, nil }
// AreTimeStampsEqual checks whether the TIMESTAMP in the local dir matches the // TIMESTAMP in the remote Google Storage dir. func (gs *GsUtil) AreTimeStampsEqual(localDir, gsDir string) (bool, error) { // Get timestamp from the local directory. localTimestampPath := filepath.Join(localDir, TIMESTAMP_FILE_NAME) fileContent, err := ioutil.ReadFile(localTimestampPath) if err != nil { return false, fmt.Errorf("Could not read %s: %s", localTimestampPath, err) } localTimestamp := strings.Trim(string(fileContent), "\n") // Get timestamp from the Google Storage directory. gsTimestampPath := filepath.Join(gsDir, TIMESTAMP_FILE_NAME) respBody, err := gs.GetRemoteFileContents(gsTimestampPath) if err != nil { return false, err } defer util.Close(respBody) resp, err := ioutil.ReadAll(respBody) if err != nil { return false, err } gsTimestamp := strings.Trim(string(resp), "\n") // Return the comparison of the two timestamps. return localTimestamp == gsTimestamp, nil }
// Takes a string and tokenizes it func GetFlatTokenList(text string) []Token { var tokens []Token remaining_text := strings.Trim(text, " \n\t\r\u000a") last_iteration_text := remaining_text for len(remaining_text) > 0 { for pattern, converter := range SOURCE_PATTERNS { match := pattern.FindIndex([]byte(remaining_text)) if match == nil || match[0] != 0 { continue } token := converter(remaining_text[match[0]:match[1]]) // fmt.Println("appended ", token) tokens = append(tokens, token) // cut out the regex match remaining_text = remaining_text[match[1]:] break } // println(remaining_text == "\u000a") if last_iteration_text == remaining_text { panic("loool... we couldn't find any match for the text") } last_iteration_text = strings.Trim(remaining_text, " \n\t\r\u000a") } return tokens }
func UpdateInvertebrate(invertebrate *entity.Invertebrate, db *sql.DB, invertebrate_id string) (sql.Result, error) { defer recoverDbPanic() stmt := getStatement("invertebrate_update", INVERTEBRATE_UPDATE_QUERY, db) if stmt == nil { return nil, errors.New("Query could not be created.") } res, err := stmt.Exec( strings.Trim(invertebrate.Name, " \t"), strings.Trim(invertebrate.Family, " \t"), invertebrate.MaxLength, invertebrate.WaterConditions.Ph.Min.V, invertebrate.WaterConditions.Ph.Max.V, invertebrate.WaterConditions.Temperature.Min.V, invertebrate.WaterConditions.Temperature.Max.V, invertebrate.WaterConditions.TotalHardness.Min.V, invertebrate.WaterConditions.TotalHardness.Max.V, invertebrate.WaterConditions.CarbonateHardness.Min.V, invertebrate.WaterConditions.CarbonateHardness.Max.V, invertebrate.WaterType, invertebrate_id, ) return res, err }
func parseTrendingRepos(doc *goquery.Document) []GithubRepo { var repos []GithubRepo var regStars = regexp.MustCompile("[0-9]+") doc.Find("li.repo-list-item").Each(func(i int, s *goquery.Selection) { title := strings.Trim(s.Find("h3.repo-list-name a").Text(), "\n\t ") title = strings.Replace(title, " ", "", -1) title = strings.Replace(title, "\n", "", -1) description := strings.Trim(s.Find("p.repo-list-description").Text(), "\n\t ") url, _ := s.Find("h3.repo-list-name a").Attr("href") url = "https://github.com" + url starsString := s.Find("p.repo-list-meta").Text() starsString = strings.Replace(starsString, ",", "", -1) starsString = regStars.FindString(starsString) if starsString == "" { starsString = "0" } stars, _ := strconv.Atoi(starsString) repo := GithubRepo{ Title: title, Description: description, Url: url, Stars: stars, Forks: 0, Date: time.Now().UTC().Unix(), } repos = append(repos, repo) }) return repos }
func GetStudent(d *goquery.Document, rollno int) (s Student, ok bool) { //sanity on document // if v := d.Find(".titlehead").Children().Text(); v != "JEE (Advanced) - 2013 Result" { // return Student{}, false // } dtext := strings.Trim(d.Text(), " ") dfields := strings.Fields(dtext) for _, v := range dfields { s.Plaintext += v + " " } s.Plaintext = strings.Trim(s.Plaintext, " ") if isInvalid(dtext) { return s, false } ok = true s.Rollno = rollno s.Region = s.Rollno / 10000 if !isSelected(dtext) { return } s.Selected = true s.Rank, _ = strconv.Atoi(d.Find(".style7").First().Text()) text, _ := d.Find(".titlehead").First().Parent().Next().Children().Children().First().Html() tokens := strings.Split(text, "<br/>") nameToks := strings.Fields(tokens[1]) nameToks = nameToks[2:len(nameToks)] for _, v := range nameToks { s.Name += v + " " } s.Name = strings.Trim(s.Name, " ") s.Q = GetQuota(dtext) return }
func TestModeHostname(t *testing.T) { cmd := exec.Command(dockerBinary, "run", "-h=testhostname", "busybox", "cat", "/etc/hostname") out, _, err := runCommandWithOutput(cmd) if err != nil { t.Fatal(err, out) } if actual := strings.Trim(out, "\r\n"); actual != "testhostname" { t.Fatalf("expected 'testhostname', but says: '%s'", actual) } cmd = exec.Command(dockerBinary, "run", "--net=host", "busybox", "cat", "/etc/hostname") out, _, err = runCommandWithOutput(cmd) if err != nil { t.Fatal(err, out) } hostname, err := os.Hostname() if err != nil { t.Fatal(err) } if actual := strings.Trim(out, "\r\n"); actual != hostname { t.Fatalf("expected '%s', but says: '%s'", hostname, actual) } deleteAllContainers() logDone("run - hostname and several network modes") }
func parseValidatorTags(tag string) ([]validatorTag, error) { if tag == "" { return nil, nil } lst := strings.Split(tag, ",") if len(lst) == 0 { return nil, nil } tags := make([]validatorTag, 0, len(lst)) for _, cfg := range lst { v := strings.SplitN(cfg, "=", 2) name := strings.Trim(v[0], " \t\r\n") cb := validators[name] if cb == nil { return nil, fmt.Errorf("unknown validator '%v'", name) } param := "" if len(v) == 2 { param = strings.Trim(v[1], " \t\r\n") } tags = append(tags, validatorTag{name: name, cb: cb, param: param}) } return tags, nil }
func TestDnsOptions(t *testing.T) { cmd := exec.Command(dockerBinary, "run", "--dns=127.0.0.1", "--dns-search=mydomain", "busybox", "cat", "/etc/resolv.conf") out, _, err := runCommandWithOutput(cmd) if err != nil { t.Fatal(err, out) } actual := strings.Replace(strings.Trim(out, "\r\n"), "\n", " ", -1) if actual != "nameserver 127.0.0.1 search mydomain" { t.Fatalf("expected 'nameserver 127.0.0.1 search mydomain', but says: '%s'", actual) } cmd = exec.Command(dockerBinary, "run", "--dns=127.0.0.1", "--dns-search=.", "busybox", "cat", "/etc/resolv.conf") out, _, err = runCommandWithOutput(cmd) if err != nil { t.Fatal(err, out) } actual = strings.Replace(strings.Trim(strings.Trim(out, "\r\n"), " "), "\n", " ", -1) if actual != "nameserver 127.0.0.1" { t.Fatalf("expected 'nameserver 127.0.0.1', but says: '%s'", actual) } logDone("run - dns options") }
func drawsOk(t *testing.T, msg string, n tree.Node, s string) { got := strings.Trim(n.Draw(), "\n") want := strings.Trim(trim.ReplaceAllString(s, ""), "\n") if got != want { t.Errorf("%s failed\nexpected:\n[%s]\ngot:\n[%s]\n", msg, want, got) } }
func (this *cleaner) cleanDivs(doc *goquery.Document) *goquery.Document { frames := make(map[string]int) framesNodes := make(map[string]*list.List) divs := doc.Find("div") divs.Each(func(i int, s *goquery.Selection) { children := s.Children() if children.Size() == 0 { text := s.Text() text = strings.Trim(text, " ") text = strings.Trim(text, "\t") text = strings.ToLower(text) frames[text]++ if framesNodes[text] == nil { framesNodes[text] = list.New() } framesNodes[text].PushBack(s) } }) for text, freq := range frames { if freq > 1 { selections := framesNodes[text] for s := selections.Front(); s != nil; s = s.Next() { selection := s.Value.(*goquery.Selection) this.config.parser.removeNode(selection) } } } return doc }
// TestRunDeviceSymlink checks run with device that follows symlink (#13840) func (s *DockerSuite) TestRunDeviceSymlink(c *check.C) { testRequires(c, DaemonIsLinux, NotUserNamespace, NotArm, SameHostDaemon) if _, err := os.Stat("/dev/zero"); err != nil { c.Skip("Host does not have /dev/zero") } // Create a temporary directory to create symlink tmpDir, err := ioutil.TempDir("", "docker_device_follow_symlink_tests") c.Assert(err, checker.IsNil) defer os.RemoveAll(tmpDir) // Create a symbolic link to /dev/zero symZero := filepath.Join(tmpDir, "zero") err = os.Symlink("/dev/zero", symZero) c.Assert(err, checker.IsNil) // Create a temporary file "temp" inside tmpDir, write some data to "tmpDir/temp", // then create a symlink "tmpDir/file" to the temporary file "tmpDir/temp". tmpFile := filepath.Join(tmpDir, "temp") err = ioutil.WriteFile(tmpFile, []byte("temp"), 0666) c.Assert(err, checker.IsNil) symFile := filepath.Join(tmpDir, "file") err = os.Symlink(tmpFile, symFile) c.Assert(err, checker.IsNil) // md5sum of 'dd if=/dev/zero bs=4K count=8' is bb7df04e1b0a2570657527a7e108ae23 out, _ := dockerCmd(c, "run", "--device", symZero+":/dev/symzero", "busybox", "sh", "-c", "dd if=/dev/symzero bs=4K count=8 | md5sum") c.Assert(strings.Trim(out, "\r\n"), checker.Contains, "bb7df04e1b0a2570657527a7e108ae23", check.Commentf("expected output bb7df04e1b0a2570657527a7e108ae23")) // symlink "tmpDir/file" to a file "tmpDir/temp" will result in an error as it is not a device. out, _, err = dockerCmdWithError("run", "--device", symFile+":/dev/symzero", "busybox", "sh", "-c", "dd if=/dev/symzero bs=4K count=8 | md5sum") c.Assert(err, check.NotNil) c.Assert(strings.Trim(out, "\r\n"), checker.Contains, "not a device node", check.Commentf("expected output 'not a device node'")) }
func insert_new_user(user RegisteringUser) (int, []string) { db := connect_sql() defer db.Close() msg_err := make([]string, 10) ret := 0 // TODO : welcom mail to send if user_exist(user.InputMail) { msg_err[0] = "Email already used" ret = 1 } if !strings.Contains(user.InputMail, "@") { msg_err[1] = "Incorrect Email" ret = 1 } if user.InputPass != user.InputPassVerif { msg_err[2] = "Passwords don't match" ret = 1 } //TODO : min lenght not max if len(user.InputPseudo) > Pref.max_lenght_pseudo { msg_err[3] = "Passwords too short" ret = 1 } if ret == 0 { cleanpseudo := strings.Trim(strings.ToLower(user.InputPseudo), " ") cleanmail := strings.Trim(strings.ToLower(user.InputMail), " ") cleanpass := strings.Trim(user.InputPass, " ") _, err := db.Exec("INSERT INTO users (pseudo, mail, password) VALUES (?, ?, ?)", cleanpseudo, cleanmail, EncryptPass(cleanpass)) HandleErrorSql(err) } return ret, msg_err }