Exemplo n.º 1
0
func DecInterface(dec *msgpack.Decoder) (interface{}, error) {
	var st status
	err := dec.Decode(&st)
	if err != nil {
		return nil, e.Forward(err)
	}
	switch st {
	case statusNotNil:
		var typename string
		err = dec.Decode(&typename)
		if err != nil {
			return nil, e.Forward(err)
		}
		t, err := types.GetType(typename)
		if err != nil {
			return nil, e.Forward(err)
		}
		ptr := types.Make(reflect.PtrTo(t))
		err = dec.DecodeValue(ptr)
		if err != nil {
			return nil, e.Forward(err)
		}
		return reflect.Indirect(ptr).Interface(), nil
	case statusNil:
		return nil, nil
	}
	panic("not here")
}
Exemplo n.º 2
0
func (c *Constructors) Construct(name string, args ...interface{}) (reflect.Value, error) {
	c.lck.Lock()
	defer c.lck.Unlock()
	con, found := c.constructors[name]
	if !found {
		t, err := types.GetType(name)
		if err != nil {
			return reflect.Value{}, e.New(ErrTypeNotFound)
		}
		return types.Make(t), nil
	}
	vals := make([]reflect.Value, 0, len(args))
	for _, arg := range args {
		vals = append(vals, reflect.ValueOf(arg))
	}
	retvals := con.Call(vals)
	if len(retvals) != 2 {
		return reflect.Value{}, e.New(ErrInvReturn)
	}
	if retvals[1].Interface() != nil {
		err, ok := retvals[1].Interface().(error)
		if !ok {
			return reflect.Value{}, e.New(ErrInvReturn)
		}
		if err != nil {
			return reflect.Value{}, e.Forward(err)
		}
	}
	return retvals[0], nil
}
Exemplo n.º 3
0
func (t *Time) DecodeMsgpack(dec *msgpack.Decoder) error {
	var status statusValue
	err := dec.Decode(&status)
	if err != nil {
		return err
	}
	switch status {
	case stNotIsValid:
		t.t = nil
	case stIsValid:
		var typename string
		err := dec.Decode(&typename)
		if err != nil {
			return err
		}
		typ, err := types.GetType(typename)
		if err != nil {
			return e.Forward(err)
		}
		ptr := types.Make(reflect.PtrTo(typ))
		err = dec.DecodeValue(ptr)
		if err != nil {
			return err
		}
		t.t = ptr.Elem().Interface()
	default:
		return e.New("invalid data")
	}
	return nil
}
Exemplo n.º 4
0
func (r *respCall) DecodeMsgpack(dec *msgpack.Decoder) error {
	var proto util.Msg
	err := dec.Decode(&proto)
	if err != nil {
		return e.Forward(err)
	}
	switch proto {
	case util.ErrNil:
	case util.ErrOk:
		err := dec.Decode(&proto)
		if err != nil {
			return e.Forward(err)
		}
		switch proto {
		case util.ErrorPriv:
			var errtype string
			err := dec.Decode(&errtype)
			if err != nil {
				return e.Forward(err)
			}
			t, err := types.GetType(errtype)
			if err != nil {
				return e.Forward(err)
			}
			ptr := types.Make(reflect.PtrTo(t))
			err = dec.DecodeValue(ptr)
			if err != nil {
				return e.Forward(err)
			}
			r.Err = reflect.Indirect(ptr).Interface().(error)
		case util.ErrorInt:
			var errStr string
			err := dec.Decode(&errStr)
			if err != nil {
				return e.Forward(err)
			}
			r.Err = errors.New(errStr)
		}
	default:
		return e.New("protocol error")
	}
	var lenght int
	err = dec.Decode(&lenght)
	if err != nil {
		return e.Forward(err)
	}
	if lenght > 0 {
		r.Vals = make([]reflect.Value, lenght)
		for i := range r.Vals {
			r.Vals[i], err = util.MsgPackDecode(dec)
			if err != nil {
				return e.Forward(err)
			}
		}
	}
	return nil
}
Exemplo n.º 5
0
func (r *RespInst) DecodeMsgpack(dec *msgpack.Decoder) error {
	err := dec.Decode(&r.Inst)
	if err != nil {
		return e.Forward(err)
	}
	var proto util.Msg
	err = dec.Decode(&proto)
	if err != nil {
		return e.Forward(err)
	}
	switch proto {
	case util.ErrNil:
	case util.ErrOk:
		err := dec.Decode(&proto)
		if err != nil {
			return e.Forward(err)
		}
		switch proto {
		case util.ErrorPriv:
			var errtype string
			err := dec.Decode(&errtype)
			if err != nil {
				return e.Forward(err)
			}
			t, err := types.GetType(errtype)
			if err != nil {
				return e.Forward(err)
			}
			ptr := types.Make(reflect.PtrTo(t))
			err = dec.DecodeValue(ptr)
			if err != nil {
				return e.Forward(err)
			}
			r.Err = reflect.Indirect(ptr).Interface().(error)
		case util.ErrorInt:
			var errStr string
			err := dec.Decode(&errStr)
			if err != nil {
				return e.Forward(err)
			}
			r.Err = errors.New(errStr)
		}
	default:
		return e.New("protocol error")
	}
	return nil
}
Exemplo n.º 6
0
// MsgPackDecode decode from dec a value represented by a reflect.Value type.
func MsgPackDecode(dec *msgpack.Decoder) (reflect.Value, error) {
	var proto Msg
	err := dec.Decode(&proto)
	if err != nil {
		return reflect.Value{}, e.Forward(err)
	}
	switch proto {
	case NotValid:
		return reflect.Value{}, nil
	case Func:
		return reflect.Value{}, nil
	case Valid:

	default:
		return reflect.Value{}, e.New("protocol error")
	}

	err = dec.Decode(&proto)
	if err != nil {
		return reflect.Value{}, e.Forward(err)
	}
	switch proto {
	case ArgNil:
		err = dec.Decode(&proto)
		if err != nil {
			return reflect.Value{}, e.Forward(err)
		}
		switch proto {
		case ZeroArg:
			return reflect.Value{}, nil
		case NoZeroArg:
			var typename string
			err = dec.Decode(&typename)
			if err != nil {
				return reflect.Value{}, e.Forward(err)
			}
			// Work arround for this two special types.
			switch typename {
			case "error":
				return reflect.Value{}, nil
			case "interface {}":
				return reflect.Value{}, nil
			}
			t, err := types.GetType(typename)
			if err != nil {
				return reflect.Value{}, e.Forward(err)
			}
			val := reflect.New(t)
			ind := reflect.Indirect(val)
			return ind, nil
		default:
			return reflect.Value{}, e.New("protocol error")
		}
	case NotNil:

	default:
		return reflect.Value{}, e.New("protocol error")
	}

	err = dec.Decode(&proto)
	if err != nil {
		return reflect.Value{}, e.Forward(err)
	}
	switch proto {
	case ZeroArg:
		var typename string
		err = dec.Decode(&typename)
		if err != nil {
			return reflect.Value{}, e.Forward(err)
		}
		t, err := types.GetType(typename)
		if err != nil {
			return reflect.Value{}, e.Forward(err)
		}
		return reflect.Zero(t), nil
	case NoZeroArg:

	default:
		return reflect.Value{}, e.New("protocol error")
	}

	err = dec.Decode(&proto)
	if err != nil {
		return reflect.Value{}, e.Forward(err)
	}
	switch proto {
	case ArgError:
		var errStr string
		err = dec.Decode(&errStr)
		if err != nil {
			return reflect.Value{}, e.Forward(err)
		}
		return reflect.ValueOf(errors.New(errStr)), nil
	case ArgNormal:
		var typename string
		err = dec.Decode(&typename)
		if err != nil {
			return reflect.Value{}, e.Forward(err)
		}
		t, err := types.GetType(typename)
		if err != nil {
			return reflect.Value{}, e.Forward(err)
		}
		ptr := types.Make(reflect.PtrTo(t))
		err = dec.DecodeValue(ptr)
		if err != nil {
			return reflect.Value{}, e.Forward(err)
		}
		val := reflect.Indirect(ptr)
		return val, nil
	default:
		return reflect.Value{}, e.New("protocol error")
	}
}
Exemplo n.º 7
0
func (a *Alive) Connect() error {

	if a.events == nil {
		a.events = make(chan event.Event)
	}
	a.closePing = make(chan bool)

	resolved, err := dns.ResolveUrl(a.Url)
	if e.Contains(err, "invalid domain name") {
		resolved = a.Url
	} else if err != nil {
		a.setConnected(false)
		return e.Forward(err)
	}

	for i := 0; i < a.Tries; i++ {
		a.conn, err = net.Dial(resolved.Scheme, resolved.Host)
		if e.Contains(err, definitions.NetErrorConnectionRefused) ||
			e.Contains(err, definitions.NetErrorTimeOut) ||
			e.Contains(err, definitions.ErrCheckIsAliveNoRoute) ||
			e.Contains(err, definitions.ErrCheckIsAliveNoAnswerFromResolver) {
			time.Sleep(a.Wait)
			continue
		} else if err != nil {
			a.setConnected(false)
			return e.Forward(err)
		}
		break
	}
	if a.conn == nil {
		a.setConnected(false)
		if err != nil {
			return e.Push(e.New(err), definitions.ErrCheckIsAliveCantConnect)
		}
		return e.New(definitions.ErrCheckIsAliveCantConnect)
	}

	a.setConnected(true)

	dec := gob.NewDecoder(a.conn)
	enc := gob.NewEncoder(a.conn)

	go func() {
		defer func() {
			if a.conn != nil {
				a.conn.Close()
			}
			a.setConnected(false)
		}()
		for {
			select {
			case <-time.After(a.Wait):
				err := a.conn.SetWriteDeadline(time.Now().Add(5 * time.Second))
				if err != nil {
					return
				}
				err = enc.Encode("ping")
				if err != nil {
					a.Statuses.Log(status.Verbose, "Alive: Ping encode error: %v", err)
					return
				}
			case <-a.closePing:
				return
			}
		}
	}()

	go func() {
		defer func() {
			if a.conn != nil {
				a.conn.Close()
			}
			a.setConnected(false)
		}()
		for {
			var typ string
			err := dec.Decode(&typ)
			if err != nil {
				a.Statuses.Log(status.Verbose, "Alive: Decode error: %v", err)
				return
			}
			t, err := types.GetType(typ)
			if err != nil {
				a.Statuses.Log(status.Verbose, "Alive: GetType error: %v", err)
				return
			}
			ptr := types.Make(reflect.PtrTo(t))
			err = dec.DecodeValue(ptr)
			if err != nil {
				a.Statuses.Log(status.Verbose, "Alive: DecodeValue error: %v", err)
				return
			}
			val := reflect.Indirect(ptr)
			if val.IsValid() {
				a.events <- val.Interface().(event.Event)
			}
		}
	}()

	return nil
}