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);
}
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 IObjectContainer OpenClient(string clientId, IObjectServer server
)
{
server.GrantAccess(clientId, "p");
return Db4oClientServer.OpenClient(MultithreadedClientConfig(), "127.0.0.1", server
.Ext().Port(), clientId, "p");
}
protected override void StartServer()
{
var databasePath = InitDatabaseFile();
_server = Db4oClientServer.OpenServer(databasePath, Port);
_server.GrantAccess(USER_NAME, USER_PWD);
_server.Ext().Configure().ClientServer().SetMessageRecipient(this);
}
/// <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);
}
private void InitServer()
{
try
{
lock (this)
{
IObjectServer server = Db4oFactory.OpenServer(MiCliente.File, Convert.ToInt32(MiCliente.Port));
if (ValidoUsuario())
{
AgregoUsuarios(ref server);
server.Ext().Configure().AddAlias(new WildcardAlias("JerarquiaCheckList.*", "JerarquiaCheckList.*,JerarquiaCheckList"));
server.Ext().Configure().ClientServer().SetMessageRecipient(this);
try
{
while (!stop)
{
Monitor.Wait(this);/*wait 60000 ??*/
}
}
catch (ThreadInterruptedException)
{
server.Close();
stop = true;
}
finally
{
server.Close();
stop = true;
}
}
else
{
server.Close();
stop = true;
if (pub != null)
{
pub.SinAcceso();
}
}
}
}
catch (DatabaseFileLockedException)
{//¿Que puedo hacer
}
}
private static void RegisterForEventsOnTheServer()
{
// #example: register for events on the server
IObjectServer server =
Db4oClientServer.OpenServer(DatabaseFileName, PortNumber);
IEventRegistry eventsOnServer =
EventRegistryFactory.ForObjectContainer(server.Ext().ObjectContainer());
// #end example
}
protected override void StartServer()
{
var databasePath = InitDatabaseFile();
_server = Db4oClientServer.OpenServer(databasePath, Port);
_server.GrantAccess(USER_NAME, USER_PWD);
_server.Ext().Configure().ClientServer().SetMessageRecipient(this);
}
public virtual void TestIsNotAlive()
{
IObjectServer server = OpenServer();
int port = server.Ext().Port();
ClientObjectContainer client = OpenClient(port);
server.Close();
Assert.IsFalse(client.IsAlive());
client.Close();
}
public void Apply(IObjectServer server)
{
PerformanceCounter clientConnections = null;
ObjectContainerBase container = (ObjectContainerBase) server.Ext().ObjectContainer();
container.WithEnvironment(delegate
{
clientConnections = Db4oClientServerPerformanceCounters.CounterForNetworkingClientConnections(server);
});
ServerEventsFor(server).Closed += delegate { clientConnections.RemoveInstance();};
}
public void Apply(IObjectServer server)
{
PerformanceCounter clientConnections = null;
ObjectContainerBase container = (ObjectContainerBase)server.Ext().ObjectContainer();
container.WithEnvironment(delegate
{
clientConnections = Db4oClientServerPerformanceCounters.CounterForNetworkingClientConnections(server);
});
ServerEventsFor(server).Closed += delegate { clientConnections.RemoveInstance(); };
}
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));
}
private void CopyToFileDataBase()
{
if (!UseMemoryStorage)
{
return;
}
var containerExt = _emmbededServer.Ext().ObjectContainer().Ext();
containerExt.Backup(new FileStorage(), DataBaseFilePath);
DefragFileDataBase();
}
/// <exception cref="System.IO.IOException"></exception>
public virtual void Test()
{
string user = "******";
string password = "******";
IObjectServer server = ClientServerFixture().Server();
server.GrantAccess(user, password);
IObjectContainer con = OpenClient(user, password);
Assert.IsNotNull(con);
con.Close();
server.Ext().RevokeAccess(user);
Assert.Expect(typeof(Exception), new _ICodeBlock_40(this, user, password));
}
public void TestNetworkingCounters()
{
IServerConfiguration config = Db4oClientServer.NewServerConfiguration();
config.Common.Add(new NetworkingMonitoringSupport());
using (IObjectServer server = Db4oClientServer.OpenServer(config, TempFile(), Db4oClientServer.ArbitraryPort))
{
const string userName = "******";
const string password = userName;
server.GrantAccess(userName, password);
IObjectContainer client = Db4oClientServer.OpenClient("localhost", server.Ext().Port(), userName, password);
client.Close();
Assert.IsTrue(PerformanceCounterCategory.InstanceExists(TempFile(), Db4oPerformanceCounters.CategoryName));
}
Assert.IsFalse(PerformanceCounterCategory.InstanceExists(TempFile(), Db4oPerformanceCounters.CategoryName));
}
/// <exception cref="System.Exception"></exception>
public virtual void Test()
{
string fileName = DatabaseFile();
File4.Delete(fileName);
IObjectServer server = Db4oClientServer.OpenServer(CreateServerConfiguration(), fileName
, -1);
_port = server.Ext().Port();
try
{
server.GrantAccess("db4o", "db4o");
RunTest();
}
finally
{
server.Close();
File4.Delete(fileName);
}
}
public virtual void Test()
{
IServerConfiguration serverConfig = Db4oClientServer.NewServerConfiguration();
serverConfig.File.Storage = new MemoryStorage();
IObjectServer server = Db4oClientServer.OpenServer(serverConfig, string.Empty, Db4oClientServer
.ArbitraryPort);
server.GrantAccess(User, Password);
IClientConfiguration clientConfig = Db4oClientServer.NewClientConfiguration();
ClientConfigurationItemIntegrationTestCase.DummyConfigurationItem item = new ClientConfigurationItemIntegrationTestCase.DummyConfigurationItem
(this);
clientConfig.AddConfigurationItem(item);
IExtClient client = (IExtClient)Db4oClientServer.OpenClient(clientConfig, "localhost"
, server.Ext().Port(), User, Password);
item.Verify(clientConfig, client);
client.Close();
server.Close();
}
public virtual IObjectContainer OpenClient()
{
return(Db4oClientServer.OpenClient(Host, _server.Ext().Port(), User, Pass));
}
private static void EventsClientServer()
{
CleanUp();
StoreJoe();
using (IObjectServer server = OpenServer())
{
IEventRegistry eventsOnServer = EventRegistryFactory.ForObjectContainer(server.Ext().ObjectContainer());
RegisterAFewEvents(eventsOnServer, "db4o server");
IObjectContainer client1 = OpenClient();
IEventRegistry eventsOnClient1 = EventRegistryFactory.ForObjectContainer(client1);
RegisterAFewEvents(eventsOnClient1, "db4o client 1");
RunOperations(client1);
IObjectContainer client2 = OpenClient();
IEventRegistry eventsOnClient2 = EventRegistryFactory.ForObjectContainer(client2);
RegisterAFewEvents(eventsOnClient2, "db4o client 2");
SleepForAWhile();
client1.Dispose();
client2.Dispose();
}
CleanUp();
}
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));
}
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 override LocalObjectContainer FileSession()
{
return((LocalObjectContainer)_server.Ext().ObjectContainer());
}
public void Apply(object config)
{
IObjectServer server = this._enclosing.OpenServer(ConfigurationReuseTestSuite.NewInMemoryConfiguration
(), "..", 0);
try
{
this._enclosing.OpenClient(((IConfiguration)config), "localhost", server.Ext().Port
(), "user", "password");
}
finally
{
server.Close();
}
}
private IThreadPool4 ServerThreadPool()
{
return(ThreadPoolFor(_server.Ext().ObjectContainer()));
}
/// <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);
}
private IExtObjectContainer OpenNewSession()
{
return
((IExtObjectContainer)Db4oClientServer.OpenClient("localhost", _server.Ext().Port(), UserName, Password));
}
