/// <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(); } }
public void SetupContext() { CurrentSessionContext = new ThreadStaticCurrentSessionContext(); Server = Db4oClientServer.OpenServer(Db4oClientServer.NewServerConfiguration(), "RemoteServerTestDb.yap", Port); Server.GrantAccess(Username,Password); SessionFactory = new RemoteServerSessionFactory(CurrentSessionContext,Host, Port, Username, Password); }
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); } }
protected virtual IObjectContainer OpenClient(string clientId, IObjectServer server ) { server.GrantAccess(clientId, "p"); return(Db4oClientServer.OpenClient(MultithreadedClientConfig(), "127.0.0.1", server .Ext().Port(), clientId, "p")); }
private static IObjectServer OpenServer(IServerConfiguration configuration) { IObjectServer server = Db4oClientServer.OpenServer(configuration, DatabaseFileName, PortNumber); server.GrantAccess(UserAndPassword, UserAndPassword); return(server); }
private static void UseEventsToRefreshObjects() { CleanUp(); using (IObjectServer server = OpenServer()) { server.GrantAccess(UsertNameAndPassword, UsertNameAndPassword); StoreJoeOnOtherClient(); IObjectContainer client = OpenClient(); RegisterEvent(client); List <Person> allPersons = ListAllPersons(client); PrintPersons(allPersons); UpdateJoeOnOtherClient(); // the events are asynchronously transported over the network // which takes a while WaitForALittleWhile(); PrintPersons(allPersons); WaitForALittleWhile(); } CleanUp(); }
private void WithDatabase(string file, IFunction4 function) { Configure(); IExtObjectContainer objectContainer = Db4oFactory.OpenFile(file).Ext(); try { function.Apply(objectContainer); } finally { objectContainer.Close(); } IObjectServer server = Db4oFactory.OpenServer(ClientServerFileName(file), -1); server.GrantAccess(Username, Password); objectContainer = Db4oFactory.OpenClient("localhost", server.Ext().Port(), Username , Password).Ext(); try { function.Apply(objectContainer); } finally { objectContainer.Close(); server.Close(); } }
protected virtual void InitializeAccessControl(IObjectServer db4oServer) { if (!String.IsNullOrEmpty(ClientUsername)) { db4oServer.GrantAccess(ClientUsername, ClientPassword); } }
private static void RefreshOnDemand() { CleanUp(); using (IObjectServer server = OpenServer()) { server.GrantAccess(UsertNameAndPassword, UsertNameAndPassword); StoreJoeOnOtherClient(); IObjectContainer client = OpenClient(); IList <Person> allPersons = ListAllPersons(client); PrintPersons(allPersons); UpdateJoeOnOtherClient(); // the persons are not in the most current state PrintPersons(allPersons); // but you can explicitly refresh the objects Refresh(client, allPersons); PrintPersons(allPersons); WaitForALittleWhile(); } CleanUp(); }
/// <exception cref="System.Exception"></exception> public virtual void Test() { IObjectServer server = Db4oClientServer.OpenServer(TempFile(), Db4oClientServer.ArbitraryPort ); server.GrantAccess(string.Empty, string.Empty); IObjectContainer client = Db4oClientServer.OpenClient("localhost", ((ObjectServerImpl )server).Port(), string.Empty, string.Empty); IObjectContainer client2 = Db4oClientServer.OpenClient("localhost", ((ObjectServerImpl )server).Port(), string.Empty, string.Empty); client.Commit(); client2.Commit(); try { server.Close(); } finally { try { client.Close(); client2.Close(); } catch (Db4oException) { } } }
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()); } }
protected virtual IObjectContainer OpenClient(string clientId, IObjectServer server ) { server.GrantAccess(clientId, "p"); return Db4oClientServer.OpenClient(MultithreadedClientConfig(), "127.0.0.1", server .Ext().Port(), clientId, "p"); }
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); }
private static IObjectServer StartServer() { IObjectServer server = Db4oClientServer.OpenServer("In:Memory", Port); server.GrantAccess(UserAndPassword, UserAndPassword); return(server); }
protected override void StartServer() { var databasePath = InitDatabaseFile(); _server = Db4oClientServer.OpenServer(databasePath, Port); _server.GrantAccess(USER_NAME, USER_PWD); _server.Ext().Configure().ClientServer().SetMessageRecipient(this); }
private IObjectServer OpenServer() { IObjectServer server = Db4oClientServer.OpenServer(Db4oClientServer.NewServerConfiguration (), TempFile(), -1); server.GrantAccess(Username, Password); return(server); }
/// <exception cref="System.Exception"></exception> private void OpenServerFor(IDb4oTestCase testInstance) { _serverConfig = ServerConfigFor(testInstance); _server = _csFactory.OpenServer(AsServerConfiguration(_serverConfig), _file.GetAbsolutePath (), -1); _port = _server.Ext().Port(); _server.GrantAccess(Username, Password); }
public virtual void Open() { IServerConfiguration config = Db4oClientServer.NewServerConfiguration(); config.File.Storage = new MemoryStorage(); _server = Db4oClientServer.OpenServer(config, string.Empty, Db4oClientServer.ArbitraryPort ); _server.GrantAccess(User, Pass); }
public virtual void Open() { IServerConfiguration config = Db4oClientServer.NewServerConfiguration(); config.File.Storage = new MemoryStorage(); _server = Db4oClientServer.OpenServer(config, string.Empty, Db4oClientServer.ArbitraryPort ); _server.GrantAccess(User, Pass); }
protected override void StartServer() { var databasePath = InitDatabaseFile(); _server = Db4oClientServer.OpenServer(databasePath, Port); _server.GrantAccess(USER_NAME, USER_PWD); _server.Ext().Configure().ClientServer().SetMessageRecipient(this); }
private static void RunClientServer() { using (IObjectServer server = Db4oClientServer.OpenServer("database.db4o", 8080)) { server.GrantAccess("user", "password"); OpenClient(); } }
public static void Main(string[] args) { using (IObjectServer server = Db4oClientServer.OpenServer("database.db4o", Port)) { server.GrantAccess(UserAndPassword, UserAndPassword); GrabSemaphore(); TryGrabSemaphore(); } }
private static IObjectServer CreateInMemoryServer() { IServerConfiguration config = Db4oClientServer.NewServerConfiguration(); config.File.Storage = new MemoryStorage(); IObjectServer server = Db4oClientServer.OpenServer(config, "In:Memory", Port); server.GrantAccess(UserAndPassword, UserAndPassword); return(server); }
public override void Open() { Config().MessageLevel(-1); _server = Db4oClientServer.OpenServer(Db4oClientServerLegacyConfigurationBridge.AsServerConfiguration (CloneConfiguration()), testFile.GetPath(), _port); _server.GrantAccess(Username, Password); _db = Db4oClientServer.OpenClient(Db4oClientServerLegacyConfigurationBridge.AsClientConfiguration (CloneConfiguration()), Host, _port, Username, Password).Ext(); _provider = Db4oProviderFactory.NewInstance(_db, _name); }
public override void Open() { Config().MessageLevel(-1); _server = Db4oClientServer.OpenServer(Db4oClientServerLegacyConfigurationBridge.AsServerConfiguration (CloneConfiguration()), testFile.GetPath(), _port); _server.GrantAccess(Username, Password); _db = Db4oClientServer.OpenClient(Db4oClientServerLegacyConfigurationBridge.AsClientConfiguration (CloneConfiguration()), Host, _port, Username, Password).Ext(); _provider = Db4oProviderFactory.NewInstance(_db, _name); }
/// <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 bool Start() { if (IsRunning) { throw new ArgumentException("Storage server already started."); } EvaluateConnectionProperties(); _server = Db4oFactory.OpenServer(Connection.File, Connection.HostPort); _server.GrantAccess(Connection.User, Connection.Password); return(true); }
private static IObjectServer OpenDatabaseServer(string fileName) { IServerConfiguration configuration = Db4oClientServer.NewServerConfiguration(); configuration.File.GenerateUUIDs = ConfigScope.Globally; configuration.File.GenerateCommitTimestamps = true; IObjectServer srv = Db4oClientServer.OpenServer(configuration, fileName, Port); srv.GrantAccess(UserName, UserName); return(srv); }
public override void SetUp() { Db4oPerformanceCounterInstaller.ReInstall(); var serverConfiguration = Db4oClientServer.NewServerConfiguration(); serverConfiguration.AddConfigurationItem(new ClientConnectionsMonitoringSupport()); serverConfiguration.AddConfigurationItem(new ConnectionCloseEventSupport(ClientDisconnected)); _server = Db4oClientServer.OpenServer(serverConfiguration, TempFile(), Db4oClientServer.ArbitraryPort); _server.GrantAccess(UserName, Password); }
public static void AccessRemoteServer() { using (IObjectServer server = Db4oClientServer.OpenServer(YapFileName, ServerPort)) { server.GrantAccess(ServerUser, ServerPassword); using (IObjectContainer client = Db4oClientServer.OpenClient("localhost", ServerPort, ServerUser, ServerPassword)) { // Do something with this client, or open more clients } } }
public static void Main(string[] args) { // #example: Start a db4o server using (IObjectServer server = Db4oClientServer.OpenServer("database.db4o", 8080)) { server.GrantAccess("user", "password"); // Let the server run. LetServerRun(); } // #end example }
public override void SetUp() { Db4oPerformanceCounterInstaller.ReInstall(); var serverConfiguration = Db4oClientServer.NewServerConfiguration(); serverConfiguration.AddConfigurationItem(new ClientConnectionsMonitoringSupport()); serverConfiguration.AddConfigurationItem(new ConnectionCloseEventSupport(ClientDisconnected)); _server = Db4oClientServer.OpenServer(serverConfiguration, TempFile(), Db4oClientServer.ArbitraryPort); _server.GrantAccess(UserName, Password); }
public static void Main(string[] args) { CleanUp(); using (IObjectServer server = Db4oClientServer.OpenServer(DatabaseFile, 1337)) { server.GrantAccess("sa", "sa"); StoreData(server); ReferenceCacheExample(); UnitOfWork(); } }
private static IObjectServer StartUpServer() { // #example: configure a message receiver for the server IServerConfiguration configuration = Db4oClientServer.NewServerConfiguration(); configuration.Networking.MessageRecipient = new ServerMessageReceiver(); IObjectServer server = Db4oClientServer.OpenServer(configuration, DatabaseFile, PortNumber); // #end example server.GrantAccess(UserAndPassword, UserAndPassword); return(server); }
public virtual void Run() { //store IServerConfiguration conf = Db4oClientServer.NewServerConfiguration(); IObjectServer server = Db4oClientServer.OpenServer(conf, File, Port); server.GrantAccess("db4o", "db4o"); //store //update //assert server.Close(); }
public object Apply(object config) { IConfiguration serverConfig = Db4oFactory.NewConfiguration(); serverConfig.Storage = new MemoryStorage(); IObjectServer server = this._enclosing.OpenServer(serverConfig, ".", -1); server.GrantAccess("user", "password"); IObjectContainer client = this._enclosing.OpenClient(((IConfiguration)config), "localhost" , server.Ext().Port(), "user", "password"); return(new _IRunnable_42(client, server)); }
/// <summary> /// opens the IObjectServer, and waits forever until Close() is called /// or a StopServer message is being received. /// </summary> public void RunServer() { Console.WriteLine("Server starting"); lock (this) { // Using the messaging functionality to redirect all // messages to this.processMessage IConfiguration configuration = Db4oFactory.NewConfiguration(); configuration.ClientServer().SetMessageRecipient(this); configuration.Add(new TransparentActivationSupport()); configuration.Add(new TransparentPersistenceSupport()); server = Db4oFactory.OpenServer(configuration, FileName, Port); server.GrantAccess(User, Password); server.GrantAccess("server", "serverpass"); Console.WriteLine("Server started"); client = Db4oFactory.OpenClient(Host, Port, "server", "serverpass"); try { if (!stop) { // wait forever until Close will change stop variable Console.WriteLine("Server waiting..."); Monitor.Wait(this); } } catch (Exception e) { Console.WriteLine(e.ToString()); } server.Close(); Console.WriteLine("Server closed"); } }
private IObjectContainer OpenContainer() { string user = "******"; string password = "******"; _server = Db4oClientServer.OpenServer(((IServerConfiguration)Configure(Db4oClientServer .NewServerConfiguration(), "db4o server(" + DatabaseFileName + ")")), DatabaseFileName , Db4oClientServer.ArbitraryPort); _server.GrantAccess(user, password); return Db4oClientServer.OpenClient(((IClientConfiguration)Configure(Db4oClientServer .NewClientConfiguration(), "db4o client(localhost:" + _server.Ext().Port() + ")" )), "localhost", _server.Ext().Port(), user, password); return Db4oEmbedded.OpenFile(((IEmbeddedConfiguration)Configure(Db4oEmbedded.NewConfiguration (), "db4o(" + DatabaseFileName + ")")), DatabaseFileName); }
/// <summary> /// Starts the server. /// </summary> /// <exception cref="InvalidOperationException">Thrown if the server has already been started.</exception> /// <exception cref="ObjectDisposedException">Thrown if the server has been disposed.</exception> /// <exception cref="AmbienceException">Thrown if the operation failed.</exception> public void Start() { ThrowIfDisposed(); Directory.CreateDirectory(Path.GetDirectoryName(databasePath)); try { IConfiguration db4oConfig = Db4oFactory.NewConfiguration(); db4oServer = Db4oFactory.OpenServer(db4oConfig, databasePath, configuration.Port); db4oServer.GrantAccess(configuration.Credential.UserName, configuration.Credential.Password); } catch (Db4oException ex) { throw new AmbienceException("An error occurred while starting the server.", ex); } }
public void StartServer() { _databaseInstance = Db4oFactory.OpenServer(_databaseFile, _databasePort); _databaseInstance.GrantAccess(_databaseUser, _databasePassword); _databaseUp = true; }
/// <exception cref="System.Exception"></exception> private void OpenServerFor(IDb4oTestCase testInstance) { _serverConfig = ServerConfigFor(testInstance); _server = _csFactory.OpenServer(AsServerConfiguration(_serverConfig), _file.GetAbsolutePath (), -1); _port = _server.Ext().Port(); _server.GrantAccess(Username, Password); }
protected virtual void InitializeAccessControl(IObjectServer db4oServer) { if (!String.IsNullOrEmpty(ClientUsername)) db4oServer.GrantAccess(ClientUsername, ClientPassword); }
/// <summary> /// Opens a connection to the database file. /// </summary> /// <remarks>The <c>Open</c> method assumes that the connection string will /// contain user credentials which are used when calling the /// <see cref="Db4objects.Db4o.CS.Db4oClientServer"/> <c>GrantAccess</c> method.</remarks> /// <exception cref="System.Exception">Throws when the singleton /// is already initialized.</exception> public void Open() { if (_databaseServer != null) { throw new Exception("Server is running"); } var userInfo = _connectionString.UserInfo.Split(new char[] { ':' }); _user = new GenericIdentity(userInfo[0]); _config = Db4oClientServer.NewServerConfiguration(); _databaseServer = Db4oClientServer.OpenServer(_connectionString.AbsolutePath, _connectionString.Port); _databaseServer.GrantAccess(userInfo[0], userInfo[1]); }