func unpackMessage(message *messages.MessageEnvelope) proto.Message {
t := proto.MessageType(message.TypeName).Elem()
intPtr := reflect.New(t)
instance := intPtr.Interface().(proto.Message)
proto.Unmarshal(message.MessageData, instance)
return instance
}
func GetInstance(messageType string) (interface{}, error) {
mType := proto.MessageType(messageType).Elem()
if mType == nil {
return nil, errors.New("Unknown type: " + messageType)
}
return reflect.New(mType).Interface(), nil
}
func newMessage(name string) (proto.Message, error) {
reflectType := proto.MessageType(name)
if reflectType == nil {
return nil, fmt.Errorf("protolog: no Message registered for name: %s", name)
}
return reflect.New(reflectType.Elem()).Interface().(proto.Message), nil
}
func (s *serverReflectionServer) typeForName(name string) (reflect.Type, error) {
pt := proto.MessageType(name)
if pt == nil {
return nil, fmt.Errorf("unknown type: %q", name)
}
st := pt.Elem()
return st, nil
}
func messageTypeForPackage(pkg string, name string) (reflect.Type, error) {
switch pkg {
case "golang":
return golang.MessageType(name), nil
//case "gogo":
//return gogo.MessageType(name), nil
default:
return nil, fmt.Errorf("lion: unknown package: %s", pkg)
}
}
// Empty returns a new proto.Message of the type specified in a
// google.protobuf.Any message. It returns an error if corresponding message
// type isn't linked in.
func Empty(any *any.Any) (proto.Message, error) {
aname, err := AnyMessageName(any)
if err != nil {
return nil, err
}
t := proto.MessageType(aname)
if t == nil {
return nil, fmt.Errorf("any: message type %q isn't linked in", aname)
}
return reflect.New(t.Elem()).Interface().(proto.Message), nil
}
func (m *Marshaler) marshalAny(out *errWriter, any proto.Message, indent string) error {
// "If the Any contains a value that has a special JSON mapping,
// it will be converted as follows: {"@type": xxx, "value": yyy}.
// Otherwise, the value will be converted into a JSON object,
// and the "@type" field will be inserted to indicate the actual data type."
v := reflect.ValueOf(any).Elem()
turl := v.Field(0).String()
val := v.Field(1).Bytes()
// Only the part of type_url after the last slash is relevant.
mname := turl
if slash := strings.LastIndex(mname, "/"); slash >= 0 {
mname = mname[slash+1:]
}
mt := proto.MessageType(mname)
if mt == nil {
return fmt.Errorf("unknown message type %q", mname)
}
msg := reflect.New(mt.Elem()).Interface().(proto.Message)
if err := proto.Unmarshal(val, msg); err != nil {
return err
}
if _, ok := msg.(wkt); ok {
out.write("{")
if m.Indent != "" {
out.write("\n")
}
if err := m.marshalTypeURL(out, indent, turl); err != nil {
return err
}
m.writeSep(out)
if m.Indent != "" {
out.write(indent)
out.write(m.Indent)
out.write(`"value": `)
} else {
out.write(`"value":`)
}
if err := m.marshalObject(out, msg, indent+m.Indent, ""); err != nil {
return err
}
if m.Indent != "" {
out.write("\n")
out.write(indent)
}
out.write("}")
return out.err
}
return m.marshalObject(out, msg, indent, turl)
}
func (ev *Event) decode() error {
if nil != ev.Msg {
return nil
}
t := proto.MessageType(ev.GetMsgType())
if nil == t {
return fmt.Errorf("No msg type found for:%s", ev.GetMsgType())
}
msg := reflect.New(t.Elem()).Interface().(proto.Message)
pos := (ev.length & 0xFF) + 8
err := proto.Unmarshal(ev.raw[pos:], msg)
if nil != err {
return err
}
ev.Msg = msg
return nil
}
func main() {
flag.Parse()
if flag.NArg() == 0 {
flagutil.UsageError("Missing path to LevelDB")
}
var protoValueType reflect.Type
if *protoValue != "" {
protoValueType = proto.MessageType(*protoValue)
if protoValueType == nil {
flagutil.UsageErrorf("could not understand protocol buffer type: %q", *protoValue)
}
}
var en *json.Encoder
if *emitJSON {
en = json.NewEncoder(os.Stdout)
}
for _, path := range flag.Args() {
func() {
db, err := leveldb.Open(path, nil)
if err != nil {
log.Fatalf("Error opening %q: %v", path, err)
}
defer db.Close()
it, err := db.ScanPrefix([]byte(*keyPrefix), nil)
if err != nil {
log.Fatalf("Error creating iterator for %q: v", path, err)
}
defer it.Close()
for {
key, val, err := it.Next()
if err == io.EOF {
break
} else if err != nil {
log.Fatalf("Error during scan of %q: %v", path, err)
}
var k, v interface{}
if protoValueType == nil {
if *stringKey {
k = strconv.Quote(string(key))
} else {
k = base64.StdEncoding.EncodeToString(key)
}
if *stringValue {
v = strconv.Quote(string(val))
} else {
v = base64.StdEncoding.EncodeToString(val)
}
} else {
p := reflect.New(protoValueType.Elem()).Interface().(proto.Message)
if err := proto.Unmarshal(val, p); err != nil {
log.Fatalf("Error unmarshaling value to %q: %v", *protoValue, err)
}
k, v = string(key), p
}
if en == nil {
fmt.Println(strings.NewReplacer(
"@key@", fmt.Sprintf("%s", k),
"@value@", fmt.Sprintf("%s", v),
).Replace(*lineFormat))
} else {
en.Encode(keyValue{k, v})
}
}
}()
}
}