public LockController( RpcController rpc ) { if (instance != null) { this.rpc = rpc; instance = this; } }
public void Init() { controller = new RpcController(); client = new Mock<RpcClient>(new object[] { controller }); server = new Mock<RpcServer>(new object[] { controller }); channel = new Mock<RpcChannel>(new object[] { controller }); controller.Client = client.Object; controller.Server = server.Object; controller.Channel = channel.Object; }
public void Init() { var controller = new RpcController(); client = new RpcClient(controller); server = new RpcServer(controller); server.RegisterService(new SampleService()); var channel = new LoopbackRpcChannel(controller); channel.Start(); dynProxy = client.GetProxy("ISampleService"); }
public DirtyObjectController( NetReplicationController netreplicationcontroller, NetworkLevel2Controller network, RpcController rpc ) { if (!network.IsServer) { throw new Exception( "Shouldnt be instantiating dirtyobjectcontroller on client" ); } this.netreplicationcontroller = netreplicationcontroller; this.rpc = rpc; this.network = network; //network = NetworkControllerFactory.GetInstance(); network.NewConnection += new Level2NewConnectionHandler(network_NewConnection); network.Disconnection += new Level2DisconnectionHandler(network_Disconnection); }
/// <exception cref="Com.Google.Protobuf.ServiceException"/> public virtual DatanodeProtocolProtos.RegisterDatanodeResponseProto RegisterDatanode (RpcController controller, DatanodeProtocolProtos.RegisterDatanodeRequestProto request ) { DatanodeRegistration registration = PBHelper.Convert(request.GetRegistration()); DatanodeRegistration registrationResp; try { registrationResp = impl.RegisterDatanode(registration); } catch (IOException e) { throw new ServiceException(e); } return((DatanodeProtocolProtos.RegisterDatanodeResponseProto)DatanodeProtocolProtos.RegisterDatanodeResponseProto .NewBuilder().SetRegistration(PBHelper.Convert(registrationResp)).Build()); }
/// <exception cref="Com.Google.Protobuf.ServiceException"/> public virtual QJournalProtocolProtos.CanRollBackResponseProto CanRollBack(RpcController controller, QJournalProtocolProtos.CanRollBackRequestProto request) { try { StorageInfo si = PBHelper.Convert(request.GetStorage(), HdfsServerConstants.NodeType .JournalNode); bool result = impl.CanRollBack(Convert(request.GetJid()), si, PBHelper.Convert(request .GetPrevStorage(), HdfsServerConstants.NodeType.JournalNode), request.GetTargetLayoutVersion ()); return((QJournalProtocolProtos.CanRollBackResponseProto)QJournalProtocolProtos.CanRollBackResponseProto .NewBuilder().SetCanRollBack(result).Build()); } catch (IOException e) { throw new ServiceException(e); } }
public SignalsClient(string url) { mUrl = url; if (mRpcController == null) { mRpcController = new RpcController(); mRpcClient = new RpcClient(mRpcController, 2500) { ResponseTimeout = TimeSpan.FromMilliseconds(10000) }; mSignalsClient = mRpcClient.GetProxy <ISignalsClient>(); } mThread = new Thread(ChannelChecker); mThread.Start(); }
/// <exception cref="Com.Google.Protobuf.ServiceException"/> public virtual MRServiceProtos.GetTaskAttemptCompletionEventsResponseProto GetTaskAttemptCompletionEvents (RpcController controller, MRServiceProtos.GetTaskAttemptCompletionEventsRequestProto proto) { GetTaskAttemptCompletionEventsRequest request = new GetTaskAttemptCompletionEventsRequestPBImpl (proto); try { GetTaskAttemptCompletionEventsResponse response = real.GetTaskAttemptCompletionEvents (request); return(((GetTaskAttemptCompletionEventsResponsePBImpl)response).GetProto()); } catch (IOException e) { throw new ServiceException(e); } }
/// <exception cref="Com.Google.Protobuf.ServiceException"/> public virtual ProtocolInfoProtos.GetProtocolSignatureResponseProto GetProtocolSignature (RpcController controller, ProtocolInfoProtos.GetProtocolSignatureRequestProto request ) { ProtocolInfoProtos.GetProtocolSignatureResponseProto.Builder builder = ProtocolInfoProtos.GetProtocolSignatureResponseProto .NewBuilder(); string protocol = request.GetProtocol(); string rpcKind = request.GetRpcKind(); long[] versions; try { versions = GetProtocolVersionForRpcKind(RPC.RpcKind.ValueOf(rpcKind), protocol); } catch (TypeLoadException e1) { throw new ServiceException(e1); } if (versions == null) { return((ProtocolInfoProtos.GetProtocolSignatureResponseProto)builder.Build()); } foreach (long v in versions) { ProtocolInfoProtos.ProtocolSignatureProto.Builder sigBuilder = ProtocolInfoProtos.ProtocolSignatureProto .NewBuilder(); sigBuilder.SetVersion(v); try { ProtocolSignature signature = ProtocolSignature.GetProtocolSignature(protocol, v); foreach (int m in signature.GetMethods()) { sigBuilder.AddMethods(m); } } catch (TypeLoadException e) { throw new ServiceException(e); } builder.AddProtocolSignature(((ProtocolInfoProtos.ProtocolSignatureProto)sigBuilder .Build())); } return((ProtocolInfoProtos.GetProtocolSignatureResponseProto)builder.Build()); }
/// <exception cref="Com.Google.Protobuf.ServiceException"/> public virtual YarnServiceProtos.GetContainersResponseProto GetContainers(RpcController controller, YarnServiceProtos.GetContainersRequestProto proto) { GetContainersRequestPBImpl request = new GetContainersRequestPBImpl(proto); try { GetContainersResponse response = real.GetContainers(request); return(((GetContainersResponsePBImpl)response).GetProto()); } catch (YarnException e) { throw new ServiceException(e); } catch (IOException e) { throw new ServiceException(e); } }
GetReconfigurationStatus(RpcController unused, ClientDatanodeProtocolProtos.GetReconfigurationStatusRequestProto request) { ClientDatanodeProtocolProtos.GetReconfigurationStatusResponseProto.Builder builder = ClientDatanodeProtocolProtos.GetReconfigurationStatusResponseProto.NewBuilder (); try { ReconfigurationTaskStatus status = impl.GetReconfigurationStatus(); builder.SetStartTime(status.GetStartTime()); if (status.Stopped()) { builder.SetEndTime(status.GetEndTime()); System.Diagnostics.Debug.Assert(status.GetStatus() != null); foreach (KeyValuePair <ReconfigurationUtil.PropertyChange, Optional <string> > result in status.GetStatus()) { ClientDatanodeProtocolProtos.GetReconfigurationStatusConfigChangeProto.Builder changeBuilder = ClientDatanodeProtocolProtos.GetReconfigurationStatusConfigChangeProto.NewBuilder (); ReconfigurationUtil.PropertyChange change = result.Key; changeBuilder.SetName(change.prop); changeBuilder.SetOldValue(change.oldVal != null ? change.oldVal : string.Empty); if (change.newVal != null) { changeBuilder.SetNewValue(change.newVal); } if (result.Value.IsPresent()) { // Get full stack trace. changeBuilder.SetErrorMessage(result.Value.Get()); } builder.AddChanges(changeBuilder); } } } catch (IOException e) { throw new ServiceException(e); } return((ClientDatanodeProtocolProtos.GetReconfigurationStatusResponseProto)builder .Build()); }
/// <exception cref="Com.Google.Protobuf.ServiceException"/> public virtual ClientDatanodeProtocolProtos.GetBlockLocalPathInfoResponseProto GetBlockLocalPathInfo (RpcController unused, ClientDatanodeProtocolProtos.GetBlockLocalPathInfoRequestProto request) { BlockLocalPathInfo resp; try { resp = impl.GetBlockLocalPathInfo(PBHelper.Convert(request.GetBlock()), PBHelper. Convert(request.GetToken())); } catch (IOException e) { throw new ServiceException(e); } return((ClientDatanodeProtocolProtos.GetBlockLocalPathInfoResponseProto)ClientDatanodeProtocolProtos.GetBlockLocalPathInfoResponseProto .NewBuilder().SetBlock(PBHelper.Convert(resp.GetBlock())).SetLocalPath(resp.GetBlockPath ()).SetLocalMetaPath(resp.GetMetaPath()).Build()); }
Heartbeat(RpcController controller, YarnServerNodemanagerServiceProtos.LocalizerStatusProto proto) { LocalizerStatusPBImpl request = new LocalizerStatusPBImpl(proto); try { LocalizerHeartbeatResponse response = real.Heartbeat(request); return(((LocalizerHeartbeatResponsePBImpl)response).GetProto()); } catch (YarnException e) { throw new ServiceException(e); } catch (IOException e) { throw new ServiceException(e); } }
/// <exception cref="Com.Google.Protobuf.ServiceException"/> public virtual YarnServiceProtos.KillApplicationResponseProto ForceKillApplication (RpcController arg0, YarnServiceProtos.KillApplicationRequestProto proto) { KillApplicationRequestPBImpl request = new KillApplicationRequestPBImpl(proto); try { KillApplicationResponse response = real.ForceKillApplication(request); return(((KillApplicationResponsePBImpl)response).GetProto()); } catch (YarnException e) { throw new ServiceException(e); } catch (IOException e) { throw new ServiceException(e); } }
RefreshAdminAcls(RpcController controller, YarnServerResourceManagerServiceProtos.RefreshAdminAclsRequestProto proto) { RefreshAdminAclsRequestPBImpl request = new RefreshAdminAclsRequestPBImpl(proto); try { RefreshAdminAclsResponse response = real.RefreshAdminAcls(request); return(((RefreshAdminAclsResponsePBImpl)response).GetProto()); } catch (YarnException e) { throw new ServiceException(e); } catch (IOException e) { throw new ServiceException(e); } }
/// <exception cref="Com.Google.Protobuf.ServiceException"/> public virtual TraceAdminPB.AddSpanReceiverResponseProto AddSpanReceiver(RpcController controller, TraceAdminPB.AddSpanReceiverRequestProto req) { try { SpanReceiverInfoBuilder factory = new SpanReceiverInfoBuilder(req.GetClassName()); foreach (TraceAdminPB.ConfigPair config in req.GetConfigList()) { factory.AddConfigurationPair(config.GetKey(), config.GetValue()); } long id = server.AddSpanReceiver(factory.Build()); return((TraceAdminPB.AddSpanReceiverResponseProto)TraceAdminPB.AddSpanReceiverResponseProto .NewBuilder().SetId(id).Build()); } catch (IOException e) { throw new ServiceException(e); } }
/// <exception cref="Com.Google.Protobuf.ServiceException"/> public virtual YarnServiceProtos.AllocateResponseProto Allocate(RpcController arg0 , YarnServiceProtos.AllocateRequestProto proto) { AllocateRequestPBImpl request = new AllocateRequestPBImpl(proto); try { AllocateResponse response = real.Allocate(request); return(((AllocateResponsePBImpl)response).GetProto()); } catch (YarnException e) { throw new ServiceException(e); } catch (IOException e) { throw new ServiceException(e); } }
UpdateNodeResource(RpcController controller, YarnServerResourceManagerServiceProtos.UpdateNodeResourceRequestProto proto) { UpdateNodeResourceRequestPBImpl request = new UpdateNodeResourceRequestPBImpl(proto ); try { UpdateNodeResourceResponse response = real.UpdateNodeResource(request); return(((UpdateNodeResourceResponsePBImpl)response).GetProto()); } catch (YarnException e) { throw new ServiceException(e); } catch (IOException e) { throw new ServiceException(e); } }
/// <exception cref="Com.Google.Protobuf.ServiceException"/> public virtual YarnServiceProtos.UseSharedCacheResourceResponseProto Use(RpcController controller, YarnServiceProtos.UseSharedCacheResourceRequestProto proto) { UseSharedCacheResourceRequestPBImpl request = new UseSharedCacheResourceRequestPBImpl (proto); try { UseSharedCacheResourceResponse response = real.Use(request); return(((UseSharedCacheResourceResponsePBImpl)response).GetProto()); } catch (YarnException e) { throw new ServiceException(e); } catch (IOException e) { throw new ServiceException(e); } }
/// <exception cref="Com.Google.Protobuf.ServiceException"/> public virtual SecurityProtos.GetDelegationTokenResponseProto GetDelegationToken( RpcController controller, SecurityProtos.GetDelegationTokenRequestProto proto) { GetDelegationTokenRequestPBImpl request = new GetDelegationTokenRequestPBImpl(proto ); try { GetDelegationTokenResponse response = real.GetDelegationToken(request); return(((GetDelegationTokenResponsePBImpl)response).GetProto()); } catch (YarnException e) { throw new ServiceException(e); } catch (IOException e) { throw new ServiceException(e); } }
Refresh(RpcController controller, GenericRefreshProtocolProtos.GenericRefreshRequestProto request) { try { IList <string> argList = request.GetArgsList(); string[] args = Collections.ToArray(argList, new string[argList.Count]); if (!request.HasIdentifier()) { throw new ServiceException("Request must contain identifier"); } ICollection <RefreshResponse> results = impl.Refresh(request.GetIdentifier(), args ); return(Pack(results)); } catch (IOException e) { throw new ServiceException(e); } }
/// <exception cref="Com.Google.Protobuf.ServiceException"/> public virtual YarnServerCommonServiceProtos.NodeHeartbeatResponseProto NodeHeartbeat (RpcController controller, YarnServerCommonServiceProtos.NodeHeartbeatRequestProto proto) { NodeHeartbeatRequestPBImpl request = new NodeHeartbeatRequestPBImpl(proto); try { NodeHeartbeatResponse response = real.NodeHeartbeat(request); return(((NodeHeartbeatResponsePBImpl)response).GetProto()); } catch (YarnException e) { throw new ServiceException(e); } catch (IOException e) { throw new ServiceException(e); } }
AddToClusterNodeLabels(RpcController controller, YarnServerResourceManagerServiceProtos.AddToClusterNodeLabelsRequestProto proto) { AddToClusterNodeLabelsRequestPBImpl request = new AddToClusterNodeLabelsRequestPBImpl (proto); try { AddToClusterNodeLabelsResponse response = real.AddToClusterNodeLabels(request); return(((AddToClusterNodeLabelsResponsePBImpl)response).GetProto()); } catch (YarnException e) { throw new ServiceException(e); } catch (IOException e) { throw new ServiceException(e); } }
/// <exception cref="Com.Google.Protobuf.ServiceException"/> public virtual TraceAdminPB.ListSpanReceiversResponseProto ListSpanReceivers(RpcController controller, TraceAdminPB.ListSpanReceiversRequestProto req) { try { SpanReceiverInfo[] descs = server.ListSpanReceivers(); TraceAdminPB.ListSpanReceiversResponseProto.Builder bld = TraceAdminPB.ListSpanReceiversResponseProto .NewBuilder(); for (int i = 0; i < descs.Length; ++i) { bld.AddDescriptions(((TraceAdminPB.SpanReceiverListInfo)TraceAdminPB.SpanReceiverListInfo .NewBuilder().SetId(descs[i].GetId()).SetClassName(descs[i].GetClassName()).Build ())); } return((TraceAdminPB.ListSpanReceiversResponseProto)bld.Build()); } catch (IOException e) { throw new ServiceException(e); } }
/// <exception cref="Com.Google.Protobuf.ServiceException"/> public virtual YarnServerCommonServiceProtos.RegisterNodeManagerResponseProto RegisterNodeManager (RpcController controller, YarnServerCommonServiceProtos.RegisterNodeManagerRequestProto proto) { RegisterNodeManagerRequestPBImpl request = new RegisterNodeManagerRequestPBImpl(proto ); try { RegisterNodeManagerResponse response = real.RegisterNodeManager(request); return(((RegisterNodeManagerResponsePBImpl)response).GetProto()); } catch (YarnException e) { throw new ServiceException(e); } catch (IOException e) { throw new ServiceException(e); } }
/// <exception cref="Com.Google.Protobuf.ServiceException"/> public virtual NamenodeProtocolProtos.GetBlockKeysResponseProto GetBlockKeys(RpcController unused, NamenodeProtocolProtos.GetBlockKeysRequestProto request) { ExportedBlockKeys keys; try { keys = impl.GetBlockKeys(); } catch (IOException e) { throw new ServiceException(e); } NamenodeProtocolProtos.GetBlockKeysResponseProto.Builder builder = NamenodeProtocolProtos.GetBlockKeysResponseProto .NewBuilder(); if (keys != null) { builder.SetKeys(PBHelper.Convert(keys)); } return((NamenodeProtocolProtos.GetBlockKeysResponseProto)builder.Build()); }
/// <exception cref="Com.Google.Protobuf.ServiceException"/> public virtual YarnServiceProtos.ReservationDeleteResponseProto DeleteReservation (RpcController controller, YarnServiceProtos.ReservationDeleteRequestProto requestProto ) { ReservationDeleteRequestPBImpl request = new ReservationDeleteRequestPBImpl(requestProto ); try { ReservationDeleteResponse response = real.DeleteReservation(request); return(((ReservationDeleteResponsePBImpl)response).GetProto()); } catch (YarnException e) { throw new ServiceException(e); } catch (IOException e) { throw new ServiceException(e); } }
/// <exception cref="Com.Google.Protobuf.ServiceException"/> public virtual YarnServiceProtos.FinishApplicationMasterResponseProto FinishApplicationMaster (RpcController arg0, YarnServiceProtos.FinishApplicationMasterRequestProto proto ) { FinishApplicationMasterRequestPBImpl request = new FinishApplicationMasterRequestPBImpl (proto); try { FinishApplicationMasterResponse response = real.FinishApplicationMaster(request); return(((FinishApplicationMasterResponsePBImpl)response).GetProto()); } catch (YarnException e) { throw new ServiceException(e); } catch (IOException e) { throw new ServiceException(e); } }
/// <exception cref="Com.Google.Protobuf.ServiceException"/> public virtual YarnServiceProtos.RunSharedCacheCleanerTaskResponseProto RunCleanerTask (RpcController controller, YarnServiceProtos.RunSharedCacheCleanerTaskRequestProto proto) { RunSharedCacheCleanerTaskRequestPBImpl request = new RunSharedCacheCleanerTaskRequestPBImpl (proto); try { RunSharedCacheCleanerTaskResponse response = real.RunCleanerTask(request); return(((RunSharedCacheCleanerTaskResponsePBImpl)response).GetProto()); } catch (YarnException e) { throw new ServiceException(e); } catch (IOException e) { throw new ServiceException(e); } }
/// <exception cref="Com.Google.Protobuf.ServiceException"/> public virtual DatanodeProtocolProtos.ReportBadBlocksResponseProto ReportBadBlocks (RpcController controller, DatanodeProtocolProtos.ReportBadBlocksRequestProto request ) { IList <HdfsProtos.LocatedBlockProto> lbps = request.GetBlocksList(); LocatedBlock[] blocks = new LocatedBlock[lbps.Count]; for (int i = 0; i < lbps.Count; i++) { blocks[i] = PBHelper.Convert(lbps[i]); } try { impl.ReportBadBlocks(blocks); } catch (IOException e) { throw new ServiceException(e); } return(VoidReportBadBlockResponse); }
/// <exception cref="Com.Google.Protobuf.ServiceException"/> public virtual YarnServerCommonServiceProtos.SCMUploaderCanUploadResponseProto CanUpload (RpcController controller, YarnServerCommonServiceProtos.SCMUploaderCanUploadRequestProto proto) { SCMUploaderCanUploadRequestPBImpl request = new SCMUploaderCanUploadRequestPBImpl (proto); try { SCMUploaderCanUploadResponse response = real.CanUpload(request); return(((SCMUploaderCanUploadResponsePBImpl)response).GetProto()); } catch (YarnException e) { throw new ServiceException(e); } catch (IOException e) { throw new ServiceException(e); } }
/// <exception cref="Com.Google.Protobuf.ServiceException"/> public virtual DatanodeProtocolProtos.BlockReceivedAndDeletedResponseProto BlockReceivedAndDeleted (RpcController controller, DatanodeProtocolProtos.BlockReceivedAndDeletedRequestProto request) { IList <DatanodeProtocolProtos.StorageReceivedDeletedBlocksProto> sBlocks = request .GetBlocksList(); StorageReceivedDeletedBlocks[] info = new StorageReceivedDeletedBlocks[sBlocks.Count ]; for (int i = 0; i < sBlocks.Count; i++) { DatanodeProtocolProtos.StorageReceivedDeletedBlocksProto sBlock = sBlocks[i]; IList <DatanodeProtocolProtos.ReceivedDeletedBlockInfoProto> list = sBlock.GetBlocksList (); ReceivedDeletedBlockInfo[] rdBlocks = new ReceivedDeletedBlockInfo[list.Count]; for (int j = 0; j < list.Count; j++) { rdBlocks[j] = PBHelper.Convert(list[j]); } if (sBlock.HasStorage()) { info[i] = new StorageReceivedDeletedBlocks(PBHelper.Convert(sBlock.GetStorage()), rdBlocks); } else { info[i] = new StorageReceivedDeletedBlocks(sBlock.GetStorageUuid(), rdBlocks); } } try { impl.BlockReceivedAndDeleted(PBHelper.Convert(request.GetRegistration()), request .GetBlockPoolId(), info); } catch (IOException e) { throw new ServiceException(e); } return(VoidBlockReceivedAndDeleteResponse); }
/// <exception cref="Com.Google.Protobuf.ServiceException"/> public virtual GetUserMappingsProtocolProtos.GetGroupsForUserResponseProto GetGroupsForUser (RpcController controller, GetUserMappingsProtocolProtos.GetGroupsForUserRequestProto request) { string[] groups; try { groups = impl.GetGroupsForUser(request.GetUser()); } catch (IOException e) { throw new ServiceException(e); } GetUserMappingsProtocolProtos.GetGroupsForUserResponseProto.Builder builder = GetUserMappingsProtocolProtos.GetGroupsForUserResponseProto .NewBuilder(); foreach (string g in groups) { builder.AddGroups(g); } return((GetUserMappingsProtocolProtos.GetGroupsForUserResponseProto)builder.Build ()); }
/// <exception cref="Com.Google.Protobuf.ServiceException"/> public virtual DatanodeProtocolProtos.CacheReportResponseProto CacheReport(RpcController controller, DatanodeProtocolProtos.CacheReportRequestProto request) { DatanodeCommand cmd = null; try { cmd = impl.CacheReport(PBHelper.Convert(request.GetRegistration()), request.GetBlockPoolId (), request.GetBlocksList()); } catch (IOException e) { throw new ServiceException(e); } DatanodeProtocolProtos.CacheReportResponseProto.Builder builder = DatanodeProtocolProtos.CacheReportResponseProto .NewBuilder(); if (cmd != null) { builder.SetCmd(PBHelper.Convert(cmd)); } return((DatanodeProtocolProtos.CacheReportResponseProto)builder.Build()); }
public ObjectReplicationServerToClient_ClientProxy( RpcController rpc, IPEndPoint connection ) { this.rpc = rpc; this.connection = connection; }
protected RpcChannel(RpcController controller) { this.controller = controller; controller.Channel = this; }
void network_NewConnection(NetworkLevel2Connection net2con, ConnectionInfo connectioninfo) { LogFile.WriteLine("Testnetrpc , new connection " + connectioninfo); RpcController rpc = new RpcController(network); TestController.GetInstance().rpc = rpc; Testing.TestInterface_ClientProxy testinterface_clientproxy = new OSMP.Testing.TestInterface_ClientProxy(rpc, null); testinterface_clientproxy.SayHello(); }
public void Go() { network = new NetworkLevel2Controller(); network.ListenAsServer(serverport); network.NewConnection += new Level2NewConnectionHandler(network_NewConnection); RpcController rpc = new RpcController(network); TestController.GetInstance().rpc = rpc; while (true) { network.Tick(); Thread.Sleep(50); } //Testing.TestInterface_ClientProxy testinterface_clientproxy = new OSMP.Testing.TestInterface_ClientProxy( rpc, }
public LoopbackRpcChannel(RpcController controller) : base(controller) { }
//static NetReplicationController instance = new NetReplicationController(); //public static NetReplicationController GetInstance(){ return instance; } public NetReplicationController( RpcController rpc ) { this.rpc = rpc; referencecontroller = new NetObjectReferenceController(); if (rpc.isserver) { dirtyobjectcontroller = new DirtyObjectController( this, rpc.network, rpc ); } }
public int Init( IConfigSource commandlineConfig, IClientControllers controllers ) { Type type = Type.GetType( "OSMP.ObjectReplicationClientToServer" ); LogFile.WriteLine( "type: [" + type + "] " + type.AssemblyQualifiedName ); //System.Environment.Exit( 0 ); Tao.DevIl.Il.ilInit(); Tao.DevIl.Ilu.iluInit(); config = Config.GetInstance(); string serverip = commandlineConfig.Configs["CommandLineArgs"].GetString( "serverip", config.ServerIPAddress ); int port = commandlineConfig.Configs["CommandLineArgs"].GetInt( "serverport", config.ServerPort ); network = new NetworkLevel2Controller(); network.NewConnection += new Level2NewConnectionHandler(network_NewConnection); network.ConnectAsClient(serverip, port); rpc = new RpcController(network); netreplicationcontroller = new NetReplicationController(rpc); renderer = RendererFactory.GetInstance(); renderer.Tick += new OSMP.TickHandler( MainLoop ); renderer.Init(); worldstorage = new WorldModel(netreplicationcontroller); worldview = new WorldView( worldstorage ); playermovement = PlayerMovement.GetInstance(); InitializePlayermovement(); myavatar = new Avatar(); worldstorage.AddEntity(myavatar); controllers.Plugin.LoadClientPlugins(); if (!commandlineConfig.Configs["CommandLineArgs"].Contains("nochat" )) { LoadChat(); } if( commandlineConfig.Configs["CommandLineArgs"].Contains("url" ) ) { string url = commandlineConfig.Configs["CommandLineArgs"].GetString("url" ); LogFile.WriteLine( "url: " + url); if (url.StartsWith( "osmp://" )) { targettoload = "http://" + url.Substring( "osmp://".Length ); LogFile.WriteLine( "target: " + targettoload ); } else { targettoload = url; } } renderer.StartMainLoop(); return 0; }
public LockRpcToClient_ClientProxy( RpcController rpc, IPEndPoint connection ) { this.rpc = rpc; this.connection = connection; }
//! metaverseserver entry point. Processes commandline arguments; starts dbinterface and serverfileagent components; handles initialization public void Init( IConfigSource commandlineConfig, IServerControllers controllers ) { config = Config.GetInstance(); Test.Info("*** Server starting ***"); Running = true; network = new NetworkLevel2Controller(); ServerPort = commandlineConfig.Configs["CommandLineArgs"].GetInt( "serverport", config.ServerPort ); Test.Debug("Creating Metaverse Client listener on port " + ServerPort ); network.ListenAsServer(ServerPort); network.NewConnection += new Level2NewConnectionHandler(network_NewConnection); network.Disconnection += new Level2DisconnectionHandler(network_Disconnection); rpc = new RpcController(network); netreplicationcontroller = new NetReplicationController( rpc ); World = new WorldModel(netreplicationcontroller); controllers.Plugin.LoadServerPlugins(); Test.Info("*** Server initialization complete ***"); }
public WorldControl_ClientProxy( RpcController rpc, IPEndPoint connection ) { this.rpc = rpc; this.connection = connection; }
public TestInterface_ClientProxy( RpcController rpc, IPEndPoint connection ) { this.rpc = rpc; this.connection = connection; }