private static IObjectServer OpenServer(IServerConfiguration configuration) { IObjectServer server = Db4oClientServer.OpenServer(configuration, DatabaseFileName, PortNumber); server.GrantAccess(UserAndPassword, UserAndPassword); return(server); }
internal void Verify(IServerConfiguration config, IObjectServer server) { Assert.AreSame(config, this._config); Assert.AreSame(server, this._server); Assert.AreEqual(1, this._prepareCount); Assert.AreEqual(1, this._applyCount); }
public HttpServer(IServerConfiguration configuration) { this.Address = configuration.GetAddress(); this.Port = configuration.GetPort(); this.InitBase(); }
public virtual void TestClientServerApi() { IServerConfiguration config = Db4oClientServer.NewServerConfiguration(); IObjectServer server = Db4oClientServer.OpenServer(config, TempFile(), unchecked ( (int)(0xdb40))); try { server.GrantAccess("user", "password"); IClientConfiguration clientConfig = Db4oClientServer.NewClientConfiguration(); IObjectContainer client1 = Db4oClientServer.OpenClient(clientConfig, "localhost", unchecked ((int)(0xdb40)), "user", "password"); try { } finally { Assert.IsTrue(client1.Close()); } } finally { Assert.IsTrue(server.Close()); } }
/// <summary> /// Initializes a new instance of the <see cref="ServerContext"/> class. /// </summary> /// <param name="server">The server.</param> /// <param name="configuration">The configuration.</param> /// <param name="serverSocket">The server socket.</param> internal ServerContext(StandardServer server, IServerConfiguration configuration, Socket serverSocket) { this.ListeningSocket = serverSocket; this.Server = server; this.windowsServer = server; this.Configuration = configuration; }
public static void Setup(IServerConfiguration serverConfiguration) { worldService = Api.Server.World; protoSpawnZone = Api.GetProtoEntity <ZoneSpecialPlayerSpawn>(); serverConfiguration.SetupPlayerCharacterSpawnCallbackMethod( character => SpawnPlayer(character, isRespawn: false)); }
public UserCache( IServerConfiguration serverConfiguration) { _ServerConfiguration = serverConfiguration; _UserAccountCache = new List <CacheItem <UserAccount> >(); }
/// <summary> /// Initializes a new instance of the <see cref="ServerContext"/> class. /// </summary> /// <param name="server">The server.</param> /// <param name="configuration">The configuration.</param> /// <param name="serverSocket">The server socket.</param> internal ServerContext(StandardServer server, IServerConfiguration configuration, Socket serverSocket) { this.ListeningSocket = serverSocket; this.Server = server; this.windowsServer = server; this.Configuration = configuration; }
/// <summary> /// Creates a new session and adds it to the beacon sender. The top level action count is reset to zero and the /// last interaction time is set to the current timestamp. /// <para> /// In case the given <code>initialServerConfig</code> is not null, the new session will be initialized with /// this server configuration. The created session however will not be in state /// <see cref="ISessionState.IsConfigured">configured</see>, meaning new session requests will be performed for /// this session. /// </para> /// <para> /// In case the given <code>updatedServerConfig</code> is not null, the new session will be updated with this /// server configuration. The created session will be in state /// <see cref="ISessionState.IsConfigured">configured</see>, meaning new session requests will be omitted. /// </para> /// </summary> /// <param name="initialServerConfig"> /// the server configuration with which the session will be initialized. Can be <code>null</code> /// </param> /// <param name="updatedServerConfig"> /// the server configuration with which the session will be updated. Can be <code>null</code>. /// </param> /// <returns>the newly created session.</returns> private ISessionInternals CreateSession(IServerConfiguration initialServerConfig, IServerConfiguration updatedServerConfig) { var session = sessionCreator.CreateSession(this); var beacon = session.Beacon; beacon.OnServerConfigurationUpdate += OnServerConfigurationUpdate; ThisComposite.StoreChildInList(session); lastInteractionTime = beacon.SessionStartTime; topLevelActionCount = 0; if (initialServerConfig != null) { session.InitializeServerConfiguration(initialServerConfig); } if (updatedServerConfig != null) { session.UpdateServerConfiguration(updatedServerConfig); } beaconSender.AddSession(session); return(session); }
public override void ServerInitialize(IServerConfiguration serverConfiguration) { if (Api.IsEditor) { return; } var autosaveIntervalMinutes = Api.Server.Core.AutosaveIntervalMinutes; if (autosaveIntervalMinutes < AutosavegameIntervalMinutesMin || autosaveIntervalMinutes > AutosavegameIntervalMinutesMax) { throw new Exception( string.Format("Autosave interval should be in range from {0} to {1} (both inclusive)", AutosavegameIntervalMinutesMin, AutosavegameIntervalMinutesMax)); } Server.Core.AutosaveOnQuit = true; Api.Logger.Important($"Server auto-save enabled. Interval: {autosaveIntervalMinutes} minutes"); framesBetweenAutoSaves = 60 * autosaveIntervalMinutes * ServerGame.FrameRate; SetNextAutoSaveFrameNumber(); TriggerEveryFrame.ServerRegister(Update, "Autosave manager"); }
/// <summary> /// opens the IObjectServer, and waits forever until Close() is called /// or a StopServer message is being received. /// </summary> public void RunServer() { lock (this) { IServerConfiguration config = Db4oClientServer.NewServerConfiguration(); // Using the messaging functionality to redirect all // messages to this.processMessage config.Networking.MessageRecipient = this; IObjectServer db4oServer = Db4oClientServer.OpenServer(config, FILE, PORT); db4oServer.GrantAccess(USER, PASS); try { if (!stop) { // wait forever until Close will change stop variable Monitor.Wait(this); } } catch (Exception e) { Console.WriteLine(e.ToString()); } db4oServer.Close(); } }
private void BuildClientsHandlerConfig(IServerConfiguration clients) { //set up where to bind the listening socket //config for this should already be valid here, of course we can't check yet if the interface actually exists string interfaceAddress = String.Empty; //empty string means bind to * int port = 19333; //default port for (int i = 0; i < m_globalconfiglines.Count; i++) { string line = m_globalconfiglines[i].line; string word; Util.GetWord(ref line, out word); if (word == "interface") { Util.GetWord(ref line, out interfaceAddress); } else if (word == "port") { Util.GetWord(ref line, out word); port = int.Parse(word); } } clients.SetInterface(interfaceAddress, port); }
internal void Verify(IServerConfiguration config, IObjectServer server) { Assert.AreSame(config, _config); Assert.AreSame(server, _server); Assert.AreEqual(1, _prepareCount); Assert.AreEqual(1, _applyCount); }
public override void ServerInitialize(IServerConfiguration serverConfiguration) { var database = Server.Database; if (!database.TryGet(nameof(ChatSystem), "GlobalChatRoomHolder", out sharedGlobalChatRoomHolder)) { sharedGlobalChatRoomHolder = ServerCreateChatRoom(new ChatRoomGlobal()); database.Set(nameof(ChatSystem), "GlobalChatRoomHolder", sharedGlobalChatRoomHolder); } if (!database.TryGet(nameof(ChatSystem), "LocalChatRoomHolder", out sharedLocalChatRoomHolder)) { sharedLocalChatRoomHolder = ServerCreateChatRoom(new ChatRoomLocal()); database.Set(nameof(ChatSystem), "LocalChatRoomHolder", sharedLocalChatRoomHolder); } if (!database.TryGet(nameof(ChatSystem), nameof(serverPrivateChatRooms), out serverPrivateChatRooms)) { serverPrivateChatRooms = new Dictionary<string, Dictionary<string, ILogicObject>>(); database.Set(nameof(ChatSystem), nameof(serverPrivateChatRooms), serverPrivateChatRooms); } }
public RouletteContext(IServerConfiguration ServerConfiguration) { var config = ServerConfiguration.GetMongoDBConfig(); var client = new MongoClient(config.ConnectionString); _db = client.GetDatabase(config.Database); }
/// <summary> /// Constructs a new <see cref="ConsensusServer"/>. /// </summary> /// <param name="configuration">The <see cref="IServerConfiguration"/> of this <see cref="ConsensusServer"/>.</param> /// <param name="log">The <see cref="ILog"/> used by this <see cref="ConsensusServer"/> to store entries in.</param> /// <param name="protocol">The <see cref="IProtocol"/> using by this <see cref="ConsensusServer"/> to communicate with other <see cref="ConsensusServer"/>s in the same cluster.</param> /// <param name="scheduler">The <see cref="IResourceTrackingScheduler"/> on which to execute callbacks.</param> /// <exception cref="ArgumentNullException">Thrown if one of the parameters is null.</exception> public ConsensusServer(IServerConfiguration configuration, ILog log, IProtocol protocol, IResourceTrackingScheduler scheduler) { // validate arguments if (configuration == null) { throw new ArgumentNullException("configuration"); } if (scheduler == null) { throw new ArgumentNullException("scheduler"); } if (log == null) { throw new ArgumentNullException("log"); } if (protocol == null) { throw new ArgumentNullException("protocol"); } // store the arguments this.configuration = configuration; this.scheduler = scheduler; this.log = log; this.protocol = protocol; // create a new state state = new ConsensusServerState(this); }
public virtual void TestMissingClassesInClient() { IList serverMissedClasses = new ArrayList(); IList clientMissedClasses = new ArrayList(); IServerConfiguration serverConfig = Db4oClientServer.NewServerConfiguration(); PrepareHost(serverConfig.File, serverConfig.Common, serverMissedClasses); IObjectServer server = Db4oClientServer.OpenServer(serverConfig, DbUri, Port); server.GrantAccess(User, Password); try { IClientConfiguration clientConfig = Db4oClientServer.NewClientConfiguration(); PrepareCommon(clientConfig.Common, clientMissedClasses); ExcludeClasses(clientConfig.Common, new Type[] { typeof(MissingClassDiagnosticsTestCase.Pilot ), typeof(MissingClassDiagnosticsTestCase.Car) }); IObjectContainer client = Db4oClientServer.OpenClient(clientConfig, "localhost", Port, User, Password); IObjectSet result = client.Query(new MissingClassDiagnosticsTestCase.AcceptAllPredicate ()); IterateOver(result); client.Close(); } finally { server.Close(); } Assert.AreEqual(0, serverMissedClasses.Count); AssertPilotAndCarMissing(clientMissedClasses); }
public static void Main(string[] args) { File.Delete(YapFileName); AccessLocalServer(); File.Delete(YapFileName); using (IObjectContainer db = Db4oEmbedded.OpenFile(YapFileName)) { SetFirstCar(db); SetSecondCar(db); } IServerConfiguration config = Db4oClientServer.NewServerConfiguration(); config.Common.ObjectClass(typeof(Car)).UpdateDepth(3); using (IObjectServer server = Db4oClientServer.OpenServer(config, YapFileName, 0)) { QueryLocalServer(server); DemonstrateLocalReadCommitted(server); DemonstrateLocalRollback(server); } AccessRemoteServer(); using (IObjectServer server = Db4oClientServer.OpenServer(Db4oClientServer.NewServerConfiguration(), YapFileName, ServerPort)) { server.GrantAccess(ServerUser, ServerPassword); QueryRemoteServer(ServerPort, ServerUser, ServerPassword); DemonstrateRemoteReadCommitted(ServerPort, ServerUser, ServerPassword); DemonstrateRemoteRollback(ServerPort, ServerUser, ServerPassword); } }
/// <summary> /// Creates a new session and adds it to the beacon sender. The top level action count is reset to zero and the /// last interaction time is set to the current timestamp. /// <para> /// In case the given <code>initialServerConfig</code> is not null, the new session will be initialized with /// this server configuration. The created session however will not be in state /// <see cref="ISessionState.IsConfigured">configured</see>, meaning new session requests will be performed for /// this session. /// </para> /// <para> /// In case the given <code>updatedServerConfig</code> is not null, the new session will be updated with this /// server configuration. The created session will be in state /// <see cref="ISessionState.IsConfigured">configured</see>, meaning new session requests will be omitted. /// </para> /// </summary> /// <param name="initialServerConfig"> /// the server configuration with which the session will be initialized. Can be <code>null</code> /// </param> /// <param name="updatedServerConfig"> /// the server configuration with which the session will be updated. Can be <code>null</code>. /// </param> private void CreateAndAssignCurrentSession(IServerConfiguration initialServerConfig, IServerConfiguration updatedServerConfig) { var session = sessionCreator.CreateSession(this); var beacon = session.Beacon; beacon.OnServerConfigurationUpdate += OnServerConfigurationUpdate; ThisComposite.StoreChildInList(session); lastInteractionTime = beacon.SessionStartTime; topLevelActionCount = 0; if (initialServerConfig != null) { session.InitializeServerConfiguration(initialServerConfig); } if (updatedServerConfig != null) { session.UpdateServerConfiguration(updatedServerConfig); } lock (lockObject) { // synchronize access currentSession = session; } beaconSender.AddSession(currentSession); }
public override void ServerInitialize(IServerConfiguration serverConfiguration) { if (Api.IsEditor) { return; } var autosaveIntervalMinutes = Api.Server.Core.AutosaveIntervalMinutes; if (autosaveIntervalMinutes < AutosavegameIntervalMinutesMin || autosaveIntervalMinutes > AutosavegameIntervalMinutesMax) { throw new Exception( string.Format("Autosave interval should be in range from {0} to {1} (both inclusive)", AutosavegameIntervalMinutesMin, AutosavegameIntervalMinutesMax)); } Server.Core.AutosaveOnQuit = true; Api.Logger.Important($"Server auto-save enabled. Interval: {autosaveIntervalMinutes} minutes"); serverFramesBetweenAutoSaves = 60 * autosaveIntervalMinutes * ServerGame.FrameRate; SetNextAutoSaveFrameNumber(); // Randomize the next autosave date a bit (up to +60 seconds) // to ensure that if there are several game servers they will not save together // affecting performance of each other. serverNextAutoSaveFrameNumber = (uint)(serverNextAutoSaveFrameNumber + ServerGame.FrameRate * RandomHelper.Next(0, 61)); TriggerEveryFrame.ServerRegister(Instance.Update, "Autosave manager"); }
private static string concurrentBody(ClassDeclarationSyntax @class, IServerConfiguration config, SemanticModel model) { var result = new StringBuilder(); ConcurrentExtension.Visit(@class, methods: (name, type, parameters) => { result.AppendLine(Templates .jsMethod(new { MethodName = name.ToString(), Arguments = argumentsFromParameters(parameters), Data = objectFromParameters(parameters), Path = "'/' + this.__ID + '/" + name.ToString() + "'", Response = calculateResponse(type, model), })); }, fields: (name, type, value) => { //td: shall we transmit properties? //result.AppendLine(Templates // .jsProperty // .Render(new // { // Name = name.ToString(), // Value = valueString(value, type, model) // })); }); return(result.ToString()); }
public IContainer GetContainer(IServerConfiguration configuration) { if(configuration == null) { throw new ArgumentNullException("configuration"); } var containerBuilder = new ContainerBuilder(); containerBuilder.Register(b => Logger.Instance).As<ILogger>(); containerBuilder.RegisterType<ConnectionManager>().As<IConnectionManager>().SingleInstance(); containerBuilder.RegisterType<NodeInitializer>().As<INodeInitializer>().SingleInstance(); containerBuilder.RegisterType<NodeSynchronizer>().As<INodeSynchronizer>().InstancePerDependency(); containerBuilder.RegisterType<MasterElections>().As<IMasterElections>().SingleInstance(); containerBuilder.RegisterType<AggregateRepository>().As<IAggregateRepository>().SingleInstance(); containerBuilder.RegisterType<EventAggregate>().As<IEventAggregate>().InstancePerDependency(); containerBuilder.RegisterInstance(configuration).As<IServerConfiguration>(); var container = containerBuilder.Build(); return container; }
public override void ServerInitialize(IServerConfiguration serverConfiguration) { serverConfiguration.SetupPlayerLoginHook(PlayerLoginHook); serverConfiguration.PlayerRemoteCallRateExceeded += PlayerRemoteCallRateExceededHandler; if (!Database.TryGet(nameof(ServerPlayerAccessSystem), DatabaseKeyKickedPlayersDictionary, out kickedPlayersDictionary)) { kickedPlayersDictionary = new Dictionary <string, KickEntry>(); Database.Set(nameof(ServerPlayerAccessSystem), DatabaseKeyKickedPlayersDictionary, kickedPlayersDictionary); } // fill the legacy lists // TODO: remove once we no longer need this LoadLegacyList(isWhiteList: true); LoadLegacyList(isWhiteList: false); if (Database.TryGet(nameof(ServerPlayerAccessSystem), "IsWhitelistEnabled", out bool legacyIsWhiteListEnabled)) { Database.Remove(nameof(ServerPlayerAccessSystem), "IsWhitelistEnabled"); SetWhitelistMode(legacyIsWhiteListEnabled); }
public virtual void Open() { IServerConfiguration config = Db4oClientServer.NewServerConfiguration(); config.File.Storage = new MemoryStorage(); _server = Db4oClientServer.OpenServer(config, string.Empty, 0); }
public bool BuildConfig(IServerConfiguration clients, IChannelDataProvider channelDataProvider, List <CDevice> devices, List <CLight> lights) { Util.Log("building config"); BuildClientsHandlerConfig(clients); List <CColor> colors = new List <CColor>(); if (!BuildColorConfig(colors)) { return(false); } if (!BuildDeviceConfig(devices, channelDataProvider)) { return(false); } if (!BuildLightConfig(lights, devices, colors)) { return(false); } Util.Log("built config successfully"); return(true); }
public override void ServerInitialize(IServerConfiguration serverConfiguration) { base.ServerInitialize(serverConfiguration); ServerAreasGroupChanged += ServerAreasGroupChangedHandler; ServerBaseBroken += ServerBaseBrokenHandler; FactionSystem.ServerFactionMemberAccessRightsChanged += ServerFactionMemberAccessRightsChangedHandler; FactionSystem.ServerCharacterJoinedOrLeftFaction += ServerCharacterJoinedOrLeftFactionHandler; }
/// <summary> /// Instantiates a new <see cref="BasicServerBase"/>. /// </summary> /// <param name="channelAddress">The client's address.</param> /// <param name="configuration">The client's configuration.</param> /// <param name="transportController">Controls the transportation layer.</param> /// <param name="logSourceId">The value used for the <see cref="Logging.ILogEntry.SourceId"/> when generating <see cref="Logging.ILog"/>s.</param> protected BasicServerBase(IChannelAddress channelAddress, IServerConfiguration configuration, ITransportController transportController, string logSourceId) : this() { Initialize(channelAddress, configuration, transportController, logSourceId); }
public override void ServerInitialize(IServerConfiguration serverConfiguration) { // invoke world init with some small delay because the world objects are not yet loaded // (that's the bootstrapper!) ServerTimersSystem.AddAction( delaySeconds: 0.1, () => Api.GetProtoEntity <TriggerWorldInit>().OnWorldInit()); }
public override void ServerInitialize(IServerConfiguration serverConfiguration) { Logger.Important("Farm plants growth speed multiplier: " + ServerFarmPlantsGrowthSpeedMultiplier.ToString("0.###") + Environment.NewLine + "Farm plants spoil speed multiplier: " + SharedFarmPlantsSpoilSpeedMultiplier.ToString("0.###")); }
public PermissionProvider( IServerConfiguration serverConfiguration , IUserCache userCache) { _ServerConfiguration = serverConfiguration; _UserCache = userCache; _AdministratorPermission = _ServerConfiguration.AdministratorPermissionName; }
public static Configure Db4oHostedDatabase(this Configure config, ICurrentSessionContext currentSessionContext, IServerConfiguration serverConfig, string dbFileName, int port, params HostedServerSessionFactory.Access[] access) { var sessionFactory = new HostedServerSessionFactory(currentSessionContext, serverConfig, dbFileName, port, access); config.Configurer.RegisterSingleton<ISessionFactory>(sessionFactory); return config; }
public override void ServerInitialize(IServerConfiguration serverConfiguration) { Server.Characters.PlayerOnlineStateChanged += ServerPlayerOnlineStateChangedHandler; Server.Characters.PlayerNameChanged += ServerPlayerNameChangedHandler; Server.World.WorldBoundsChanged += ServerLoadSystem; ServerTimersSystem.AddAction(0, ServerLoadSystem); }
public override void ServerInitialize(IServerConfiguration serverConfiguration) { Server.Characters.PlayerOnlineStateChanged += ServerPlayerOnlineStateChangedHandler; Server.Characters.PlayerNameChanged += ServerPlayerNameChangedHandler; Server.World.WorldBoundsChanged += this.ServerWorldBoundsChangedHandler; ServerLoadSystem(); }
/// <exception cref="System.Exception"></exception> public virtual void SetUp() { IServerConfiguration config = Db4oClientServer.NewServerConfiguration(); config.File.Storage = new MemoryStorage(); this.server = Db4oClientServer.OpenServer(config, "InMemory:File", Port); this.server.GrantAccess(UsernameAndPassword, UsernameAndPassword); }
public PresentationExportHelper(IServerConfiguration config, IPresentationDAL presentationDAL) { _config = config; _presentationDAL = presentationDAL; _serverSidePresentationSchemaTransfer = new ServerSideGroupFileTransfer( config.ScenarioFolder, new ServerSideGroupFileSourceEx(config.ScenarioFolder)); _serverSidePresentationTransfer = new ServerSideGroupFileTransfer( _config.ScenarioFolder, new ServerSideGroupFileSourceEx(_config.ScenarioFolder)); }
public HttpResourceHandler(string method, string path, IServerConfiguration serverConfiguration) { _method = method; _path = path; _pipeline = new HttpHandler(serverConfiguration); _comparison = StringComparison.CurrentCulture; ServerConfiguration = serverConfiguration; AuthenticationScheme = AuthenticationSchemes.Anonymous; }
public ProxyController(IHgServer hgServer, IServerConfiguration configuration, IDeploymentManager deploymentManager, IRepositoryManager repositoryManager) { _hgServer = hgServer; _configuration = configuration; _deploymentManager = deploymentManager; _repositoryManager = repositoryManager; }
private async Task FinalizeConfiguration() { // Configure the server this.Configuration = this.CreateServerConfiguration(); // Setup the server security, create the server and start it up. IEnumerable<ISecurityRole> roles = await this.Configuration.InitializeSecurityRoles(); this.RegisterAllowedSecurityRoles(roles); await this.PrepareServerForRunning(); }
/// <summary> /// Allows configuration of the server and opening to the outside /// </summary> public HostedServerSessionFactory(ICurrentSessionContext currentSessionContext, IServerConfiguration config, string dbFileName, int port, params Access[] access) : base(currentSessionContext) { _server = Db4oClientServer.OpenServer(config, dbFileName, port); foreach(var account in access) { _server.GrantAccess(account.Username,account.Password); } }
public LoginService(IServerConfiguration configuration) { _configuration = configuration; _loginStorage = new LoginStorage(_configuration); _store = NotificationManager<LoginService>.Instance.RegisterDuplexService<UserIdentity, ILoginNotifier>( NotifierBehaviour.OneInstance); _loginStorage.OnAddItem += new EventHandler<KeyCollection<UserIdentity>.KeyEventArgs>(_loginStorage_OnAddItem); _loginStorage.OnRemoveItem += new EventHandler<KeyCollection<UserIdentity>.KeyEventArgs>(_loginStorage_OnRemoveItem); }
public ProxyService(IHgServer hgServer, IServerConfiguration configuration, IDeploymentManager deploymentManager, IServerRepository severRepository) { _hgServer = hgServer; _configuration = configuration; _deploymentManager = deploymentManager; _severRepository = severRepository; }
public ManagedSocketAdapter( Socket connection, IServerConfiguration configuration ) { Id = Guid.NewGuid().ToString(); Configuration = configuration; Connection = connection; Bytes = new byte[configuration.ReadBufferSize]; OnDisconnect = new List<Action>(); SocketStream = GetStream( connection ); }
//private readonly ISystemParametersAdapter _systemParameters; public AdministrationService(IServerConfiguration serviceConfiguration, ILoginService loginService, IPresentationWorker worker) { Debug.Assert(serviceConfiguration != null, "IServerConfiguration не может быть null"); Debug.Assert(loginService != null, "ILoginService не может быть null"); Debug.Assert(worker != null, "IPresentationWorker не может быть null"); _serviceConfiguration = serviceConfiguration; _loginService = loginService; _worker = worker; //_systemParameters = new SystemParametersAdapter(); }
public LiveScmController(ITracer tracer, IOperationLock deploymentLock, IEnvironment environment, IRepository repository, IServerConfiguration serverConfiguration) { _tracer = tracer; _deploymentLock = deploymentLock; _environment = environment; _repository = repository; _serverConfiguration = serverConfiguration; }
public ManagedSocketListener( IScheduler scheduler, IEndpointConfiguration endpoint, IServerConfiguration configuration ) { try { Scheduler = scheduler; Configuration = configuration; Connection = Bind( endpoint ); } catch (Exception ex) { Console.WriteLine( ex ); } }
public IServerConfiguration ConfigurarPersistenciaEntidades( IServerConfiguration configuracion ) { //configuracion.Common.ObjectClass( typeof( Proyecto )).CascadeOnUpdate( true ); configuracion.Common.ObjectClass( typeof( Bugtracker ) ).UpdateDepth( 5 ); configuracion.Common.ObjectClass( typeof( Bugtracker ) ).CascadeOnUpdate( true ); //((Db4objects.Db4o.Config.IConfiguration) test ).ClassActivationDepthConfigurable //configuracion.Common.ObjectClass( typeof( Bugtracker ) ).MinimumActivationDepth( 100); configuracion.Common.ObjectClass( typeof( Proyecto ) ).UpdateDepth( 10 ); return configuracion; }
public LiveScmController(ITracer tracer, IOperationLock deploymentLock, IEnvironment environment, IRepositoryFactory repositoryFactory, IServerConfiguration serverConfiguration, IDeploymentStatusManager status) { _tracer = tracer; _deploymentLock = deploymentLock; _environment = environment; _repository = repositoryFactory.GetGitRepository(); _serverConfiguration = serverConfiguration; _status = status; }
public Win32SocketAdapter( IEndpointConfiguration endpoint, IServerConfiguration configuration ) { try { Configuration = configuration; Connection = Bind( endpoint ); Bytes = new byte[configuration.ReadBufferSize]; OnDisconnect = new List<Action>(); } catch (Exception ex) { Console.WriteLine( ex ); } }
public DesignerService(IServerConfiguration config, PresentationWorker worker, ILoginService loginService, IAdministrationService administrationService) { Debug.Assert(config != null, "IServerConfiguration не может быть null"); Debug.Assert(worker != null, "IPresentationWorker не может быть null"); Debug.Assert(loginService != null, "ILoginService не может быть null"); Debug.Assert(administrationService != null, "IAdministrationService не может быть null"); _config = config; _loginService = loginService; _presentationWorker = worker; _administrationService = administrationService; _configFileExportHelper = new ConfigurationExportHelper(config); }
/// <exception cref="Db4objects.Db4o.Ext.Db4oIOException"></exception> /// <exception cref="Db4objects.Db4o.Ext.IncompatibleFileFormatException"></exception> /// <exception cref="Db4objects.Db4o.Ext.OldFormatException"></exception> /// <exception cref="Db4objects.Db4o.Ext.DatabaseFileLockedException"></exception> /// <exception cref="Db4objects.Db4o.Ext.DatabaseReadOnlyException"></exception> public virtual IObjectServer OpenServer(IServerConfiguration config, string databaseFileName , int port) { LocalObjectContainer container = (LocalObjectContainer)Db4oFactory.OpenFile(AsLegacy (config), databaseFileName); if (container == null) { return null; } lock (container.Lock()) { return new ObjectServerImpl(container, config, port); } }
public void Initialize(IServerConfiguration configuration) { var netPeerConfiguration = new NetPeerConfiguration("LidgrenConfig"); netPeerConfiguration.Port = configuration.Port; netPeerConfiguration.DisableMessageType(NetIncomingMessageType.UnconnectedData); netPeerConfiguration.DisableMessageType(NetIncomingMessageType.DiscoveryRequest); netPeerConfiguration.DisableMessageType(NetIncomingMessageType.DiscoveryResponse); server = new NetServer(netPeerConfiguration); Reader = new LidgrenMessageReader(server); Writer = new LidgrenMessageWriter(server); connections.Clear(); }
/// <summary> /// Constructs a new <see cref="ConsensusServer"/>. /// </summary> /// <param name="configuration">The <see cref="IServerConfiguration"/> of this <see cref="ConsensusServer"/>.</param> /// <param name="log">The <see cref="ILog"/> used by this <see cref="ConsensusServer"/> to store entries in.</param> /// <param name="protocol">The <see cref="IProtocol"/> using by this <see cref="ConsensusServer"/> to communicate with other <see cref="ConsensusServer"/>s in the same cluster.</param> /// <param name="scheduler">The <see cref="IResourceTrackingScheduler"/> on which to execute callbacks.</param> /// <exception cref="ArgumentNullException">Thrown if one of the parameters is null.</exception> public ConsensusServer(IServerConfiguration configuration, ILog log, IProtocol protocol, IResourceTrackingScheduler scheduler) { // validate arguments if (configuration == null) throw new ArgumentNullException("configuration"); if (scheduler == null) throw new ArgumentNullException("scheduler"); if (log == null) throw new ArgumentNullException("log"); if (protocol == null) throw new ArgumentNullException("protocol"); // store the arguments this.configuration = configuration; this.scheduler = scheduler; this.log = log; this.protocol = protocol; // create a new state state = new ConsensusServerState(this); }
public BackgroundPresentationManager(IServerConfiguration config, IPresentationWorker worker, PresentationShowPreparator preparator, DisplayAndEquipmentMonitor monitor, IShowDisplayAndDeviceCommand showDisplayAndDeviceCommand, UserIdentity systemUser) { _config = config; _showPreparator = preparator; _monitor = monitor; _worker = worker; _showDisplayAndDeviceCommand = showDisplayAndDeviceCommand; _systemUser = systemUser; _restoreShowTimer = new Timer(RestoreShow); TimeSpan interval =TimeSpan.FromSeconds(BackgroundPresentationRestoreTimeout); _backgroundPresentationChange = new Timer(MonitorForBackgroundPresentation, null, interval, interval); // мониторинг оборудования _monitor.OnStateChange += new EventHandler<TechnicalServices.Interfaces.ConfigModule.Server.EqiupmentStateChangeEventArgs>(_monitor_OnStateChange); // мониторинг изменения в фоновом сценарии _worker.OnPresentationChanged += new EventHandler<PresentationChangedEventArgs>(_worker_OnPresentationChanged); }
public void Prepare(IServerConfiguration configuration) { this._config = configuration; this._prepareCount++; }
public ObjectServerImpl(LocalObjectContainer container, IServerConfiguration serverConfig , int port) : this(container, (ServerConfigurationImpl)serverConfig, (port < 0 ? 0 : port), port == 0) { }
public void Prepare(IServerConfiguration configuration) { }
protected virtual void ValidateConfiguration(IServerConfiguration config) { if (ListenPort < 1) throw new ServiceConfigurationException("ListenPort must be > 0."); if (String.IsNullOrEmpty(Db4oFileName)) throw new ServiceConfigurationException("Missing file name."); if (String.IsNullOrEmpty(ClientUsername)) throw new ServiceConfigurationException("Missing ClientUsername."); }
protected virtual void InitializeExtendedConfiguration(IServerConfiguration config) { config.Networking.MessageRecipient = this; }
public SocketServer( IServerConfiguration configuration, IListenerFactory listenerFactory, IScheduler scheduler ) { Configuration = configuration; Scheduler = scheduler; ListenerFactory = listenerFactory; }
/// <summary> /// opens an /// <see cref="Db4objects.Db4o.IObjectServer">IObjectServer</see> /// on the specified database file and port. /// <br /><br /> /// </summary> /// <param name="config"> /// a custom /// <see cref="Db4objects.Db4o.CS.Config.IServerConfiguration">Db4objects.Db4o.CS.Config.IServerConfiguration /// </see> /// instance to be obtained via /// <see cref="NewServerConfiguration()">NewServerConfiguration()</see> /// </param> /// <param name="databaseFileName">an absolute or relative path to the database file</param> /// <param name="port"> /// the port to be used or 0 if the server should not open a port, specify a value < 0 if an arbitrary free port should be chosen - see /// <see cref="ExtObjectServer#port()">ExtObjectServer#port()</see> /// . /// </param> /// <returns> /// an /// <see cref="Db4objects.Db4o.IObjectServer">IObjectServer</see> /// listening /// on the specified port. /// </returns> /// <seealso cref="Configuration#readOnly">Configuration#readOnly</seealso> /// <seealso cref="Configuration#encrypt">Configuration#encrypt</seealso> /// <seealso cref="Configuration#password">Configuration#password</seealso> /// <exception cref="Db4oIOException">I/O operation failed or was unexpectedly interrupted. /// </exception> /// <exception cref="DatabaseFileLockedException"> /// the required database file is locked by /// another process. /// </exception> /// <exception cref="IncompatibleFileFormatException"> /// runtime /// <see cref="Db4objects.Db4o.Config.IConfiguration">configuration</see> /// is not compatible /// with the configuration of the database file. /// </exception> /// <exception cref="OldFormatException"> /// open operation failed because the database file /// is in old format and /// <see cref="Db4objects.Db4o.Config.IConfiguration.AllowVersionUpdates(bool)">Db4objects.Db4o.Config.IConfiguration.AllowVersionUpdates(bool) /// </see> /// /// is set to false. /// </exception> /// <exception cref="DatabaseReadOnlyException">database was configured as read-only. /// </exception> public static IObjectServer OpenServer(IServerConfiguration config, string databaseFileName , int port) { return config.Networking.ClientServerFactory.OpenServer(config, databaseFileName, port); }