本文整理汇总了Golang中bytes.TrimRight函数的典型用法代码示例。如果您正苦于以下问题:Golang TrimRight函数的具体用法?Golang TrimRight怎么用?Golang TrimRight使用的例子?那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了TrimRight函数的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Golang代码示例。
示例1: parseIndex
func parseIndex(sql []byte) (indexName string, indexId interface{}, userId uint64) {
var err error
keyspaceIndex := bytes.Index(sql, KEYSPACE_ID_COMMENT)
if keyspaceIndex == -1 {
panic(NewBinlogParseError(fmt.Sprintf("Error parsing index comment, doesn't contain keyspace id %v", string(sql))))
}
keyspaceIdComment := sql[keyspaceIndex+len(KEYSPACE_ID_COMMENT):]
indexCommentStart := bytes.Index(keyspaceIdComment, INDEX_COMMENT)
if indexCommentStart != -1 {
indexCommentParts := bytes.SplitN(keyspaceIdComment[indexCommentStart:], COLON_BYTE, 2)
userId, err = strconv.ParseUint(string(bytes.SplitN(indexCommentParts[1], mysqlctl.SPACE, 2)[0]), 10, 64)
if err != nil {
panic(NewBinlogParseError(fmt.Sprintf("Error converting user_id %v", string(sql))))
}
indexNameId := bytes.Split(indexCommentParts[0], DOT_BYTE)
indexName = string(indexNameId[1])
if indexName == "username" {
indexId = string(bytes.TrimRight(indexNameId[2], COLON))
} else {
indexId, err = strconv.ParseUint(string(bytes.TrimRight(indexNameId[2], COLON)), 10, 64)
if err != nil {
panic(NewBinlogParseError(fmt.Sprintf("Error converting index id %v %v", string(bytes.TrimRight(indexNameId[2], COLON)), string(sql))))
}
}
}
return
}
示例2: ParseKey
// ParseKey reads the given RSA private key and create a public one for it.
func ParseKey(pem string) (*Key, error) {
p, err := ioutil.ReadFile(pem)
if err != nil {
return nil, err
}
key, err := ssh.ParseRawPrivateKey(p)
if err != nil {
return nil, err
}
rsaKey, ok := key.(*rsa.PrivateKey)
if !ok {
return nil, fmt.Errorf("%q is not a RSA key", pem)
}
pub, err := ssh.NewPublicKey(&rsaKey.PublicKey)
if err != nil {
return nil, err
}
// Compute key fingerprint.
var buf bytes.Buffer
for _, b := range md5.Sum(pub.Marshal()) {
fmt.Fprintf(&buf, "%0.2x:", b)
}
return &Key{
Label: strings.TrimSuffix(filepath.Base(pem), ".pem"), // trim .pem file extension
Key: string(bytes.TrimRight(ssh.MarshalAuthorizedKey(pub), "\n")), // trim newline
Fingerprint: string(bytes.TrimRight(buf.Bytes(), ":")), // trim dangling colon
Note: "{}",
Tags: make(Tags),
}, nil
}
示例3: DetectAtxHeader
func DetectAtxHeader(first, second Line, detectors Detectors) Handler {
if !bytes.HasPrefix(first.Bytes, []byte("#")) {
return nil
}
done := false
return HandlerFunc(func(line Line, ctx Context) (bool, error) {
if done {
return false, nil
}
done = true
block := md.AtxHeaderBlock{
Raw: md.Raw{md.Run(line)},
}
text := bytes.TrimRight(line.Bytes, "\n")
text = bytes.Trim(text, "#")
if len(text) > 0 {
block.Level, _ = mdutils.OffsetIn(line.Bytes, text)
} else {
block.Level = len(bytes.TrimRight(line.Bytes, "\n"))
}
if block.Level > 6 {
block.Level = 6
}
spanRegion := md.Raw{md.Run{
Line: line.Line,
Bytes: bytes.Trim(text, mdutils.Whites),
}}
ctx.Emit(block)
parseSpans(spanRegion, ctx)
ctx.Emit(md.End{})
return true, nil
})
}
示例4: readLine
func (p *parser) readLine() []byte {
if !p.linenoFixed {
p.lineno = p.elineno + 1
}
var line []byte
for !p.done {
buf, err := p.rd.ReadBytes('\n')
if !p.linenoFixed {
p.elineno++
}
if err == io.EOF {
p.done = true
} else if err != nil {
p.err = fmt.Errorf("readline %s: %v", p.srcpos(), err)
p.done = true
}
line = append(line, buf...)
buf = bytes.TrimRight(buf, "\r\n")
backslash := false
for len(buf) > 1 && buf[len(buf)-1] == '\\' {
buf = buf[:len(buf)-1]
backslash = !backslash
}
if !backslash {
break
}
}
line = bytes.TrimRight(line, "\r\n")
return line
}
示例5: main
func main() {
input_buffer := bufio.NewReader(os.Stdin)
fmt.Println("Type your settings from https://themis.cossacklabs.com/interactive-simulator/setup/")
fmt.Println("JSON endpoint: ")
endpoint, err := input_buffer.ReadString('\n')
endpoint = strings.TrimRight(endpoint, "\n\r")
fmt.Println("Your private key in base64 format:")
client_private, err := input_buffer.ReadBytes('\n')
client_private, err = base64.StdEncoding.DecodeString(string(client_private))
if err != nil {
fmt.Println("Incorrect base64 format for private key")
return
}
fmt.Println("Server public key in base64 format:")
server_public, err := input_buffer.ReadBytes('\n')
server_public = bytes.TrimRight(server_public, "\r\n")
server_public, err = base64.StdEncoding.DecodeString(string(server_public))
secure_message := message.New(
&keys.PrivateKey{bytes.TrimRight(client_private, "\r\n")},
&keys.PublicKey{server_public})
for {
fmt.Println("Print message to send (or quit to stop):")
line, _, err := input_buffer.ReadLine()
if err != nil {
fmt.Println(err)
return
}
if bytes.Equal(line, []byte("quit")) {
return
}
wrapped, err := secure_message.Wrap(line)
if err != nil {
fmt.Println("Error in wraping", err)
return
}
data, err := send_message(wrapped, endpoint)
if err != nil {
fmt.Println("Error occured:", err)
return
}
unwrapped, err := secure_message.Unwrap(data)
fmt.Println(string(unwrapped))
}
}
示例6: formatQuoted
func formatQuoted(text []byte) []byte {
if bytes.Equal(text, noOutputOld) {
return noOutputNew
}
nonZero := bytes.HasSuffix(text, nonZeroOld)
if nonZero {
text = text[:len(text)-len(nonZeroOld)]
}
var buf bytes.Buffer
buf.Grow(512)
fmt.Fprintf(&buf, "%q", text)
if buf.Len() > maxTextLen {
truncateMaxLen(&buf, 1)
buf.Truncate(len(bytes.TrimRight(buf.Bytes(), "\\")))
buf.WriteString(`" + `)
buf.WriteString(more)
}
if nonZero {
buf.WriteString(split)
buf.WriteString(nonZeroNew)
}
return buf.Bytes()
}
示例7: main
func main() {
flag.Parse()
if *show_key {
if flag.NArg() < 1 {
flag.Usage()
os.Exit(1)
}
for _, seed := range flag.Args() {
key, err := issh.GetAuthorizedKey(seed)
if err != nil {
panic("Failed to create a key: " + err.Error())
}
fmt.Printf("public key for \"%s\"\n"+
"command=\"exit 1\",no-port-forwarding,no-X11-forwarding,no-pty %s "+
"issh generated from seed: '%s'\n",
seed, bytes.TrimRight(key, "\r\n \t"), seed)
}
return
}
if flag.NArg() != 2 {
flag.Usage()
os.Exit(1)
}
user, host, port := parseUserHostPort(flag.Arg(1))
stdout, exitcode, err := issh.Run(user, host, port, flag.Arg(0))
if err != nil {
panic("Failed to execute remote command: " + err.Error())
}
os.Stdout.Write(stdout)
os.Exit(exitcode)
}
示例8: desDecode
func desDecode(b []byte) ([]byte, error) {
td, err := des.NewTripleDESCipher(deskey)
if err != nil {
logger.Println(err)
return nil, err
}
// blockMode := cipher.NewCBCDecrypter(block, key)
// orig := make([]byte, len(b))
// blockMode.CryptBlocks(orig, b)
// logger.Println(string(orig))
n := len(b) / td.BlockSize()
var rb []byte
for i := 0; i < n; i++ {
dst := make([]byte, td.BlockSize())
td.Decrypt(dst, b[i*8:(i+1)*8])
rb = append(rb, dst[:]...)
}
lastValue := int(rb[len(rb)-1])
logger.Println(string(rb[0 : len(rb)-lastValue]))
// 移除最后的0
return bytes.TrimRight(rb, string([]byte{0})), nil
}
示例9: TestPatterns
func (S) TestPatterns(c *C) {
const sep = " "
var input bytes.Buffer
key := genPublicKey(c)
keyBytes := bytes.TrimRight(bytes.TrimSpace(ssh.MarshalAuthorizedKey(key)), "\n")
// format: pattern
input.WriteString("*.example")
input.WriteString(sep)
input.Write(keyBytes)
input.WriteString("\n")
// format: negated pattern
input.WriteString("!*.example.or?")
input.WriteString(sep)
input.Write(keyBytes)
input.WriteString("\n")
k, err := Unmarshal(bytes.NewReader(input.Bytes()))
c.Assert(err, IsNil)
// Test HostKeyCallback
addr := &net.TCPAddr{
Port: 22,
}
c.Assert(k.HostKeyCallback("foo.example:22", addr, key), IsNil) // pattern match
c.Assert(k.HostKeyCallback("foo.example.org:22", addr, key), Equals, HostNotFoundError) // negated pattern match
c.Assert(k.HostKeyCallback("anything.example.com:22", addr, key), IsNil) // negated pattern miss
// Make sure output is the same as input
var output bytes.Buffer
c.Assert(k.Marshal(&output), IsNil)
c.Assert(output.String(), Equals, input.String())
}
示例10: read
// read reads events from an inotify file descriptor. It does not handle errors
// returned from read(2) function since they are not critical to watcher logic.
func (i *inotify) read() (es []*event) {
n, err := syscall.Read(int(i.fd), i.buffer[:])
if err != nil || n < syscall.SizeofInotifyEvent {
return
}
var sys *syscall.InotifyEvent
nmin := n - syscall.SizeofInotifyEvent
for pos, path := 0, ""; pos <= nmin; {
sys = (*syscall.InotifyEvent)(unsafe.Pointer(&i.buffer[pos]))
pos += syscall.SizeofInotifyEvent
if path = ""; sys.Len > 0 {
endpos := pos + int(sys.Len)
path = string(bytes.TrimRight(i.buffer[pos:endpos], "\x00"))
pos = endpos
}
es = append(es, &event{
sys: syscall.InotifyEvent{
Wd: sys.Wd,
Mask: sys.Mask,
Cookie: sys.Cookie,
},
path: path,
})
}
return
}
示例11: Processor
// Client processor blockingly reads everything remote client sends,
// splits messages by CRLF and send them to Daemon gorouting for processing
// it futher. Also it can signalize that client is unavailable (disconnected).
func (client *Client) Processor(sink chan<- ClientEvent) {
var bufNet []byte
buf := make([]byte, 0)
log.Println(client, "New client")
sink <- ClientEvent{client, EventNew, ""}
for {
bufNet = make([]byte, BufSize)
_, err := client.conn.Read(bufNet)
if err != nil {
sink <- ClientEvent{client, EventDel, ""}
break
}
bufNet = bytes.TrimRight(bufNet, "\x00")
buf = append(buf, bufNet...)
if !bytes.HasSuffix(buf, []byte(CRLF)) {
continue
}
for _, msg := range bytes.Split(buf[:len(buf)-2], []byte(CRLF)) {
if len(msg) > 0 {
sink <- ClientEvent{client, EventMsg, string(msg)}
}
}
buf = []byte{}
}
}
示例12: TestFlushOnClose
func TestFlushOnClose(t *testing.T) {
l, err := newUDPListener("127.0.0.1:0")
if err != nil {
t.Fatal(err)
}
defer l.Close()
c, err := NewBufferedClient(l.LocalAddr().String(), "test", 1*time.Second, 1024)
if err != nil {
t.Fatal(err)
}
c.Inc("count", int64(1), 1.0)
c.Close()
expected := "test.count:1|c"
data := make([]byte, 1024)
_, _, err = l.ReadFrom(data)
if err != nil {
t.Fatal(err)
}
data = bytes.TrimRight(data, "\x00")
if bytes.Equal(data, []byte(expected)) != true {
fmt.Println(data)
fmt.Println([]byte(expected))
t.Fatalf("got '%s' expected '%s'", data, expected)
}
}
示例13: downloadFile
func (peer Peer) downloadFile(file File, conn *net.TCPConn) {
if f, ok := status.status["local"].files[file.FileName]; ok {
if f.Chunks[file.Chunks[1]] == 1 {
return
}
} else {
chunks := make([]int, file.Chunks[0])
for chunk := range chunks {
chunks[chunk] = 0
}
chunks[file.Chunks[1]] = 1
status.status["local"].files[file.FileName] = File{
FileName: file.FileName,
Chunks: chunks,
}
}
status.status["local"].files[file.FileName].Chunks[file.Chunks[1]] = 1
incrementChunkReplication(file.FileName, file.Chunks[1], file.Chunks[0])
err := conn.SetReadBuffer(ChunkSize)
checkError(err)
readBuffer := make([]byte, ChunkSize)
_, err = conn.Read(readBuffer)
checkError(err)
conn.Close()
status.mu.Lock()
basepath := path.Dir(file.FileName)
fileName := path.Base(file.FileName)
err = os.MkdirAll(basepath, 0777)
checkError(err)
filePath := path.Join(basepath, fileName)
localFile, err := os.OpenFile(filePath, os.O_CREATE|os.O_RDWR, 0777)
if err != nil {
for {
localFile, err = os.OpenFile(filePath, os.O_CREATE|os.O_RDWR, 0777)
if err == nil {
break
}
}
}
writeOffset := int64(file.Chunks[1] * ChunkSize)
_, err = localFile.WriteAt(bytes.TrimRight(readBuffer, "\x00"), writeOffset)
checkError(err)
err = localFile.Close()
checkError(err)
status.mu.Unlock()
fmt.Printf("Downloaded file %s:%d \n\n", file.FileName, file.Chunks[1])
fileList := []File{file}
haveMessage := encodeMessage(peer.host, peer.port, Have, fileList)
sendToAll(haveMessage)
return
}
示例14: DetectSetextHeader
func DetectSetextHeader(first, second Line, detectors Detectors) Handler {
if second.EOF() {
return nil
}
if !reSetextHeader.Match(bytes.TrimRight(second.Bytes, "\n")) {
return nil
}
block := md.SetextHeaderBlock{}
switch second.Bytes[0] {
case '=':
block.Level = 1
case '-':
block.Level = 2
}
done := 0
return HandlerFunc(func(next Line, ctx Context) (bool, error) {
if done == 2 {
ctx.Emit(block)
parseSpans(trim(md.Raw{block.Raw[0]}), ctx)
ctx.Emit(md.End{})
return false, nil
}
done++
block.Raw = append(block.Raw, md.Run(next))
return true, nil
})
}
示例15: main
func main() {
flag.Parse()
if *fPeers == "" {
flagbad("-peers is empty\n")
}
if *fTopic == "" {
flagbad("-topic is empty\n")
}
kfk, err := kafka.New("kafka-producer", logger, strings.Split(*fPeers, ","))
if err != nil {
logger.Panicf("Failed to start kafka: %v", err)
}
defer kfk.Close()
br := bufio.NewReader(os.Stdin)
for {
line, err := br.ReadBytes('\n')
if err == io.EOF && len(line) == 0 {
break
}
if err != nil {
logger.Panicf("Reading from stdin: %v", err)
}
line = bytes.TrimRight(line, "\n")
part, offset, err := kfk.Send(nil, line, *fTopic)
if err != nil {
logger.Panicf("Sending message: %v", err)
}
if *fVerbose {
fmt.Printf("send (len=%d, part=%d, offset=%d)\n", len(line), part, offset)
}
}
}