小编Ste*_*ook的帖子

我正在尝试从Golang日志包转换到Logrus.我的问题是如何自定义记录消息的时间戳格式.默认是自开始以来的秒数计数器,但我想要一个"2016-03-24 17:10:15"格式.我的简单测试代码是:

package main

import (
        "github.com/Sirupsen/logrus"
)

func main() {
        customFormatter := new(logrus.TextFormatter)
        customFormatter.TimestampFormat = "2006-01-02 15:04:05"
        logrus.SetFormatter(customFormatter)
        logrus.Info("Hello Walrus")
}

这编译并运行正常,但时间戳格式保持不变.任何人都可以提供一些有关它不工作原因的见解吗？

谢谢

我正在尝试学习Golang并拥有Python背景知识.我目前正试图了解如何将变量打包成二进制格式(带校验和).在Python中我会使用类似的东西:

import struct
import hashlib

a = 100
b = "foo\x00\x00"  # Padded to fixed length
packet = struct.pack('<B5s', a, b)
digest = hashlib.sha256(packet).digest()
packet += digest

要在Go中执行相同的操作,我正在尝试这样的代码:

package main

import (
    "crypto/sha256"
    "fmt"
    "encoding/binary"
    "bytes"
)

type packet struct {
    a uint8
    b string
}

func main() {
    var p = packet{}
    p.a = 1
    p.b = "foo\x00\x00"
    buf := new(bytes.Buffer)
    binary.Write(buf, binary.LittleEndian, &p)
    h := sha256.New()
    h.Write(buf.String())
    fmt.Printf("% x\n", p)
}

不幸的是,然而我攻击它似乎陷入了冲突变量类型(缓冲区,字节数组和字符串)的噩梦.我很欣赏一些指导,即我是否采取了正确的方法.

我试图了解实现Python的ConfigParser的最佳方法，以便多个程序模块都可以访问元素。我正在使用：-

import ConfigParser
import os.path

config = ConfigParser.RawConfigParser()

config.add_section('paths')
homedir = os.path.expanduser('~')
config.set('paths', 'user', os.path.join(homedir, 'users'))
[snip]
config.read(configfile)

在最后一行引用了configfile变量。这必须传递到Config模块，以便用户可以覆盖默认配置文件。我应该如何以其他模块可以使用config.get（spam，eggs）的方式在模块/类中实现此功能？

我正在尝试从存储在字节数组中的模数和指数创建RSA公钥.经过一些实验,我得到了以下内容:

func bytes_to_int(b []byte) (acc uint64) {
  length := len(b)
  if length % 4 != 0 {
    extra := (4 - length % 4)
    b = append([]byte(strings.Repeat("\000", extra)), b...)
    length += extra
  }
  var block uint32
  for i := 0; i < length; i += 4 {
    block = binary.BigEndian.Uint32(b[i:i+4])
    acc = (acc << 32) + uint64(block)
  }
return
}

func main() {
  fmt.Println(bytes_to_int(data[:128]))
  fmt.Println(bytes_to_int(data[128:]))
}

这似乎有效(虽然我不相信没有更好的方法).我的下一步是将其转换为使用math/big来处理更大的数字.我可以看到一个Lsh函数来执行<<但无法弄清楚如何以递归方式将Uint32(块)添加到big.Int.

作为参考,我试图导入的公钥是存储在密钥环中的Mixmaster密钥(pubring.mix):http: //www.mixmin.net/draft-sassaman-mixmaster-XX.html#key-format http ://pinger.mixmin.net/pubring.mix

我正在尝试使用golang编写数据包协议.由于协议将具有固定长度,因此分配精确的内存量似乎是一个很好的起点.例如

packet := make([]byte, 1024)

我不明白的是如何填充该数据包的特定元素.我想说的是: -

slice = pointer(packet[512])
slice = []byte("abcdef")

