'shared.bmx
Type TService {proxy}
	Method GetInfo:String(id:Int) Abstract
End Type

'Diese Datei mit buildproxies starten

'server.bmx
Framework fscom.rmi
Import "shared.bmx"

Type TServerService Extends TService
	Field info:String[]
	
	Method GetInfo:String(id:Int)
		Return info[id]
	End Method
End Type

Local server:TServerService = New TServerService
server.info=["ABC","123","!§$"]

RMIStartServer
RMIRegisterObjectService server, "InfoService"

Repeat
	RMIPollNetwork
	PollSystem
Forever

'client.bmx
Framework fscom.rmi
Import BRL.StandardIO
Import "shared.bmx"

RMIConnect "localhost"
Local client:TService=TService(RMIGetServiceObject("InfoService","TService"))

Print client.GetInfo(0)
Print client.GetInfo(1)
Print client.GetInfo(2)

Input

• [Erledigt V0.2] Aktuell kann nur der Client nur vom Server Methoden aufrufen. Damit ist er bei Ereignisabfragen auf Polling angewiesen. Wünschenswert wäre wenn der Client selbst eine Art Server startet und über die Leitung rückwärts vom Server angesprochen werden kann.
  
• [Erledigt V0.2]Der Service kann nicht den Client erkennen. Er muss z.B. eine Login-Funktion implementieren, die ein Cookie zurück gibt, das der Client bei allen Anfragen mitschicken muss. Ich hätte gern, dass man eine Klasse registrieren kann, sodass RMI pro Client ein Server-Service-Objekt anlegt.
  
• Der TBufferedStream hat einen "endlosen" buffer implementiert. Der Arbeitsspeicher ist allerdings begrenzt. Besser wäre eine Implementierung, bei der man den Buffer wenn gewollt begrenzen kann. Ich denke da an jemand, der versucht eine 10GB-Datei zu verschicken und dann den Arbeitsspeicher sprängt
  
• Bei der Serialisierung ist die Objekt-Baum "Ich erkenne ein Objekt, dass ich bereits verschickt habe"-Implementierung noch arg verbesserungswürdig
  
• Ich habe bereits einen RMI-Service, der Infos über alle RMI-Services gibt implementiert. Es wäre wünschenswert, wenn der Client beim Start der Verbindung die Server-Implementierung mit der Client-Implementierung vergleicht und Alarm schlägt bei Differenzen. Aktuell ist der Ausgang unbestimmt bei nicht übereinstimmender Implementierung: Vielleicht geht's gut, vielleicht nicht.
  
• UDP-Untertützung
  
• [Teilweise V0.3]Threading: Die Aufrufe werden jetzt an einen Executor gegeben, der theoretisch die Aufrufe in verschiedenen Threads ausführen kann. Noch nicht ausgiebig getestet.
  

• Verwendung von standardisierten Aufruf-Semantiken anstelle von Marke-Eigenbau "blocking" / "nonblocking"
  
• Nutzung von Proxy-Objekten, die als Parameter übergeben, oder als Rückgabewert übertragen werden.
  

SuperStrict

Framework bah.maxunit
Import fscom.rmi
Import "rmi-test-interface.bmx"

RMIConnect "localhost"

New TTestSuite.Run()

Type TMyTest Extends TTest
	Method simple() {test}
		'DebugStop
		Local simple:TSimpleServerside = TSimpleServerside(RMIGetServiceObject("Single" , "TSimpleServerside") )
		
		assertNotNull simple
		
		Local test:GenObject = New GenObject
		test.integer=4711
		Local ignored:Byte = simple.set(test)
		
		'set returns true serverside and is nonblocking
		'so it should return 0 here as the return value is discarded in nonblocking
		assertEqualsI 0, ignored
		
		Local newTest:GenObject = simple.get()
		assertEquals test, newTest
	End Method

	Method complex() {test}
		Local multiple:TMultipleServerside = TMultipleServerside(RMIGetServiceObject("Multiple" , "TMultipleServerside") )

		assertNotNull multiple

		Local localService:TClientsideImpl = New TClientsideImpl
		RMIRegisterObjectService localService, "TESTSERVICE"
		
		Local testString:String = "123456"
		
		multiple.CallMe("TESTSERVICE" , teststring)
		
		'Wait for serverside code and poll network
		StandardIOStream.WriteString "1"
		StandardIOStream.Flush()
		
		Local calledLast:Int=localService.calledLast
		Repeat 
			RMIPollNetwork
		Until calledLast<>localService.calledLast
		
		'check for new value set by remote code
		assertEquals "123456",localService.lastRef
				
		'Wait for serverside code and poll network
		StandardIOStream.WriteString "2"
		StandardIOStream.Flush()

		calledLast=localService.calledLast
		Repeat 
			RMIPollNetwork
		Until calledLast<>localService.calledLast
		
		'check if return value caused server to call again
		assertEquals "34" , localService.lastRef
		
		'Wait for serverside code and poll network
		StandardIOStream.WriteString "3"
		StandardIOStream.Flush()

		calledLast=localService.calledLast
		Local timeout:Int=MilliSecs()+1000
		Repeat 
			RMIPollNetwork
		Until MilliSecs()>timeout
		
		'TClientsideImpl.Call should have returned "",
		'so the server should Not have called
		assertEqualsI calledLast, localService.calledLast
	End Method
	
	Method recursive() {test}
		Local service:TFactorial = TFactorial(RMIGetServiceObject("Factorial" , "TFactorial") )
		
		Local clientService:TFactorialImpl=New TFactorialImpl
		clientService.service=service
		RMIRegisterObjectService clientService,"Factorial"
		
		'DebugStop
		
		assertEqualsI 120 , service.Fac(5)
	End Method
