func TestNewNoValueInstance(t *testing.T) { owners := auth.NewPlainTextCredentials() err := owners.Add(&auth.PlainText{"id", "pass1234"}) if err != nil { t.Fatal(e.Trace(e.Forward(err))) } ownersWrong := auth.NewPlainTextCredentials() err = ownersWrong.Add(&auth.PlainText{"id2", "passssss"}) if err != nil { t.Fatal(e.Trace(e.Forward(err))) } err = instances.NewNoValueInstance("1", "321", owners) if err != nil { t.Fatal(e.Trace(e.Forward(err))) } err = instances.NewNoValueInstance("1", "111", ownersWrong) if err != nil && !e.Equal(err, ErrOwnerNotMatch) { t.Fatal(e.Trace(e.Forward(err))) } else if err == nil { t.Fatal("err is nil") } err = instances.NewNoValueInstance("123", "1", owners) if err != nil { t.Fatal(e.Trace(e.Forward(err))) } err = instances.NewNoValueInstance("123", "1", owners) if err != nil && !e.Equal(err, ErrInstExists) { t.Fatal(e.Trace(e.Forward(err))) } else if err == nil { t.Fatal("err is nil") } }
func (s *Server) mkChServer(conn InstConn, args []reflect.Value, enc *msgpack.Encoder) (err error) { typeChanDesc := reflect.TypeOf(&ChannelDescriptor{}) for i, arg := range args { if arg.Type() != typeChanDesc { continue } chd := arg.Interface().(*ChannelDescriptor) // criar channel. Value ch := chd.Make(true) // substituir o ChannelDescriptor pelo channel criado args[i] = ch // criar sessão/instância instname, err := rand.Chars(16, rand.NumberLetters, "go") if err != nil { return e.Forward(err) } owners := auth.NewPlainTextCredentials() err = owners.Add(conn.Auth()) if err != nil { return e.Forward(err) } err = s.Insts.NewChValueInstance(conn.SessionName(), instname, ch, chd.Dir, owners) if err != nil { return e.Forward(err) } // envia-las err = enc.Encode(instname) if err != nil { return e.Forward(err) } } return nil }
func BenchmarkLoad(b *testing.B) { instances := core.NewInstances() owners := auth.NewPlainTextCredentials() id = &auth.PlainText{Ident: "id", Pass: "******"} owners.Add(id) constructor := core.NewConstructor() server = &core.Server{ Proto: "tcp", Addr: "localhost:0", ConnTimeout: 30 * time.Second, Insts: instances, Cons: constructor, FifoLength: 1, Ttl: 24 * time.Hour, Cleanup: 5 * time.Minute, } server.Start() err := instances.New("1", "3", reflect.ValueOf(&Load{}), owners) if err != nil { b.Error(e.Trace(e.Forward(err))) } l := &LoadClient{ Net: "tcp", Addrs: server.Address().String(), Auth: id, Session: "1", Instance: "3", PointerRecv: true, } err = l.Init(true) if err != nil { b.Error(e.Trace(e.Forward(err))) } in, err := rand.Bytes(1e6, "go") if err != nil { b.Error(e.Trace(e.Forward(err))) } b.ResetTimer() for i := 0; i < b.N; i++ { l.Load(in) b.SetBytes(int64(len(in))) } }
func TestNewChValueInstance(t *testing.T) { owners := auth.NewPlainTextCredentials() err := owners.Add(&auth.PlainText{"id", "pass1234"}) if err != nil { t.Fatal(e.Trace(e.Forward(err))) } ownersWrong := auth.NewPlainTextCredentials() err = ownersWrong.Add(&auth.PlainText{"id2", "passssss"}) if err != nil { t.Fatal(e.Trace(e.Forward(err))) } ch := make(chan int) err = instances.NewChValueInstance("new", "1", reflect.ValueOf(ch), reflect.BothDir, owners) if err != nil { t.Fatal(e.Trace(e.Forward(err))) } err = instances.NewChValueInstance("new", "1", reflect.ValueOf(ch), reflect.BothDir, owners) if err != nil && !e.Equal(err, ErrInstExists) { t.Fatal(e.Trace(e.Forward(err))) } else if err == nil { t.Fatal("err is nil") } err = instances.NewChValueInstance("new", "2", reflect.ValueOf(ch), reflect.BothDir, ownersWrong) if err != nil && !e.Equal(err, ErrOwnerNotMatch) { t.Fatal(e.Trace(e.Forward(err))) } else if err == nil { t.Fatal("err is nil") } inst, err := instances.Get("new", "1") if err != nil { t.Fatal(e.Trace(e.Forward(err))) } if inst.Instance().Type() != reflect.TypeOf(ch) { t.Fatal("get fail") } }
func TestNew(t *testing.T) { owners := auth.NewPlainTextCredentials() err := owners.Add(&auth.PlainText{"id", "pass1234"}) if err != nil { t.Fatal(e.Trace(e.Forward(err))) } err = instances.New("1", "1", reflect.ValueOf(&teststruct{}), owners) if err != nil { t.Fatal(e.Trace(e.Forward(err))) } err = instances.New("1", "1", reflect.ValueOf(&teststruct{}), owners) if err != nil && !e.Equal(err, ErrInstExists) { t.Fatal(e.Trace(e.Forward(err))) } else if err == nil { t.Fatal("err is nil") } err = instances.New("1", "2", reflect.ValueOf(&structnomethods{}), owners) if err != nil && !e.Equal(err, ErrNoMethods) { t.Fatal(e.Trace(e.Forward(err))) } err = instances.New("1", "3", reflect.ValueOf(&teststruct{}), owners) if err != nil { t.Fatal(e.Trace(e.Forward(err))) } ownersWrong := auth.NewPlainTextCredentials() err = ownersWrong.Add(&auth.PlainText{"id2", "passssss"}) if err != nil { t.Fatal(e.Trace(e.Forward(err))) } err = instances.New("1", "4", reflect.ValueOf(&teststruct{}), ownersWrong) if err != nil && !e.Equal(err, ErrOwnerNotMatch) { t.Fatal(e.Trace(e.Forward(err))) } else if err == nil { t.Fatal("err is nil") } }
func TestExportGet(t *testing.T) { owners := auth.NewPlainTextCredentials() err := owners.Add(&auth.PlainText{"id", "pass1234"}) if err != nil { t.Fatal(e.Trace(e.Forward(err))) } err = instances.New("sess", "testexport", reflect.ValueOf(&TestExport{}), owners) if err != nil { t.Fatal(e.Trace(e.Forward(err))) } err = instances.Export("sess", "testexport", &ToExport{ Method: "TestRetval", RetvalPos: 0, Export: &Export{ Client: &TestExportClient{}, }, }) if err != nil { t.Fatal(e.Trace(e.Forward(err))) } _, err = instances.ExportGet("sess", "testexport", "TestRetval", 0) if err != nil { t.Fatal(e.Trace(e.Forward(err))) } _, err = instances.ExportGet("invalid sess", "testexport", "TestRetval", 0) if err != nil && !e.Equal(err, ErrSessionNotFound) { t.Fatal(e.Trace(e.Forward(err))) } else if err == nil { t.Fatal("err is nil") } _, err = instances.ExportGet("sess", "testexport__", "TestRetval", 0) if err != nil && !e.Equal(err, ErrInstanceNotFound) { t.Fatal(e.Trace(e.Forward(err))) } else if err == nil { t.Fatal("err is nil") } _, err = instances.ExportGet("sess", "testexport", "TestRetval__", 0) if err != nil && !e.Equal(err, ErrMethodNotFound) { t.Fatal(e.Trace(e.Forward(err))) } else if err == nil { t.Fatal("err is nil") } _, err = instances.ExportGet("sess", "testexport", "TestRetval", 999) if err != nil && !e.Equal(err, ErrReturnValueNotFound) { t.Fatal(e.Trace(e.Forward(err))) } else if err == nil { t.Fatal("err is nil") } }
func BenchmarkCall(b *testing.B) { instances := core.NewInstances() owners := auth.NewPlainTextCredentials() id = &auth.PlainText{Ident: "id", Pass: "******"} owners.Add(id) constructor := core.NewConstructor() server = &core.Server{ Proto: "tcp", Addr: "localhost:0", ConnTimeout: 30 * time.Second, Insts: instances, Cons: constructor, FifoLength: 1, Ttl: 24 * time.Hour, Cleanup: 5 * time.Minute, } server.Start() err := instances.New("1", "2", reflect.ValueOf(&Struct1{}), owners) if err != nil { b.Error(e.Trace(e.Forward(err))) } s1 := &Struct1Client{ Net: "tcp", Addrs: server.Address().String(), Auth: &auth.PlainText{"id", "pass1234"}, Session: "1", Instance: "2", PointerRecv: true, } err = s1.Init(true) if err != nil { b.Error(e.Trace(e.Forward(err))) } b.ResetTimer() for i := 0; i < b.N; i++ { s1.Func1() } }
func (p *protoServer) newInst(sess string, a auth.Auth, obj string, args ...interface{}) (string, error) { val, err := p.Cons.Construct(obj, args...) if err != nil { return "", e.Forward(err) } inst, err := rand.Chars(16, rand.NumberLetters, "go") if err != nil { return "", e.Forward(err) } owners := auth.NewPlainTextCredentials() err = owners.Add(a) if err != nil { return "", e.Forward(err) } err = p.Insts.New(sess, inst, val, owners) if err != nil { return "", e.Forward(err) } return inst, nil }
func TestServer(t *testing.T) { instances = core.NewInstances() owners = auth.NewPlainTextCredentials() id = &auth.PlainText{Ident: "id", Pass: "******"} owners.Add(id) constructor = core.NewConstructor() server = &core.Server{ Proto: "tcp", Addr: "localhost:0", ConnTimeout: 30 * time.Second, Insts: instances, Cons: constructor, FifoLength: 1, Ttl: 24 * time.Hour, Cleanup: 5 * time.Minute, } server.Start() }
func TestMain(m *testing.M) { insts := NewInstances() owners := auth.NewPlainTextCredentials() id = &auth.PlainText{Ident: "dummy", Pass: "******"} owners.Add(id) err := insts.New("0", "0", reflect.ValueOf(Dummy{}), owners) if err != nil { log.Fatal(err) } cons := NewConstructor() server = &Server{ Proto: "tcp", Addr: "localhost:0", ConnTimeout: 30 * time.Second, Insts: insts, Cons: cons, FifoLength: 1, Ttl: 24 * time.Hour, Cleanup: 5 * time.Minute, } server.Start() os.Exit(m.Run()) }
func TestServer(t *testing.T) { owners := auth.NewPlainTextCredentials() err := owners.Add(&auth.PlainText{"id", "pass1234"}) if err != nil { t.Fatal(e.Trace(e.Forward(err))) } constructor := NewConstructor() instances := NewInstances() err = instances.New("1", "1", reflect.ValueOf(Calc{}), owners) if err != nil { t.Fatal(e.Trace(e.Forward(err))) } err = instances.New("1", "2", reflect.ValueOf(&TestExport{}), owners) if err != nil { t.Fatal(e.Trace(e.Forward(err))) } err = instances.Export("1", "2", &ToExport{Method: "TestRetval", RetvalPos: 0, Export: &Export{Client: &ResultClient{}}}) if err != nil { t.Fatal(e.Trace(e.Forward(err))) } err = instances.New("1", "3", reflect.ValueOf(&TestChannel{}), owners) if err != nil { t.Fatal(e.Trace(e.Forward(err))) } serverTest = &Server{ Proto: "tcp", Addr: "localhost:0", ConnTimeout: 30 * time.Second, Insts: instances, Cons: constructor, FifoLength: 1000, Ttl: 24 * time.Hour, Cleanup: 5 * time.Minute, } serverTest.Start() t.Log(serverTest.Address()) }
func Example() { // Create a database of credentials owners := auth.NewPlainTextCredentials() // Authorize the user id err := owners.Add(&auth.PlainText{"id", "pass1234"}) if err != nil { log.Error(err) } // Constructors constructor := core.NewConstructor() // Struct with the instances instances := core.NewInstances() // New instance of a calculator. err = instances.New("1", "1", reflect.ValueOf(dummy.Calculator{}), owners) if err != nil { log.Error(err) } // Export the return value 0 of BigAdd with the client ResultClient err = instances.Export("1", "1", &core.ToExport{Method: "BigAdd", RetvalPos: 0, Export: &core.Export{Client: &dummy.ResultClient{}}}) if err != nil { log.Error(err) } // Create the server server := &core.Server{ Proto: "tcp", Addr: "localhost:0", ConnTimeout: 30 * time.Second, Insts: instances, Cons: constructor, FifoLength: 1, Ttl: 24 * time.Hour, Cleanup: 5 * time.Minute, } // Start the server server.Start() defer server.Close() // Configure the client calc := &dummy.CalculatorClient{ Net: "tcp", Addrs: server.Address().String(), Auth: &auth.PlainText{"id", "pass1234"}, Session: "1", Instance: "1", PointerRecv: true, } // Use the client API result := calc.Add(2, 40) err = calc.Error() if err != nil { log.Error(err) } fmt.Println(result) res := calc.BigAdd(2, 40) err = calc.Error() if err != nil { log.Error(err) return } fmt.Println(res.Get()) err = calc.Destroy() if err != nil { log.Error(err) } //Output: //42 //42 }
func TestOwner(t *testing.T) { owners := auth.NewPlainTextCredentials() err := owners.Add(&auth.PlainText{"id", "pass1234"}) if err != nil { t.Fatal(e.Trace(e.Forward(err))) } err = owners.Add(&auth.PlainText{"id2", "pass1234"}) if err != nil { t.Fatal(e.Trace(e.Forward(err))) } err = instances.SetOwner("1", owners) if err != nil { t.Fatal(e.Trace(e.Forward(err))) } err = instances.SetOwner("101", owners) if err != nil && !e.Equal(err, ErrSessionNotFound) { t.Fatal(e.Trace(e.Forward(err))) } else if err == nil { t.Fatal("err is nil") } _, err = instances.Owners("69") if err != nil && !e.Equal(err, ErrSessionNotFound) { t.Fatal(e.Trace(e.Forward(err))) } else if err == nil { t.Fatal("error is nil") } o, err := instances.Owners("1") if err != nil { t.Fatal(e.Trace(e.Forward(err))) } _, err = o.Get("id2") if err != nil { t.Fatal(e.Trace(e.Forward(err))) } _, err = o.Get("id3") if err != nil && !e.Equal(err, auth.ErrCredNotExist) { t.Fatal(e.Trace(e.Forward(err))) } else if err == nil { t.Fatal("error is nil") } err = o.Delete("id2") if err != nil { t.Fatal(e.Trace(e.Forward(err))) } err = o.Delete("id2") if err != nil && !e.Equal(err, auth.ErrCredNotExist) { t.Fatal(e.Trace(e.Forward(err))) } else if err == nil { t.Fatal("error is nil") } err = o.Add(&auth.PlainText{"id3", "pass1234"}) if err != nil { t.Fatal(e.Trace(e.Forward(err))) } err = o.Add(&auth.PlainText{"id3", "pass1234"}) if err != nil && !e.Equal(err, auth.ErrCredExist) { t.Fatal(e.Trace(e.Forward(err))) } else if err == nil { t.Fatal("error is nil") } err = o.Edit(&auth.PlainText{"id3", "pass6969"}) if err != nil { t.Fatal(e.Trace(e.Forward(err))) } err = o.Edit(&auth.PlainText{"id4", "pass4242"}) if err != nil && !e.Equal(err, auth.ErrCredNotExist) { t.Fatal(e.Trace(e.Forward(err))) } else if err == nil { t.Fatal("error is nil") } err = auth.Validate(o, &auth.PlainText{"id3", "pass6969"}) if err != nil { t.Fatal(e.Trace(e.Forward(err))) } err = auth.Validate(o, &auth.PlainText{"id3", "seilaseila"}) if err != nil && !e.Equal(err, auth.ErrIdOrPasswdNotValid) { t.Fatal(e.Trace(e.Forward(err))) } else if err == nil { t.Fatal("error is nil") } err = auth.Validate(o, &auth.PlainText{"id4", "seilaseila"}) if err != nil && !e.Equal(err, auth.ErrIdOrPasswdNotValid) { t.Fatal(e.Trace(e.Forward(err))) } else if err == nil { t.Fatal("error is nil") } }
func main() { instances := core.NewInstances() owners := auth.NewPlainTextCredentials() id := &auth.PlainText{Ident: "id", Pass: "******"} owners.Add(id) constructor := core.NewConstructor() server := &core.Server{ Proto: "tcp", Addr: "localhost:0", ConnTimeout: 30 * time.Second, Insts: instances, Cons: constructor, FifoLength: 1, Ttl: 24 * time.Hour, Cleanup: 5 * time.Minute, } server.Start() err := instances.New("1", "2", reflect.ValueOf(&dummy.Struct1{}), owners) if err != nil { log.Fatal(e.Trace(e.Forward(err))) } s1 := &dummy.Struct1Client{ Net: "tcp", Addrs: server.Address().String(), Auth: id, Session: "1", Instance: "2", PointerRecv: true, } str, err := s1.Func1() if err != nil { log.Fatal(e.Trace(e.Forward(err))) } if str == nil { log.Fatal("nil str") } if *str != "string" { log.Fatal("wrong string", *str) } log.Println("Destroy...") err = s1.Destroy() if err != nil { log.Fatal(e.Trace(e.Forward(err))) } log.Println("Close client...") err = s1.CloseClient() if err != nil { log.Fatal(e.Trace(e.Forward(err))) } log.Println("Close client...") err = server.Close() if err != nil { log.Fatal(e.Trace(e.Forward(err))) } panic("hi") }
func (s *Server) protoCall(conn InstConn) (err error) { enc := conn.Encoder() dec := conn.Decoder() defer func() { if err != nil { err = enc.Encode(&respCall{Err: err}) if err != nil { log.ProtoLevel().Tag("server", "gormethods").Printf("Encode %v -> %v (%v) error: %v", conn.RemoteAddr(), conn.LocalAddr(), conn.StreamNum(), err) err = e.Push(err, ErrWire) } } }() inst, err := s.Insts.Get(conn.SessionName(), conn.InstanceName()) if err != nil { log.Tag("server", "gormethods").Errorf("Error getting the instance %v/%v: %v", conn.SessionName(), conn.InstanceName(), e.Forward(err)) err = e.Forward(err) return } if inst.Type() != WithValue { log.Tag("server", "gormethods").Errorf("Instance %v/%v is of wrong type", conn.SessionName(), conn.InstanceName()) return e.New("instance is of wrong type") } log.ProtoLevel().Tag("gormethods", "server", "call").Printf("Call %v %v %v", conn.SessionName(), conn.InstanceName(), types.NameOf(inst.Instance().Type())) var req reqCall err = dec.Decode(&req) if e.Find(err, io.EOF) >= 0 { return e.Push(err, ErrWire) } else if err != nil { log.ProtoLevel().Tag("server", "gormethods").Printf("Decode %v -> %v (%v) error: %v", conn.RemoteAddr(), conn.LocalAddr(), conn.StreamNum(), err) err = e.Push(err, ErrWire) return } // Tratar argumentos (req.Args) com channel // criar channel // recebe do channel envia pelo conn // recebe do conn envia para channel // (faz isso até fechar o channel em um dos lados) // substutui em req.Args os channels // Se existem channels enviar instancias err = s.mkChServer(conn, req.Args, enc) if err != nil { err = e.Forward(err) log.Tag("server", "gormethods").Errorf("Channel arguments setup failed: %v", err) return } method := inst.Instance().MethodByName(req.Method) if !method.IsValid() { err = e.Push(e.New(ErrMethodNotFound), e.New("method %v not found", req.Method)) log.Tag("server", "gormethods").Errorf("Error in call %v/%v: %v", conn.SessionName(), conn.InstanceName(), err) return } log.ProtoLevel().Tag("server", "gormethods").Printf("Call %v/%v %v %v", conn.SessionName(), conn.InstanceName(), types.NameOf(inst.Instance().Type()), req.Method) var retvals []reflect.Value if method.Type().IsVariadic() { retvals = method.CallSlice(req.Args) } else { retvals = method.Call(req.Args) } log.ProtoLevel().Tag("server", "gormethods").Printf("Call returned %v/%v %v %v", conn.SessionName(), conn.InstanceName(), types.NameOf(inst.Instance().Type()), req.Method) for i := range retvals { var exp *Export exp, err = s.Insts.ExportGet(conn.SessionName(), conn.InstanceName(), req.Method, i) if err != nil { continue } var instname string instname, err = rand.Chars(16, rand.NumberLetters, "go") if err != nil { err = e.Push(err, "can't create the instance name for exported retval") log.Tag("server", "gormethods").Errorf("Error in call %v/%v: %v", conn.SessionName(), conn.InstanceName(), err) return } owners := auth.NewPlainTextCredentials() err = owners.Add(conn.Auth()) if err != nil { err = e.Push(err, "can't authorize the exported retval") log.Tag("server", "gormethods").Errorf("Error in call %v/%v: %v", conn.SessionName(), conn.InstanceName(), err) return } err = s.Insts.New(conn.SessionName(), instname, retvals[i], owners) if err != nil { err = e.Push(err, "can't crete the instance for the exported retval") log.Tag("server", "gormethods").Errorf("Error in call %v/%v: %v", conn.SessionName(), instname, err) return } for _, to := range exp.ToExport { err = s.Insts.Export(conn.SessionName(), instname, to) if err != nil { err = e.Push(err, e.New("can't export %v/%v %v %v %v to %v", conn.SessionName(), instname, to.Method, to.RetvalPos, types.Name(retvals[i].Interface()), types.Name(exp.Client))) log.Tag("server", "gormethods").Errorf("Error in call %v/%v: %v", conn.SessionName(), conn.InstanceName(), err) return } } exp.Client.Associate(conn.SessionName(), instname, conn.Auth()) retvals[i] = reflect.ValueOf(exp.Client) continue } log.ProtoLevel().Tag("server", "gormethods").Printf("Send returned values %v/%v %v %v", conn.SessionName(), conn.InstanceName(), types.NameOf(inst.Instance().Type()), req.Method) err = enc.Encode(&respCall{ Vals: retvals, Err: nil, }) if err != nil { log.ProtoLevel().Tag("server", "gormethods").Printf("Encode %v -> %v (%v) error: %v", conn.RemoteAddr(), conn.LocalAddr(), conn.StreamNum(), err) err = e.Push(err, ErrWire) return } log.ProtoLevel().Tag("server", "gormethods").Printf("Send returned values done %v/%v %v %v", conn.SessionName(), conn.InstanceName(), types.NameOf(inst.Instance().Type()), req.Method) return }