结果是数据包[512:518] == [] byte("abcdef").我在Arrays和Slices上阅读的文档展示了如何修改切片中的单个字节,而不是连续的字节序列.有没有办法做到这一点？

我正在尝试在 Go 中实现一个字符串 shuffle 函数，它使用 crypto/rand 而不是 math/rand。在费雪耶茨洗牌需要随机整数，所以我一直在努力，实现该功能，而无需使用密码/兰特诠释依赖于数学/大。以下是迄今为止我想出的最好的方法，但有更好的方法吗？我找不到现有示例的事实让我想知道为什么没有人这样做是有充分理由的！

package main

import "crypto/rand"
import "fmt"
import "encoding/binary"

func randomInt(max int) int {
    var n uint16
    binary.Read(rand.Reader, binary.LittleEndian, &n)
    return int(n) % max
}

func shuffle(s *[]string) {
        slice := *s
        for i := range slice {
                j := randomInt(i + 1)
                slice[i], slice[j] = slice[j], slice[i]
        }
        *s = slice
    }

func main() {
        slice := []string{"a", "b", "c", "d", "e", "f", "h", "i", "j", …

我在Go中编写了一个客户端应用程序,需要与服务器端的C程序进行交互.客户端执行AES CFB加密,服务器解密.不幸的是,服务器端有一个重用初始化向量的错误.它尝试根据以下内容执行3次解密操作: -
key1,iv
key2,iv
key3,iv

由于这个问题,iv实际上在解密操作之间被修改.我现在的问题是如何使用Go在客户端重现此行为.

通过将Println插入下面的加密函数,我可以看到cfb结构,我认为它包含下一个块的修改后的IV,但因为它是一个流接口,我不知道如何将它提取到字节切片中.有什么建议？

谢谢

package main

import (
  "fmt"
  "encoding/hex"
  "crypto/cipher"
  "crypto/aes"
)

func encrypt_aes_cfb(plain, key, iv []byte) (encrypted []byte) {
  block, err := aes.NewCipher(key)
  if err != nil {
    panic(err)
  }
  encrypted = make([]byte, len(plain))
  stream := cipher.NewCFBEncrypter(block, iv)
  stream.XORKeyStream(encrypted, plain)
  fmt.Println(stream)
  return
}

func main() {
  plain := []byte("Hello world...16Hello world...32")
  key := make([]byte, 32)
  iv := make([]byte, 16)
  enc := encrypt_aes_cfb(plain, key, iv)
  fmt.Println("Key: ", hex.EncodeToString(key))
  fmt.Println("IV:  ", hex.EncodeToString(iv))
  fmt.Println("Enc: …

我有许多Ansible角色，它们通知处理程序重新启动或重新加载systemd服务。如果通知了重新启动，则显然不需要重新加载同一服务，并且尝试同时执行这两项操作都可能导致失败，因为重新启动后重新加载的速度太快了。有没有一种方法可以配置处理程序，以便重新加载任务仅在未运行重新启动任务时才触发？

以下是我当前的重启/重载处理程序的示例。

- name: Restart foo service
  systemd:
    name: foo
    daemon_reload: yes
    state: restarted
  become: yes

- name: Reload foo service
  systemd:
    name: foo
    daemon_reload: yes
    state: reloaded
  become: yes

作为 Unix 系统管理员，我们在与其他人（例如 DBA）通过交互运行脚本启动/停止服务时遇到问题。这意味着 systemd 不知道服务的状态。为了防止这种情况，我在脚本中插入一个条件，如下所示：

# The systemd unit creates a ORACLE_SYSTEMD_UNIT environment variable.  If this
# isn't set (i.e. Not running through systemd) then abort.
if [ "${ORACLE_SYSTEMD_UNIT:+set}" == "" ]; then
    logmsg "Not initiated through systemd.  Aborting"
    exit 2
fi

任何人都可以建议一种更清洁的方法，或者可能是由 systemd 单元激活自动设置的环境变量？