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();
}
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 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.");
}
static void Main(string[] args)
{
TcpChannel channel = new TcpChannel();
ChannelServices.RegisterChannel(channel, false);
ClientApp clientApp = new ClientApp();
PadiDstm.Init();
//clientApp.PadiDstm.Fail("tcp://localhost:8089/Server");
//clientApp.PadiDstm.Fail("tcp://localhost:8089/Server");
//clientApp.PadiDstm.Recover("tcp://localhost:8089/Server");
//clientApp.PadiDstm.Fail("tcp://localhost:8089/Server");
//Console.WriteLine("About to recover");
//clientApp.PadiDstm.Recover("tcp://localhost:8089/Server");
//clientApp.PadiDstm.Recover("tcp://localhost:8089/Server");
//clientApp.PadiDstm.Status();
//clientApp.PadiDstm.Recover("tcp://localhost:8089/Server");
//clientApp.PadiDstm.Freeze("tcp://localhost:8089/Server");
//clientApp.PadiDstm.Freeze("tcp://localhost:8089/Server");
//clientApp.PadiDstm.Fail("tcp://localhost:8089/Server");
//clientApp.PadiDstm.Fail("tcp://localhost:8089/Server");
//Console.WriteLine("After fail");
//Console.ReadLine();
//clientApp.transaction1();
//clientApp.transaction2();
Console.ReadLine();
PadiDstm.Status();
Console.ReadLine();
}
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)
{
PadiDstm.Init();
Tests tests = new Tests();
Assert.AreEqual(tests.TestCommandsWithNoTransaction(), false); // falha
Assert.AreEqual(tests.TestAccessNonCreatedPadInt(), false); // falha
Assert.AreEqual(tests.TestCreateDuplicatePadInt(), false); // falha
//Assert.AreEqual(tests.TestCreateTwoPadIntsOneServerDown(), true);
//Assert.AreEqual(tests.TestCreateTwoPadIntsAfterFailedServerRecover(), true);
Assert.AreEqual(tests.TestCreateTwoPadIntsBothServersFailed(), false); // falha
//Assert.AreEqual(tests.TestCreateTwoPadIntsOneServerFrozen(), false);
//Assert.AreEqual(tests.TestAccessPadIntOnFrozenSever(), true); // fica em espera (devolve true?)
Assert.AreEqual(tests.TestAccessPadIntOnFailedServer(), false); // falha
//Assert.AreEqual(tests.TestReadPadIntOnFrozenServer(), true); // fica em espera (devolve true?)
// estes dois correm se estiverem isolados, na sequência crasham... não percebemos porquê
// Assert.AreEqual(tests.TestReadPadIntAfterWritingTransactionAborted(), true); // pq rebenta?
// Assert.AreEqual(tests.TestReadPadIntAfterWritingTransactionCommited(), true); // pq rebenta?
}
public static void Maina(string[] args)
{
Client client = new Client();
Console.Title = "Client";
Console.WriteLine("Client up and running..");
if (PadiDstm.Init())
{
string input;
while (true)
{
Console.WriteLine("----------------------HELP-------------------------");
Console.WriteLine("Please, insert the number of the test that you want to run:");
Console.WriteLine("Tests with just one client");
Console.WriteLine("1- testRandom");
Console.WriteLine("Tests with one client:");
Console.WriteLine("2- Base: testSimpleRead");
Console.WriteLine("3- Base: testSimpleWrite");
Console.WriteLine("4- Base: testSimpleAbort");
Console.WriteLine("5- Base: testSimpleCommit");
Console.WriteLine("6- Base: testMultipleReads");
Console.WriteLine("7- Base: testReadWrite");
Console.WriteLine("8- Base: testWriteRead");
Console.WriteLine("---Freeze---");
Console.WriteLine("9- Base: testFreezeCreate (client1)");
Console.WriteLine("10- Base: testFailCreate (client1)");
Console.WriteLine("11- Base: testFreezeFail (client2)");
Console.WriteLine("12- Base: testRecover");
Console.WriteLine("13- status");
Console.WriteLine("---------");
Console.Write(">");
input = Console.ReadLine();
if (input.Equals("1"))
{
client.TestRandom();
}
if (input.Equals("2"))
{
client.TestSimpleRead(client.GetNextUid());
}
if (input.Equals("3"))
{
client.TestSimpleWrite(client.GetNextUid());
}
if (input.Equals("4"))
{
client.TestSimpleAbort(client.GetNextUid());
}
if (input.Equals("5"))
{
client.TestSimpleCommit(client.GetNextUid());
}
if (input.Equals("6"))
{
client.TestMultipleRead(client.GetNextUid(), client.GetNextUid(), client.GetNextUid());
}
if (input.Equals("7"))
{
client.TestReadWrite(client.GetNextUid());
}
if (input.Equals("8"))
{
client.TestWriteRead(client.GetNextUid());
}
if (input.Equals("9"))
{
client.TestFreezeCreate(1);
}
if (input.Equals("10"))
{
client.TestFailCreate(1);
}
if (input.Equals("11"))
{
client.TestFreezeFail(2);
}
if (input.Equals("12"))
{
client.TestRecover();
}
if (input.Equals("13"))
{
PadiDstm.Status();
}
}
}
else
{
Logger.Log(new String[] { "There are no servers available" });
}
}
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();
}
private void initButton_Click(object sender, EventArgs e)
{
PadiDstm.Init();
initButton.Enabled = false;
}
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();
}
}
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 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 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 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.");
}
}
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();
}
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.");
}
}