End Type

Type TClientsideImpl Extends TClientside
	Field lastRef:String
	Field calledLast:Int
	
	Method Call:String(ref:String)
		calledLast=MilliSecs()
		If lastref
			lastRef = ref
			Return ""
		Else 
			lastRef = ref
			Return ref[2..ref.length-2]
		EndIf
	End Method
End Type

Type TFactorialImpl Extends TFactorial
	Field service:TFactorial
	
	Method Fac:Int(i:Int)
		If i = 0 Or i = 1
			Return 1
		Else
			Return service.Fac(i - 1) * i
		End If
	End Method
End Type

SuperStrict

Framework brl.standardio
Import fscom.rmi
Import "rmi-test-interface.bmx"

RMIStartServer
'DebugStop 
RMIRegisterObjectService New TSimpleServersideImpl,"Single"
RMIRegisterTypeService "TMultipleServersideImpl","Multiple"
RMIRegisterTypeService "TFactorialImpl","Factorial"

Repeat
	'DebugStop
	RMIPollNetwork
Forever 

Type TSimpleServersideImpl Extends TSimpleServerside
	Field obj:GenObject
	
	Method set:Byte(obj:GenObject)
		Self.obj = obj
		Return True 
	End Method
		
	Method get:GenObject()
		Return obj
	End Method
End Type

Type TMultipleServersideImpl Extends TMultipleServerside
	Field client:TRMIClient
	
	Method OnConnect(client:TRMIClient)
		Self.client = client
		DebugLog client.ToString()
	End Method
	
	Method CallMe(localService:String , ref:String)
		Local cservice:TClientside = TClientside(client.GetRemoteServiceObject(localService,"TClientside"))
		Repeat
			'DebugStop
			Delay 1000
			DebugLog "calling "+ref
			ref = cservice.Call(ref)
		Until ref = ""
		DebugLog "end calling"
	End Method
End Type

Type TFactorialImpl Extends TFactorial
	Field client:TRMIClient
	Field cservice:TFactorial
	
	Method OnConnect(client:TRMIClient)
		Self.client = client
		cservice=TFactorial(client.GetRemoteServiceObject("Factorial","TFactorial"))
		DebugLog client.ToString()
	End Method
	
	Method Fac:Int(i:Int)
		If i = 0 Or i = 1
			Return 1
		Else
			Return cservice.Fac(i - 1) * i
		End If
	End Method
End Type

SuperStrict

Type TSimpleServerside {proxy}
	Method set:Byte(obj:GenObject) Abstract {rminonblocking}
	Method get:GenObject() Abstract {rmiblocking}
End Type
'*** PROXY ***
Include "TSimpleServerside-proxy.bmx"


Type TMultipleServerside {proxy}
	Method CallMe(localService:String, ref:String) Abstract {rminonblocking}
End Type
'*** PROXY ***
Include "TMultipleServerside-proxy.bmx"


Type TClientside {proxy}
	Method Call:String(ref:String) Abstract {rmiblocking}
End Type
'*** PROXY ***
Include "TClientside-proxy.bmx"


Type TFactorial {proxy}
	Method Fac:Int(i:Int) Abstract
End Type
'*** PROXY ***
Include "TFactorial-proxy.bmx"



Type GenObject
	Field integer:Int
	
	Method Compare:Int(with:Object)
		If GenObject(with) And GenObject(with).integer = integer
			Return 0
		Else
			Return Super.Compare(with)
		EndIf
	End Method
End Type