public void TestRecover() { Console.WriteLine("------ Test: Recover ------"); Logger.Log(new String[] { "Client", "------ Test: Recover ------" }); Console.WriteLine("library created"); try { Console.WriteLine("init() Done"); PadiDstm.TxBegin(); Console.WriteLine("txBegin Done"); // The following 2 lines assume we have 2 servers: one at port 2001 and another at port 2002 bool res = PadiDstm.Recover("tcp://localhost:2001/PadIntServer"); Console.WriteLine("####################################################################"); Console.WriteLine("Fiz o recover res= " + res + " Depois vem o 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----------" }); }
/* 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); } }
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); } }
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 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 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); } }
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----------" }); }
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----------" }); }
private void txBeginButton_Click(object sender, EventArgs e) { //statusTextBox.Clear(); try { PadiDstm.TxBegin(); txBeginButton.Enabled = false; } catch (TxException te) { statusTextBox.AppendText("Cannot start new transaction." + "Transaction with id" + te.Tid + "is active.\r\n"); } }
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(); } }
//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); }
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 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 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----------" }); }
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 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----------" }); }