public bool TestCreateDuplicatePadInt()
{
// Test3: tries to create an already existant PadInt
// Expected result: exception or error message - PadInt 0 already exists
launchMaster();
launchTwoServers();
try {
bool res = PadiDstm.TxBegin();
PadInt pi_c = PadiDstm.CreatePadInt(0);
PadInt pi_d = PadiDstm.CreatePadInt(0);
if (pi_d == null)
{
throw new Exception("Trying to create duplicate PadInt!");
}
res = PadiDstm.TxCommit();
// Assert.Fail("No exception thrown!"); // não deve chegar aqui!
master.Kill();
server1.Kill();
server2.Kill();
return(res);
} catch (Exception e) {
Console.WriteLine("TestCreateDuplicatePadInt error: " + e);
master.Kill();
server1.Kill();
server2.Kill();
return(false);
}
}
public void TestSimpleWrite(int uid0)
{
Console.WriteLine("------ Test: Simple write ------");
Logger.Log(new String[] { "Client", "------ Test: Simple write ------" });
Console.WriteLine("library created");
try {
Console.WriteLine("init() Done");
PadiDstm.TxBegin();
Console.WriteLine("txBegin Done");
PadInt padInt0 = PadiDstm.CreatePadInt(uid0);
Console.WriteLine("padInt0 created with uid: " + uid0);
if (padInt0.Write(20))
{
Console.WriteLine("padInt0 write done with value (20) : " + padInt0.Read());
}
PadiDstm.TxCommit();
Console.WriteLine("txCommit Done");
Console.WriteLine("closeChannel Done");
} catch (Exception e) {
Console.WriteLine(e.Message);
}
Console.WriteLine("------------");
Logger.Log(new String[] { "---------Simple write end----------" });
}
static void Main(string[] args)
{
bool res;
PadiDstm.Init();
res = PadiDstm.TxBegin();
PadInt pi_a = PadiDstm.CreatePadInt(0);
PadInt pi_b = PadiDstm.CreatePadInt(1);
res = PadiDstm.TxCommit();
res = PadiDstm.TxBegin();
pi_a = PadiDstm.AccessPadInt(0);
pi_b = PadiDstm.AccessPadInt(1);
PadInt pi_c = PadiDstm.AccessPadInt(0);
PadInt pi_d = PadiDstm.AccessPadInt(1);
pi_a.Write(36);
pi_b.Write(37);
Console.WriteLine("a = " + pi_a.Read());
Console.WriteLine("b = " + pi_b.Read());
PadiDstm.Status();
// The following 3 lines assume we have 2 servers: one at port 2001 and another at port 2002
res = PadiDstm.Freeze("tcp://localhost:2001/Server");
res = PadiDstm.Recover("tcp://localhost:2001/Server");
//res = PadiDstm.Fail("tcp://localhost:2003/Server"); // mudei para 2003 porque no 2002 ta o backup do 2001
res = PadiDstm.TxCommit();
}
public bool TestAccessNonCreatedPadInt()
{
// Test2: tries to access a non-created PadInt
// Expected result: exception or error message - PadInt 1 does not exist
launchMaster();
launchTwoServers();
try {
bool res = PadiDstm.TxBegin();
PadInt pi_b = PadiDstm.CreatePadInt(0);
pi_b = PadiDstm.AccessPadInt(1);
if (pi_b == null)
{
throw new Exception("Trying to access a non created PadInt.");
}
res = PadiDstm.TxCommit();
//Assert.Fail("No exception thrown!"); // não deve chegar aqui!
master.Kill();
server1.Kill();
server2.Kill();
return(res);
} catch (Exception e) {
Console.WriteLine("TestAccessNonCreatedPadInt error: " + e);
master.Kill();
server1.Kill();
server2.Kill();
return(false);
}
}
/* Library tests */
public bool TestCommandsWithNoTransaction()
{
// Test1: tries to call all the commands before starting a transaction
// Expected result: exception or error message - must start a transaction
launchMaster();
launchTwoServers();
try {
PadInt pi_a = PadiDstm.CreatePadInt(0);
pi_a = PadiDstm.AccessPadInt(0);
pi_a.Read();
/*if (pi_a == null) {
* throw new Exception("Trying to access an object before starting a transaction.");
* }*/
//pi_a.Read();
//pi_a.Write(36);
//Assert.Fail("No exception thrown!"); // não deve chegar aqui!
master.Kill();
server1.Kill();
server2.Kill();
return(true);
} catch (TxException e) {
Console.WriteLine("TestCommandsWithNoTransaction Exception:" + e);
master.Kill();
server1.Kill();
server2.Kill();
return(false);
}
}
public void TestFailWhileInTransaction()
{
const int UID1 = 10;
const int UID2 = -10;
const int WRITE = 5;
const int MAX = 100;
bool result = PadiDstm.Init();
bool beginSuccess = PadiDstm.TxBegin();
PadInt padInt1 = PadiDstm.CreatePadInt(UID1);
padInt1.Write(WRITE);
PadInt padInt2 = PadiDstm.CreatePadInt(UID2);
padInt2.Write(WRITE);
//Servers de 1 a 2
//Fail do server 1
server[kill].Kill();
Thread.Sleep(3000);
PadiDstm.TxCommit();
//Depois de falhar
PadiDstm.Status();
//PadiDstm.Fail(failedServerURL);
bool f = PadiDstm.Freeze(failedServerURL);
Assert.IsFalse(f);
bool r = PadiDstm.Recover(failedServerURL);
Assert.IsFalse(r);
//Server falhou antes de fazer commit de t1,
//logo deve
Thread.Sleep(1000);
//Server nao consegui fazer commit
//fez abort dos creates
//access deve retornar null
beginSuccess = PadiDstm.TxBegin();
padInt1 = PadiDstm.AccessPadInt(UID1);
Assert.IsNull(padInt1);
padInt2 = PadiDstm.AccessPadInt(UID2);
Assert.IsNull(padInt2);
PadiDstm.TxCommit();
}
/*
* public bool TestCreateTwoPadIntsOneServerFrozen(){
* // Test7: Recovers both servers, freezes one and tries to create two padInts
* // Expected result: both padInts assigned to the same server
* launchMaster();
* launchTwoServers();
* try {
* bool res = PadiDstm.TxBegin();
* //res = PadiDstm.Recover("tcp://localhost:2001/Server"); // continuacao do metodo anterior
* //res = PadiDstm.Recover("tcp://localhost:2002/Server"); // continuacao do metodo anterior
* res = PadiDstm.Freeze("tcp://localhost:2001/Server");
* PadInt pi_j = PadiDstm.CreatePadInt(7);
* PadInt pi_k = PadiDstm.CreatePadInt(8);
* res = PadiDstm.TxCommit();
* master.Kill();
* server1.Kill();
* server2.Kill();
* return res;
* } catch (TxException e) {
* Console.WriteLine("TestCreateTwoPadIntsOneServerFrozen error: " + e);
* master.Kill();
* server1.Kill();
* server2.Kill();
* return false;
* }
* }
*/
/* DataServers status tests */
/*
* public bool TestAccessPadIntOnFrozenSever(){
* // Test8: Tries to access a padInt on the frozen server
* // Fails the 2002 server first to grant assignment to 2001 server
* // Expected result: delay, exception or error message?
* launchMaster();
* launchTwoServers();
* try {
* bool res = PadiDstm.TxBegin();
* // res = PadiDstm.Recover("tcp://localhost:2001/Server"); // continuacao do metodo anterior
* res = PadiDstm.Fail("tcp://localhost:2002/Server");
* PadInt pi_l = PadiDstm.CreatePadInt(9); // assigned to 2001
* res = PadiDstm.Recover("tcp://localhost:2002/Server");
* res = PadiDstm.Freeze("tcp://localhost:2001/Server");
* PadInt pi_m = PadiDstm.AccessPadInt(9); // fica à espera do Recover
* res = PadiDstm.TxCommit();
* master.Kill();
* server1.Kill();
* server2.Kill();
* return res;
* } catch (TxException e) {
* Console.WriteLine("TestAccessPadIntOnFrozenSever error: " + e);
* master.Kill();
* server1.Kill();
* server2.Kill();
* return false;
* }
* }
*/
public bool TestAccessPadIntOnFailedServer()
{
// Test9: Tries to access, read and write a padInt on the failed server
// Fails the 2001 server first to grant assignment to 2002 server
// Expected result: exception or error message?
launchMaster();
launchTwoServers();
try {
bool res = PadiDstm.TxBegin();
// res = PadiDstm.Recover("tcp://localhost:2001/Server"); // continuacao do metodo anterior
res = PadiDstm.Fail("tcp://localhost:2001/Server");
PadInt pi_n = PadiDstm.CreatePadInt(10); // assigned to 2002
res = PadiDstm.Recover("tcp://localhost:2001/Server");
res = PadiDstm.Fail("tcp://localhost:2002/Server");
pi_n = PadiDstm.AccessPadInt(10);
Console.WriteLine(pi_n.Read());
pi_n.Write(5);
Console.WriteLine(pi_n.Read());
res = PadiDstm.TxCommit();
//Assert.Fail("No exception thrown!"); // não deve chegar aqui!
master.Kill();
server1.Kill();
server2.Kill();
return(res);
} catch (TxException e) {
Console.WriteLine("TestAccessPadIntOnFailedServer error: " + e);
master.Kill();
server1.Kill();
server2.Kill();
return(false);
}
}
/* Round Robin atribution tests */
/*
* public bool TestCreateTwoPadIntsOneServerDown() {
* // Test4: Creates two PadInts when one server is down
* // Expected result: both padInts assigned to the same server (2002)
* launchMaster();
* launchTwoServers();
* try {
* bool res = PadiDstm.TxBegin();
* res = PadiDstm.Fail("tcp://localhost:2001/Server");
* PadInt pi_d = PadiDstm.CreatePadInt(1);
* PadInt pi_e = PadiDstm.CreatePadInt(2);
* res = PadiDstm.TxCommit();
* master.Kill();
* server1.Kill();
* server2.Kill();
* return res;
* } catch (TxException e) {
* Console.WriteLine("TestCreateTwoPadIntsOneServerDown error: " + e);
* master.Kill();
* server1.Kill();
* server2.Kill();
* return false;
* }
* }
*/
/*
* public bool TestCreateTwoPadIntsAfterFailedServerRecover(){
* // Test5: Recovers the failed server and tries to create another pair of PadInts
* // Expected result: one padInt assigned to each server
* launchMaster();
* launchTwoServers();
* try {
* bool res = PadiDstm.TxBegin();
* res = PadiDstm.Fail("tcp://localhost:2001/Server");
* res = PadiDstm.Recover("tcp://localhost:2001/Server"); // vinha do metodo anterior
* PadInt pi_f = PadiDstm.CreatePadInt(3);
* PadInt pi_g = PadiDstm.CreatePadInt(4);
* res = PadiDstm.TxCommit();
* master.Kill();
* server1.Kill();
* server2.Kill();
* return res;
* } catch (TxException e) {
* Console.WriteLine("TestCreateTwoPadIntsAfterFailedServerRecover error: " + e);
* master.Kill();
* server1.Kill();
* server2.Kill();
* return false;
* }
* }
*/
public bool TestCreateTwoPadIntsBothServersFailed()
{
// Test6: Fails both servers and tries to create two padInts
// Expected result: exception or error message
launchMaster();
launchTwoServers();
try {
bool res = PadiDstm.TxBegin();
res = PadiDstm.Fail("tcp://localhost:2001/Server");
res = PadiDstm.Fail("tcp://localhost:2002/Server");
PadInt pi_h = PadiDstm.CreatePadInt(5);
PadInt pi_i = PadiDstm.CreatePadInt(6);
if ((pi_i == null) || (pi_h == null))
{
throw new Exception("No data servers avaiable, can't create PadInts.");
}
res = PadiDstm.TxCommit();
//Assert.Fail("No exception thrown!"); // não deve chegar aqui!
master.Kill();
server1.Kill();
server2.Kill();
return(res);
} catch (Exception e) {
Console.WriteLine("TestCreateTwoPadIntsBothServersFailed error: " + e);
master.Kill();
server1.Kill();
server2.Kill();
return(false);
}
}
public void TestSimpleAbort(int uid0)
{
Console.WriteLine("------ Test: Simple Abort ------");
Logger.Log(new String[] { "Client", "------ Test: Simple Abort ------" });
Console.WriteLine("library created");
try {
Console.WriteLine("init() Done");
PadiDstm.TxBegin();
Console.WriteLine("txBegin Done");
PadInt padInt0 = PadiDstm.CreatePadInt(uid0);
Console.WriteLine("padInt0 created with uid: " + uid0);
if (padInt0.Write(20))
{
Console.WriteLine("padInt0 write done with value (20) : " + padInt0.Read());
}
PadiDstm.TxAbort();
Console.WriteLine("txAbort Done");
/* do a read to test if the abort was successful */
Console.WriteLine("I will test if the abort was successful...");
PadiDstm.TxBegin();
Console.WriteLine("txBegin Done");
PadInt padInt0A = PadiDstm.AccessPadInt(uid0);
/* the padInt's value must be equal to initialization value */
int value = padInt0A.Read();
if (value == 0)
{
Console.WriteLine("it's OK");
}
else
{
Console.WriteLine("BUG!!!!!: abort was not successful... value = " + value);
}
PadiDstm.TxCommit();
Console.WriteLine("txCommit Done");
Console.WriteLine("closeChannel Done");
} catch (Exception e) {
Console.WriteLine(e.Message);
}
Console.WriteLine("------------");
Logger.Log(new String[] { "---------Simple abort end----------" });
}
public void TestReadAfterCommit()
{
bool beginSuccess = false;
int uid2 = 2; //object 1 uid
// int uid2 = 2; //object 2 uid
const int DEFAULT_PADINT_VALUE = 0;
const int WRITE_VALUE = 5;
bool result = PadiDstm.Init();
Assert.IsTrue(result, "Failed to load library.");
//T1
beginSuccess = PadiDstm.TxBegin();
Assert.IsTrue(beginSuccess, "Failed to begin transaction.");
PadInt padInt1 = PadiDstm.CreatePadInt(uid2);
Assert.IsNotNull(padInt1, "CreatePadint returned null for uid:" + uid2);
int firstRead = padInt1.Read();
Assert.AreEqual(firstRead, DEFAULT_PADINT_VALUE, String.Format("Read:{0} Expected:{1}", firstRead, DEFAULT_PADINT_VALUE));
padInt1.Write(WRITE_VALUE);
int secondRead = padInt1.Read();
Assert.AreEqual(secondRead, WRITE_VALUE, String.Format("Read:{0} Expected:{1}", secondRead, WRITE_VALUE));
bool status = PadiDstm.Status();
Thread.Sleep(3000);
bool didCommit = PadiDstm.TxCommit();
beginSuccess = PadiDstm.TxBegin();
PadInt pad = PadiDstm.AccessPadInt(uid2);
int thirdRead = pad.Read();
Assert.IsTrue(didCommit, "Failed to commit transaction.");
didCommit = PadiDstm.TxCommit();
PadiDstm.Status();
Assert.IsTrue(didCommit, "Failed to commit transaction.");
Assert.IsTrue(status, "Status operation not done.");
}
public void TestReadWrite(int uid0)
{
Console.WriteLine("------ Test: Read write ------");
Logger.Log(new String[] { "Client", "------ Test: Read write ------" });
Console.WriteLine("library created");
try {
Console.WriteLine("init() Done");
PadiDstm.TxBegin();
Console.WriteLine("txBegin Done");
PadInt padInt0 = PadiDstm.CreatePadInt(uid0);
Console.WriteLine("padInt0 created with uid: " + uid0);
//read
Console.WriteLine("padInt0 read: " + padInt0.Read());
//Library.txCommit();
//Console.WriteLine("txCommit Done");
// write
Console.WriteLine("now I will do a write...");
//Library.TxBegin();
//Console.WriteLine("txBegin Done");
/* the padInt's value must be equal to initialization value */
//PadInt padInt0A = Library.AccessPadInt(uid0);
if (padInt0.Write(211))
{
Console.WriteLine("padInt0 write done with value (211) : " + padInt0.Read());
}
PadiDstm.TxCommit();
Console.WriteLine("txCommit Done");
Console.WriteLine("closeChannel Done");
} catch (Exception e) {
Console.WriteLine(e.Message);
}
Console.WriteLine("------------");
Logger.Log(new String[] { "---------Read write end----------" });
}
public void TestMultipleRead(int uid0, int uid1, int uid2)
{
Console.WriteLine("------ Test: Multiple read ------");
Logger.Log(new String[] { "Client", "------ Test: Multiple read ------" });
Console.WriteLine("library created");
try {
Console.WriteLine("init() Done");
PadiDstm.TxBegin();
Console.WriteLine("txBegin Done");
PadInt padInt0 = PadiDstm.CreatePadInt(uid0);
Console.WriteLine("padInt0 created with uid: " + uid0);
PadInt padInt1 = PadiDstm.CreatePadInt(uid1);
Console.WriteLine("padInt1 created with uid: " + uid1);
PadInt padInt2 = PadiDstm.CreatePadInt(uid2);
Console.WriteLine("padInt2 created with uid: " + uid2);
bool result = padInt0.Read() == 0;
result = (padInt0.Read() == padInt1.Read());
result = (padInt0.Read() == padInt2.Read());
if (result)
{
Console.WriteLine("it's OK");
}
else
{
Console.WriteLine("BUG!!!!!: multiple read was not successful...");
}
PadiDstm.TxCommit();
Console.WriteLine("txCommit Done");
Console.WriteLine("closeChannel Done");
} catch (Exception e) {
Console.WriteLine(e.Message);
}
Console.WriteLine("------------");
Logger.Log(new String[] { "---------multiple read end----------" });
}
public void TestFreezeFail(int uid0)
{
Console.WriteLine("------ Test: Freeze (o cliente1 tem que ja ter feito o freeze/fail) ------");
Logger.Log(new String[] { "Client", "------ Test: Freeze/Fail ------" });
Console.WriteLine("library created");
try {
Console.WriteLine("init() Done");
PadiDstm.TxBegin();
Console.WriteLine("txBegin Done");
PadInt padInt0 = PadiDstm.CreatePadInt(uid0);
Console.WriteLine("padInt0 created with uid: " + uid0);
Console.WriteLine("####################################################################");
Console.WriteLine("Vou fazer ciclo de 10 writes.");
Console.WriteLine("####################################################################");
Console.ReadLine();
for (int i = 0; i <= 10; i++)
{
Console.WriteLine("Fiz um Write no uid 2. uid() = " + padInt0.Write(i).ToString());
}
Console.WriteLine("####################################################################");
Console.WriteLine("Fiz os 10 writes. (valor deve ser 10) padInt0.Read() =" + padInt0.Read() + "Press enter para commit.");
Console.WriteLine("####################################################################");
Console.ReadLine();
PadiDstm.TxCommit();
Console.WriteLine("txCommit Done");
Console.WriteLine("closeChannel Done");
} catch (Exception e) {
Console.WriteLine(e.Message);
}
Console.WriteLine("------------");
Logger.Log(new String[] { "---------Read Freeze end----------" });
}
public bool TestReadPadIntAfterWritingTransactionCommited()
{
// Test11: Locally writes on a PadInt, and aborts this transaction. Another transaction will read the PadInt.
// Expected result: The PadInt must have the initial values, no modifications.
launchMaster();
launchTwoServers();
try {
bool res = PadiDstm.TxBegin();
PadInt pi_p = PadiDstm.CreatePadInt(12);
pi_p = PadiDstm.AccessPadInt(12);
//Console.WriteLine(pi_p.Read());
Assert.AreEqual(pi_p.Read(), 0); // tem que estar a zero, valor inicial
res = PadiDstm.TxCommit();
res = PadiDstm.TxBegin();
pi_p.Write(100);
//Console.WriteLine(pi_p.Read());
Assert.AreEqual(pi_p.Read(), 100); // tem que estar a 100, modificação local
res = PadiDstm.TxCommit(); // conclui a transacção
res = PadiDstm.TxBegin();
Assert.AreEqual(pi_p.Read(), 100); // tem que estar a 100, valor actualizado
res = PadiDstm.TxCommit();
master.Kill();
server1.Kill();
server2.Kill();
return(res);
} catch (Exception e) {
Console.WriteLine("TestReadPadIntAfterWritingTransactionCommited error: " + e);
master.Kill();
server1.Kill();
server2.Kill();
return(false);
}
}
public void TestCheckLoadBalancing()
{
bool beginSuccess = false;
const int MAX_UID = 500;
const int DEFAULT_PADINT_VALUE = 0;
const int WRITE_VALUE = 5;
bool result = PadiDstm.Init();
Assert.IsTrue(result, "Failed to load library.");
for (int i = 0; i < MAX_UID; i++)
{
beginSuccess = PadiDstm.TxBegin();
Assert.IsTrue(beginSuccess, "Failed to begin transaction.");
PadInt padInt1 = PadiDstm.CreatePadInt(i);
Assert.IsNotNull(padInt1, "CreatePadint returned null for uid:" + i);
int firstRead = padInt1.Read();
Assert.AreEqual(firstRead, DEFAULT_PADINT_VALUE, String.Format("Read:{0} Expected:{1}", firstRead, DEFAULT_PADINT_VALUE));
padInt1.Write(WRITE_VALUE);
int secondRead = padInt1.Read();
Assert.AreEqual(secondRead, WRITE_VALUE, String.Format("Read:{0} Expected:{1}", secondRead, WRITE_VALUE));
bool didCommit = PadiDstm.TxCommit();
//Thread.Sleep(1000);
}
bool status = PadiDstm.Status();
}
static void Main(string[] args)
{
bool res = false; int aborted = 0, committed = 0;
PadiDstm.Init();
String key = Console.ReadLine();
if (key.Equals("C"))
{
args = new String[] { "C" };
}
Stopwatch sw = Stopwatch.StartNew();
try
{
if ((args.Length > 0) && (args[0].Equals("C")))
{
res = PadiDstm.TxBegin();
PadInt pi_a = PadiDstm.CreatePadInt(2);
PadInt pi_b = PadiDstm.CreatePadInt(12);
PadInt pi_c = PadiDstm.CreatePadInt(20);
pi_a.Write(0);
pi_b.Write(0);
res = PadiDstm.TxCommit();
}
Console.WriteLine("####################################################################");
Console.WriteLine("Finished creating PadInts. Press enter for 300 R/W transaction cycle.");
Console.WriteLine("####################################################################");
Console.ReadLine();
}
catch (Exception e)
{
Console.WriteLine("Exception: " + e.Message);
Console.WriteLine("####################################################################");
Console.WriteLine("AFTER create ABORT. Commit returned " + res + " . Press enter for abort and next transaction.");
Console.WriteLine("####################################################################");
Console.ReadLine();
PadiDstm.TxAbort();
}
for (int i = 0; i < 300; i++)
{
try
{
res = PadiDstm.TxBegin();
PadInt pi_d = PadiDstm.AccessPadInt(2);
PadInt pi_e = PadiDstm.AccessPadInt(12);
PadInt pi_f = PadiDstm.AccessPadInt(20);
int d = pi_d.Read();
d++;
pi_d.Write(d);
int e = pi_e.Read();
e++;
pi_e.Write(e);
int f = pi_f.Read();
f++;
pi_f.Write(f);
Console.Write(".");
res = PadiDstm.TxCommit();
if (res)
{
committed++; Console.Write(".");
}
else
{
aborted++;
Console.WriteLine("$$$$$$$$$$$$$$ ABORT $$$$$$$$$$$$$$$$$");
}
}
catch (Exception e)
{
Console.WriteLine("Exception: " + e.Message);
Console.WriteLine("####################################################################");
Console.WriteLine("AFTER create ABORT. Commit returned " + res + " . Press enter for abort and next transaction.");
Console.WriteLine("####################################################################");
Console.ReadLine();
PadiDstm.TxAbort();
aborted++;
}
}
Console.WriteLine("####################################################################");
Console.WriteLine("committed = " + committed + " ; aborted = " + aborted);
Console.WriteLine("Status after cycle. Press enter for verification transaction.");
Console.WriteLine("####################################################################");
PadiDstm.Status();
Console.ReadLine();
try
{
res = PadiDstm.TxBegin();
PadInt pi_g = PadiDstm.AccessPadInt(2);
PadInt pi_h = PadiDstm.AccessPadInt(12);
PadInt pi_j = PadiDstm.AccessPadInt(20);
int g = pi_g.Read();
int h = pi_h.Read();
int j = pi_j.Read();
res = PadiDstm.TxCommit();
Console.WriteLine("####################################################################");
Console.WriteLine("2 = " + g);
Console.WriteLine("2000000001 = " + h);
Console.WriteLine("1000000000 = " + j);
Console.WriteLine("Status post verification transaction. Press enter for exit.");
Console.WriteLine("####################################################################");
PadiDstm.Status();
Console.ReadLine();
}
catch (Exception e)
{
Console.WriteLine("Exception: " + e.Message);
Console.WriteLine("####################################################################");
Console.WriteLine("AFTER create ABORT. Commit returned " + res + " . Press enter for abort and next transaction.");
Console.WriteLine("####################################################################");
Console.ReadLine();
PadiDstm.TxAbort();
}
sw.Stop();
Console.WriteLine("{Total time (ms) : " + (long)sw.ElapsedMilliseconds);
Console.ReadLine();
}
static void Main(string[] args)
{
bool res = false;
PadInt pi_a, pi_b;
PadiDstm.Init();
if ((args.Length > 0) && (args[0].Equals("C")))
{
try{
res = PadiDstm.TxBegin();
pi_a = PadiDstm.CreatePadInt(1);
pi_b = PadiDstm.CreatePadInt(2000000000);
Console.WriteLine("####################################################################");
Console.WriteLine("BEFORE create commit. Press enter for commit.");
Console.WriteLine("####################################################################");
PadiDstm.Status();
Console.ReadLine();
res = PadiDstm.TxCommit();
Console.WriteLine("####################################################################");
Console.WriteLine("AFTER create commit. commit = " + res + " . Press enter for next transaction.");
Console.WriteLine("####################################################################");
Console.ReadLine();
} catch (Exception e) {
Console.WriteLine("Exception: " + e.Message);
Console.WriteLine("####################################################################");
Console.WriteLine("AFTER create ABORT. Commit returned " + res + " . Press enter for abort and next transaction.");
Console.WriteLine("####################################################################");
Console.ReadLine();
PadiDstm.TxAbort();
}
}
try {
res = PadiDstm.TxBegin();
if ((args.Length > 0) && ((args[0].Equals("A")) || (args[0].Equals("C"))))
{
pi_b = PadiDstm.AccessPadInt(2000000000);
pi_b.Write(211);
Console.WriteLine("####################################################################");
Console.WriteLine("Status post first op: write. Press enter for second op.");
Console.WriteLine("####################################################################");
PadiDstm.Status();
Console.ReadLine();
pi_a = PadiDstm.AccessPadInt(1);
//pi_a.Write(212);
Console.WriteLine("####################################################################");
Console.WriteLine("Status post second op: read. uid(1)= " + pi_a.Read() + ". Press enter for commit.");
Console.WriteLine("####################################################################");
PadiDstm.Status();
Console.ReadLine();
}
else
{
pi_a = PadiDstm.AccessPadInt(1);
pi_a.Write(221);
Console.WriteLine("####################################################################");
Console.WriteLine("Status post first op: write. Press enter for second op.");
Console.WriteLine("####################################################################");
PadiDstm.Status();
Console.ReadLine();
pi_b = PadiDstm.AccessPadInt(2000000000);
//pi_b.Write(222);
Console.WriteLine("####################################################################");
Console.WriteLine("Status post second op: read. uid(1)= " + pi_b.Read() + ". Press enter for commit.");
Console.WriteLine("####################################################################");
PadiDstm.Status();
Console.ReadLine();
}
res = PadiDstm.TxCommit();
Console.WriteLine("####################################################################");
Console.WriteLine("commit = " + res + " . Press enter for verification transaction.");
Console.WriteLine("####################################################################");
Console.ReadLine();
} catch (Exception e) {
Console.WriteLine("Exception: " + e.Message);
Console.WriteLine("####################################################################");
Console.WriteLine("AFTER r/w ABORT. Commit returned " + res + " . Press enter for abort and next transaction.");
Console.WriteLine("####################################################################");
Console.ReadLine();
PadiDstm.TxAbort();
}
try {
res = PadiDstm.TxBegin();
PadInt pi_c = PadiDstm.AccessPadInt(1);
PadInt pi_d = PadiDstm.AccessPadInt(2000000000);
Console.WriteLine("0 = " + pi_c.Read());
Console.WriteLine("2000000000 = " + pi_d.Read());
Console.WriteLine("####################################################################");
Console.WriteLine("Status after verification read. Press enter for verification commit.");
Console.WriteLine("####################################################################");
PadiDstm.Status();
res = PadiDstm.TxCommit();
Console.WriteLine("####################################################################");
Console.WriteLine("commit = " + res + " . Press enter for exit.");
Console.WriteLine("####################################################################");
Console.ReadLine();
} catch (Exception e) {
Console.WriteLine("Exception: " + e.Message);
Console.WriteLine("####################################################################");
Console.WriteLine("AFTER verification ABORT. Commit returned " + res + " . Press enter for abort and exit.");
Console.WriteLine("####################################################################");
Console.ReadLine();
PadiDstm.TxAbort();
}
}
private void createButton_Click(object sender, EventArgs e)
{
_createdObj = PadiDstm.CreatePadInt(Convert.ToInt32(createTextBox.Text));
}
public void TestFailServer()
{
bool result = PadiDstm.Init();
bool beginSuccess = PadiDstm.TxBegin();
PadInt padInt1;
for (int i = 0; i < UMAX; i++)
{
padInt1 = PadiDstm.CreatePadInt(i);
padInt1.Write(i);
}
PadInt padInt2;
for (int i = LMAX; i < 0; i++)
{
padInt2 = PadiDstm.CreatePadInt(i);
padInt2.Write(i);
}
Thread.Sleep(5000);
PadiDstm.TxCommit();
// Thread.Sleep(10000);
//Antes de falhar
//PadiDstm.Status();
//Servers de 1 a 2
//Fail do server 1
//try
//{
server[kill].Kill();
//}
//catch (Exception e)
//{
// Console.WriteLine("kill exception" + e.Message);
//}
//Depois de falhar
//PadiDstm.Status();
//server[(kill + 1) % SERVER_MAX].Kill();
//server[(kill + 2) % SERVER_MAX].Kill();
Thread.Sleep(1000);
beginSuccess = PadiDstm.TxBegin();
for (int i = 0; i < UMAX; i++)
{
padInt1 = PadiDstm.AccessPadInt(i);
int i1 = padInt1.Read();
Assert.AreEqual(i1, i);
padInt1.Write(i);
}
for (int i = LMAX; i < 0; i++)
{
padInt2 = PadiDstm.AccessPadInt(i);
int i2 = padInt2.Read();
Assert.AreEqual(i2, i);
padInt2.Write(i);
}
PadiDstm.TxCommit();
server[(kill + 2) % SERVER_MAX].Kill();
beginSuccess = PadiDstm.TxBegin();
for (int i = 0; i < UMAX; i++)
{
padInt1 = PadiDstm.AccessPadInt(i);
int i1 = padInt1.Read();
Assert.AreEqual(i1, i);
padInt1.Write(i);
}
for (int i = LMAX; i < 0; i++)
{
padInt2 = PadiDstm.AccessPadInt(i);
int i2 = padInt2.Read();
Assert.AreEqual(i2, i);
padInt2.Write(i);
}
PadiDstm.TxCommit();
//server[(kill + 3) % SERVER_MAX].Kill();
}
public void TestFailWhileInTransactionWithRead()
{
const int UID1 = 10;
const int UID2 = -10;
const int WRITE = 5;
bool result = PadiDstm.Init();
bool beginSuccess = PadiDstm.TxBegin();
PadInt padInt1 = PadiDstm.CreatePadInt(UID1);
padInt1.Write(WRITE);
PadInt padInt2 = PadiDstm.CreatePadInt(UID2);
padInt1.Write(WRITE);
//Servers de 1 a 2
//Fail do server 1
server[kill].Kill();
Thread.Sleep(1000);
PadiDstm.TxCommit();
//Depois de falhar
PadiDstm.Status();
//Server falhou antes de fazer commit de t1,
//logo deve
Thread.Sleep(1000);
//Server nao consegui fazer commit
//fez abort dos creates
//access deve retornar null
//A seguir cria pad ints e escreve
beginSuccess = PadiDstm.TxBegin();
padInt1 = PadiDstm.AccessPadInt(UID1);
Assert.IsNull(padInt1);
padInt1 = PadiDstm.CreatePadInt(UID1);
Assert.IsNotNull(padInt1);
padInt1.Write(WRITE);
padInt2 = PadiDstm.AccessPadInt(UID2);
Assert.IsNull(padInt2);
padInt2 = PadiDstm.CreatePadInt(UID2);
Assert.IsNotNull(padInt2);
padInt2.Write(WRITE);
PadiDstm.TxCommit();
//Desta vez vai ter sucesso a
//aceder
beginSuccess = PadiDstm.TxBegin();
padInt1 = PadiDstm.AccessPadInt(UID1);
Assert.IsNotNull(padInt1);
int r1 = padInt1.Read();
Assert.AreEqual(r1, WRITE);
padInt2 = PadiDstm.AccessPadInt(UID2);
Assert.IsNotNull(padInt2);
int r2 = padInt2.Read();
Assert.AreEqual(r2, WRITE);
PadiDstm.TxCommit();
}
public void CrossedLocksTest()
{
bool res = false;
PadInt pi_a, pi_b;
PadiDstm.Init();
// if ((args.Length > 0) && (args[0].Equals("C")))
// {
try
{
res = PadiDstm.TxBegin();
Assert.IsTrue(res, "Failed to begin first transaction.");
pi_a = PadiDstm.CreatePadInt(1);
Assert.IsNotNull(pi_a, "Failed to create padint a.");
pi_b = PadiDstm.CreatePadInt(2000000000);
Assert.IsNotNull(pi_b, "Failed to create padint b.");
Console.WriteLine("####################################################################");
Console.WriteLine("BEFORE create commit. Press enter for commit.");
Console.WriteLine("####################################################################");
PadiDstm.Status();
res = PadiDstm.TxCommit();
Assert.IsTrue(res, "Failed to commit first transaction.");
Console.WriteLine("####################################################################");
Console.WriteLine("AFTER create commit. commit = " + res + " . Press enter for next transaction.");
Console.WriteLine("####################################################################");
}
catch (Exception e)
{
Console.WriteLine("Exception: " + e.Message);
Console.WriteLine("####################################################################");
Console.WriteLine("AFTER create ABORT. Commit returned " + res + " . Press enter for abort and next transaction.");
Console.WriteLine("####################################################################");
PadiDstm.TxAbort();
Assert.Fail("Failed to finalize first transaction.");
}
// }
try
{
res = PadiDstm.TxBegin();
Assert.IsTrue(res, "Failed to begin second transaction.");
// if ((args.Length > 0) && ((args[0].Equals("A")) || (args[0].Equals("C"))))
// {
pi_b = PadiDstm.AccessPadInt(2000000000);
Assert.IsNotNull(pi_b, "Failed to access padint 2000000000 on second transaction.");
pi_b.Write(211);
Console.WriteLine("####################################################################");
Console.WriteLine("Status post first op: write. Press enter for second op.");
Console.WriteLine("####################################################################");
PadiDstm.Status();
pi_a = PadiDstm.AccessPadInt(1);
Assert.IsNotNull(pi_a, "Failed to access padint 1 on second transaction.");
//pi_a.Write(212);
Console.WriteLine("####################################################################");
Console.WriteLine("Status post second op: read. uid(1)= " + pi_a.Read() + ". Press enter for commit.");
Console.WriteLine("####################################################################");
PadiDstm.Status();
// }
// else
// {
pi_a = PadiDstm.AccessPadInt(1);
Assert.IsNotNull(pi_a, "Failed to access padint 1 on second transaction.");
pi_a.Write(221);
Console.WriteLine("####################################################################");
Console.WriteLine("Status post first op: write. Press enter for second op.");
Console.WriteLine("####################################################################");
PadiDstm.Status();
pi_b = PadiDstm.AccessPadInt(2000000000);
Assert.IsNotNull(pi_b, "Failed to access padint 2000000000 on second transaction.");
//pi_b.Write(222);
Console.WriteLine("####################################################################");
Console.WriteLine("Status post second op: read. uid(1)= " + pi_b.Read() + ". Press enter for commit.");
Console.WriteLine("####################################################################");
PadiDstm.Status();
//}
res = PadiDstm.TxCommit();
Assert.IsTrue(res, "Failed to commit second transaction");
Console.WriteLine("####################################################################");
Console.WriteLine("commit = " + res + " . Press enter for verification transaction.");
Console.WriteLine("####################################################################");
}
catch (Exception e)
{
Console.WriteLine("Exception: " + e.Message);
Console.WriteLine("####################################################################");
Console.WriteLine("AFTER r/w ABORT. Commit returned " + res + " . Press enter for abort and next transaction.");
Console.WriteLine("####################################################################");
PadiDstm.TxAbort();
}
try
{
res = PadiDstm.TxBegin();
PadInt pi_c = PadiDstm.AccessPadInt(1);
PadInt pi_d = PadiDstm.AccessPadInt(2000000000);
Console.WriteLine("0 = " + pi_c.Read());
Console.WriteLine("2000000000 = " + pi_d.Read());
Console.WriteLine("####################################################################");
Console.WriteLine("Status after verification read. Press enter for verification commit.");
Console.WriteLine("####################################################################");
PadiDstm.Status();
res = PadiDstm.TxCommit();
Assert.IsTrue(res, "Failed to commit third transaction.");
Console.WriteLine("####################################################################");
Console.WriteLine("commit = " + res + " . Press enter for exit.");
Console.WriteLine("####################################################################");
}
catch (Exception e)
{
Console.WriteLine("Exception: " + e.Message);
Console.WriteLine("####################################################################");
Console.WriteLine("AFTER verification ABORT. Commit returned " + res + " . Press enter for abort and exit.");
Console.WriteLine("####################################################################");
PadiDstm.TxAbort();
Assert.Fail("Exception block. Failed to commit.");
}
}
//Criado 3
//1-> 3
//2 -> 10
//3-> 30
private bool transaction2()
{
bool succeed;
try {
Console.WriteLine("Primeira transaccao começa");
succeed = PadiDstm.TxBegin();
if (!succeed)
{
return(false);
}
PadInt pad = PadiDstm.CreatePadInt(2);
Console.WriteLine("Antes do write");
pad = PadiDstm.AccessPadInt(2);
pad.Write(10);
pad.Write(20);
Console.WriteLine("Deve ler 20 ->" + pad.Read());
succeed = PadiDstm.TxCommit();
if (!succeed)
{
PadiDstm.TxAbort();
return(false);
}
Console.WriteLine("Segunda transaccao começa");
succeed = PadiDstm.TxBegin();
if (!succeed)
{
return(false);
}
pad = PadiDstm.AccessPadInt(2);
pad.Write(10);
Console.WriteLine("Deve dar 10 -> " + pad.Read());
succeed = PadiDstm.TxCommit();
if (!succeed)
{
PadiDstm.TxAbort();
return(false);
}
//T3
succeed = PadiDstm.TxBegin();
if (!succeed)
{
return(false);
}
pad = PadiDstm.CreatePadInt(3);
pad.Write(30);
Console.WriteLine("Deve dar 30 -> " + pad.Read());
succeed = PadiDstm.TxCommit();
if (!succeed)
{
PadiDstm.TxAbort();
return(false);
}
Console.ReadLine();
}
catch (TxException e)
{
Console.WriteLine(e);
}
return(true);
}
static void Main(string[] args)
{
bool res = false;
int aborted = 0, committed = 0;
PadiDstm.Init();
try {
if ((args.Length > 0) && (args[0].Equals("C")))
{
res = PadiDstm.TxBegin();
for (int i = 0; i < 10001; i++)
{
PadInt pi_a = PadiDstm.CreatePadInt(i);
pi_a.Write(i);
}
res = PadiDstm.TxCommit();
}
Console.WriteLine("####################################################################");
Console.WriteLine("Finished creating PadInts. Press enter for sum transaction.");
Console.WriteLine("####################################################################");
Console.ReadLine();
} catch (Exception e) {
Console.WriteLine("Exception: " + e.Message);
Console.WriteLine("####################################################################");
Console.WriteLine("AFTER create ABORT. Commit returned " + res + " . Press enter for abort and next transaction.");
Console.WriteLine("####################################################################");
Console.ReadLine();
PadiDstm.TxAbort();
}
try {
int sum = 0;
PadInt pi_a;
res = PadiDstm.TxBegin();
for (int i = 0; i < 9999; i++)
{
pi_a = PadiDstm.AccessPadInt(i);
sum += pi_a.Read();
}
Console.WriteLine("sum= " + sum);
if (args[0].Equals("D1"))
{
pi_a = PadiDstm.AccessPadInt(10000);
pi_a.Write(sum);
}
if (args[0].Equals("D2"))
{
pi_a = PadiDstm.AccessPadInt(10001);
pi_a.Write(sum);
}
res = PadiDstm.TxCommit();
if (res)
{
committed++; Console.Write(".");
}
else
{
aborted++;
Console.WriteLine("$$$$$$$$$$$$$$ ABORT $$$$$$$$$$$$$$$$$");
}
} catch (Exception e) {
Console.WriteLine("Exception: " + e.Message);
Console.WriteLine("####################################################################");
Console.WriteLine("AFTER create ABORT. Commit returned " + res + " . Press enter for abort and next transaction.");
Console.WriteLine("####################################################################");
Console.ReadLine();
PadiDstm.TxAbort();
aborted++;
}
Console.WriteLine("####################################################################");
Console.WriteLine("committed = " + committed + " ; aborted = " + aborted);
Console.WriteLine("Press enter for status.");
Console.WriteLine("####################################################################");
Console.ReadLine();
PadiDstm.Status();
Console.WriteLine("####################################################################");
Console.WriteLine("Press enter for verification transaction.");
Console.WriteLine("####################################################################");
try {
res = PadiDstm.TxBegin();
PadInt pi_g = PadiDstm.AccessPadInt(10000);
int g = pi_g.Read();
res = PadiDstm.TxCommit();
Console.WriteLine("####################################################################");
Console.WriteLine("sum = " + g);
Console.WriteLine("Status post verification transaction. Press enter for exit.");
Console.WriteLine("####################################################################");
PadiDstm.Status();
Console.ReadLine();
} catch (Exception e) {
Console.WriteLine("Exception: " + e.Message);
Console.WriteLine("####################################################################");
Console.WriteLine("AFTER create ABORT. Commit returned " + res + " . Press enter for abort and next transaction.");
Console.WriteLine("####################################################################");
Console.ReadLine();
PadiDstm.TxAbort();
}
}
public void CicleTest()
{
bool res = false; int aborted = 0, committed = 0;
PadiDstm.Init();
try
{
//if ((args.Length > 0) && (args[0].Equals("C"))) {
res = PadiDstm.TxBegin();
PadInt pi_a = PadiDstm.CreatePadInt(2);
Assert.IsNotNull(pi_a, "Padint a failed to create.");
PadInt pi_b = PadiDstm.CreatePadInt(2000000001);
Assert.IsNotNull(pi_b, "Padint b failed to create.");
PadInt pi_c = PadiDstm.CreatePadInt(1000000000);
Assert.IsNotNull(pi_c, "Padint c failed to create.");
pi_a.Write(0);
pi_b.Write(0);
res = PadiDstm.TxCommit();
Assert.IsTrue(res, "Failed to commit first transaction.");
//}
Console.WriteLine("####################################################################");
Console.WriteLine("Finished creating PadInts. Press enter for 300 R/W transaction cycle.");
Console.WriteLine("####################################################################");
}
catch (Exception e)
{
Console.WriteLine("Exception: " + e.Message);
Console.WriteLine("####################################################################");
Console.WriteLine("AFTER create ABORT. Commit returned " + res + " . Press enter for abort and next transaction.");
Console.WriteLine("####################################################################");
PadiDstm.TxAbort();
Assert.Fail("Failed to commit first transaction.");
}
int previousD = 0;
int previousE = 0;
int previousF = 0;
for (int i = 0; i < 300; i++)
{
try
{
res = PadiDstm.TxBegin();
PadInt pi_d = PadiDstm.AccessPadInt(2);
Assert.IsNotNull(pi_d, "Padint a failed to access.");
PadInt pi_e = PadiDstm.AccessPadInt(2000000001);
Assert.IsNotNull(pi_e, "Padint e failed to access.");
PadInt pi_f = PadiDstm.AccessPadInt(1000000000);
Assert.IsNotNull(pi_f, "Padint f failed to access.");
int d = pi_d.Read();
Assert.AreEqual(previousD, d, "Object d does not have a consistent value.");
d++;
pi_d.Write(d);
previousD = d;
int e = pi_e.Read();
Assert.AreEqual(previousE, e, "Object e does not have a consistent value.");
e++;
pi_e.Write(e);
previousE = e;
int f = pi_f.Read();
Assert.AreEqual(previousF, f, "Object f does not have a consistent value.");
f++;
pi_f.Write(f);
previousF = f;
Console.Write(".");
res = PadiDstm.TxCommit();
Assert.IsTrue(res, "Failed to commit second transaction.");
if (res)
{
committed++; Console.Write(".");
}
else
{
aborted++;
Console.WriteLine("$$$$$$$$$$$$$$ ABORT $$$$$$$$$$$$$$$$$");
}
}
catch (Exception e)
{
Console.WriteLine("Exception: " + e.Message);
Console.WriteLine("####################################################################");
Console.WriteLine("AFTER create ABORT. Commit returned " + res + " . Press enter for abort and next transaction.");
Console.WriteLine("####################################################################");
PadiDstm.TxAbort();
aborted++;
}
}
Console.WriteLine("####################################################################");
Console.WriteLine("committed = " + committed + " ; aborted = " + aborted);
Console.WriteLine("Status after cycle. Press enter for verification transaction.");
Console.WriteLine("####################################################################");
PadiDstm.Status();
try
{
res = PadiDstm.TxBegin();
PadInt pi_g = PadiDstm.AccessPadInt(2);
PadInt pi_h = PadiDstm.AccessPadInt(2000000001);
PadInt pi_j = PadiDstm.AccessPadInt(1000000000);
int g = pi_g.Read();
Assert.AreEqual(previousD, g, "Object g does not have a consistent value.");
int h = pi_h.Read();
Assert.AreEqual(previousE, h, "Object d does not have a consistent value.");
int j = pi_j.Read();
Assert.AreEqual(previousF, j, "Object d does not have a consistent value.");
res = PadiDstm.TxCommit();
Assert.IsTrue(res, "Failed to commit last transaction.");
Console.WriteLine("####################################################################");
Console.WriteLine("2 = " + g);
Console.WriteLine("2000000001 = " + h);
Console.WriteLine("1000000000 = " + j);
Console.WriteLine("Status post verification transaction. Press enter for exit.");
Console.WriteLine("####################################################################");
PadiDstm.Status();
}
catch (Exception e)
{
Console.WriteLine("Exception: " + e.Message);
Console.WriteLine("####################################################################");
Console.WriteLine("AFTER create ABORT. Commit returned " + res + " . Press enter for abort and next transaction.");
Console.WriteLine("####################################################################");
PadiDstm.TxAbort();
Assert.IsTrue(res, "Failed to commit last transaction.");
}
}
public void TestPartitioning()
{
bool beginSuccess = false;
int uid2 = -1000; //object 1 uid
int uid3 = 1000;
// int uid2 = 2; //object 2 uid
const int DEFAULT_PADINT_VALUE = 0;
const int WRITE_VALUE = 5;
bool result = PadiDstm.Init();
Assert.IsTrue(result);
//T1
beginSuccess = PadiDstm.TxBegin();
//bool status = PadiDstm.Status();
Assert.IsTrue(beginSuccess);
PadInt padInt1 = PadiDstm.CreatePadInt(uid2);
PadInt padInt2 = PadiDstm.CreatePadInt(uid3);
Assert.IsNotNull(padInt1);
int firstRead = padInt1.Read();
Assert.AreEqual(firstRead, DEFAULT_PADINT_VALUE);
padInt2.Write(WRITE_VALUE);
//int secondRead = padInt1.Read();
//Assert.AreEqual(secondRead, WRITE_VALUE, String.Format("Read:{0} Expected:{1}", secondRead, WRITE_VALUE));
bool didCommit = PadiDstm.TxCommit();
//bool status = PadiDstm.Status();
StartServer();
Console.WriteLine("Depois de arrancar o 2 server");
Thread.Sleep(5000);
bool status = PadiDstm.Status();
beginSuccess = PadiDstm.TxBegin();
Assert.IsTrue(beginSuccess);
PadInt pad = PadiDstm.AccessPadInt(uid3);
Assert.IsNotNull(pad);
int readAfterStart = pad.Read();
Assert.AreEqual(readAfterStart, WRITE_VALUE, String.Format("Read:{0} Expected:{1}", readAfterStart, WRITE_VALUE));
Assert.IsTrue(didCommit, "Failed to commit transaction.");
didCommit = PadiDstm.TxCommit();
Assert.IsTrue(didCommit, "Failed to commit transaction.");
status = PadiDstm.Status();
}
public void TestCreateTransaction()
{
const int UID1 = 10;
const int UID2 = -10;
const int WRITE = 5;
bool result = PadiDstm.Init();
//Falha create
bool beginSuccess = PadiDstm.TxBegin();
PadInt padInt1 = PadiDstm.CreatePadInt(UID1);
padInt1.Write(WRITE);
PadInt padInt2 = PadiDstm.CreatePadInt(UID2);
padInt1.Write(WRITE);
PadiDstm.TxAbort();
//Falha access
beginSuccess = PadiDstm.TxBegin();
padInt1 = PadiDstm.AccessPadInt(UID1);
Assert.IsNull(padInt1);
padInt2 = PadiDstm.AccessPadInt(UID2);
Assert.IsNull(padInt2);
PadiDstm.TxCommit();
//Pode criar
beginSuccess = PadiDstm.TxBegin();
padInt1 = PadiDstm.CreatePadInt(UID1);
padInt1.Write(WRITE);
padInt2 = PadiDstm.CreatePadInt(UID2);
padInt2.Write(WRITE);
PadiDstm.TxCommit();
//Pode ler
beginSuccess = PadiDstm.TxBegin();
Assert.IsTrue(beginSuccess);
padInt1 = PadiDstm.AccessPadInt(UID1);
Assert.IsNotNull(padInt1);
int r1 = padInt1.Read();
Assert.AreEqual(r1, WRITE);
padInt2 = PadiDstm.AccessPadInt(UID2);
Assert.IsNotNull(padInt2);
int r2 = padInt2.Read();
Assert.AreEqual(r2, WRITE);
PadiDstm.TxCommit();
//Ja esta criado
beginSuccess = PadiDstm.TxBegin();
padInt1 = PadiDstm.CreatePadInt(UID1);
Assert.IsNull(padInt1);
padInt2 = PadiDstm.CreatePadInt(UID2);
Assert.IsNull(padInt1);
PadiDstm.TxCommit();
}
public void TestFreezeCreate(int uid0)
{
Console.WriteLine("------ Test: Freeze Create ------");
Logger.Log(new String[] { "Client", "------ Test: Freeze Create ------" });
Console.WriteLine("library created");
try {
Console.WriteLine("init() Done");
PadiDstm.TxBegin();
Console.WriteLine("txBegin Done");
PadInt padInt0 = PadiDstm.CreatePadInt(uid0);
Console.WriteLine("padInt0 created with uid: " + uid0);
Console.WriteLine("####################################################################");
Console.WriteLine("Vou fazer o primeiro ciclo de 5 writes. Depois vem o freeze");
Console.WriteLine("####################################################################");
Console.ReadLine();
int i = 0;
for (; i <= 5; i++)
{
Console.WriteLine("Fiz um Write no uid 1. uid() = " + padInt0.Write(i).ToString());
}
Console.WriteLine("####################################################################");
Console.WriteLine("Vou fazer o freeze Nota: Podem ser imprimidas writas que estao a ser feitas em cache! so vai parar quando fizer pedido ao server");
Console.WriteLine("####################################################################");
Console.ReadLine();
// The following 2 lines assume we have 2 servers: one at port 2001 and another at port 2002
bool res = PadiDstm.Freeze("tcp://localhost:2001/PadIntServer");
//res = Library.Fail("tcp://localhost:2002/PadIntServer");
Console.WriteLine("####################################################################");
Console.WriteLine("Fiz o freeze res= " + res + "Vou fazer o segundo ciclo de 5 writes. Depois vem o commit");
Console.WriteLine("####################################################################");
Console.ReadLine();
for (; i <= 10; i++)
{
Console.WriteLine("Fiz um Write no uid 1. uid() = " + padInt0.Write(i).ToString());
}
PadiDstm.TxCommit();
Console.WriteLine("txCommit Done");
PadiDstm.TxBegin();
Console.WriteLine("txBegin Done");
/* the padInt's value must be equal to initialization value */
PadInt padInt0A = PadiDstm.AccessPadInt(uid0);
Console.WriteLine("####################################################################");
Console.WriteLine("Fiz os 10 writes. padInt0A.Read()= " + padInt0A.Read() + " Press enter para commit.");
Console.WriteLine("####################################################################");
Console.ReadLine();
PadiDstm.TxCommit();
Console.WriteLine("txCommit Done");
Console.WriteLine("closeChannel Done");
} catch (Exception e) {
Console.WriteLine(e.Message);
}
Console.WriteLine("------------");
Logger.Log(new String[] { "---------Read Freeze end----------" });
}
public void TestFailCreate(int uid0)
{
Console.WriteLine("------ Test: Fail Create ------");
Logger.Log(new String[] { "Client", "------ Test: Fail Create ------" });
Console.WriteLine("library created");
try {
Console.WriteLine("init() Done");
PadiDstm.TxBegin();
Console.WriteLine("txBegin Done");
PadInt padInt0 = PadiDstm.CreatePadInt(uid0);
Console.WriteLine("padInt0 created with uid: " + uid0);
Console.WriteLine("####################################################################");
Console.WriteLine("Vou fazer o primeiro ciclo de 5 writes. Depois vem o fail");
Console.WriteLine("####################################################################");
Console.ReadLine();
int i = 0;
for (; i <= 5; i++)
{
Console.WriteLine("Fiz um Write no uid 1. uid() = " + padInt0.Write(i).ToString());
}
Console.WriteLine("####################################################################");
Console.WriteLine("Vou fazer o fail");
Console.WriteLine("####################################################################");
Console.ReadLine();
// The following 2 lines assume we have 2 servers: one at port 2001 and another at port 2002
//bool res = Library.Freeze("tcp://localhost:2001/PadIntServer");
bool res = PadiDstm.Fail("tcp://localhost:2001/PadIntServer");
Console.WriteLine("####################################################################");
Console.WriteLine("Fiz o fail res= " + res + "Vou fazer o segundo ciclo de 5 writes. Depois vem o commit");
Console.WriteLine("####################################################################");
Console.ReadLine();
for (; i <= 10; i++)
{
Console.WriteLine("Fiz um Write no uid 1. uid() = " + padInt0.Write(i).ToString());
}
PadiDstm.TxCommit();
Console.WriteLine("txCommit Done");
PadiDstm.TxBegin();
Console.WriteLine("txBegin Done");
PadInt padInt0A = PadiDstm.AccessPadInt(uid0);
Console.WriteLine("####################################################################");
Console.WriteLine("Fiz os 10 writes. padInt0A.Read()= " + padInt0A.Read() + " Press enter para commit.");
Console.WriteLine("####################################################################");
Console.ReadLine();
PadiDstm.TxCommit();
Console.WriteLine("txCommit Done");
Console.WriteLine("closeChannel Done");
} catch (Exception e) {
Console.WriteLine(e.Message);
}
Console.WriteLine("------------");
Logger.Log(new String[] { "---------Read Fail end----------" });
}
