src/jaceP2P/BackupsManager.java

   1 package jaceP2P;
   2
   3 import java.util.Vector;
   4
   5 public class BackupsManager {
   6         final int MAX_COUNT_NOT_ALIVE = 3;
   7
   8         // attributes
   9         public static BackupsManager Instance;
  10         public int myRank = -1;
  11         public Vector<Backup> liste = new Vector<Backup>();
  12         public Vector<Backup> liste_Convg = new Vector<Backup>();
  13
  14         // constructors
  15         private BackupsManager() {
  16         }
  17
  18         public static BackupsManager Instance() {
  19                 if (Instance == null) {
  20                         Instance = new BackupsManager();
  21                 }
  22                 return Instance;
  23         }
  24
  25         // retourne le nb de Backups ds la liste)
  26         public synchronized int size() {
  27                 return liste.size();
  28         }
  29
  30         public synchronized void clean() {
  31                 for (int i = 0; i < liste.size(); i++) {
  32                         ((Backup) liste.get(i)).setIteration(-1);
  33                         ((Backup) liste.get(i)).setData(null);
  34                         ((Backup) liste_Convg.get(i)).setIteration(-1);
  35                         ((Backup) liste_Convg.get(i)).setData(null);
  36                 }
  37         }
  38
  39         public synchronized void purge() {
  40                 liste.clear();
  41                 liste_Convg.clear();
  42                 myRank = -1;
  43                 Instance = null;
  44         }
  45
  46         public synchronized int getMyRank() {
  47                 return myRank;
  48         }
  49
  50         public synchronized void initialize(int req) {
  51                 ListeTask tskList = Register.Instance().getListeOfTasks();
  52
  53                 TaskId t = tskList.getTaskIdOfHostStub(LocalHost.Instance().getStub());
  54                 if (t == null) {
  55                         System.out.println("no corresponding task !!!!!!!!!!!!!!!!");
  56                         // TODO
  57                         // what can we do ?????????????????
  58                 }
  59                 myRank = t.getRank();
  60                 int rankOfBackTask;
  61
  62                 // get the number of backup nodes there are for each task i
  63                 int numBackNodes = Register.Instance().getNumBackupNeighbors();
  64                 System.out.println("numBackNodes : " + numBackNodes);
  65                 int numOfTasks = Register.Instance().getNbOfTasks();
  66                 System.out.println("nombre de taches=" + numOfTasks);
  67                 int tmp;
  68                 int lastBackupRank;
  69                 int lastBackupRankConv;
  70
  71                 // ****************************** STEP 1 : Create the empty
  72                 // BackupsManager
  73                 // **
  74
  75                 for (int i = 1; i <= numBackNodes; i++) {
  76                         // ------------ 1 - for backups "i + n" (to the right of i)
  77                         rankOfBackTask = (myRank + i) % numOfTasks;
  78                         // System.out.println("i : " + i + ", rankOfBackTask : " +
  79                         // rankOfBackTask);
  80                         Backup b_right = new Backup(rankOfBackTask);
  81                         addBackupTask(b_right, 0); // erase if exists so no redondancy
  82                         Backup b_rightConv = new Backup(rankOfBackTask);
  83                         addBackupTask(b_rightConv, 1); // erase if exists so no redondancy
  84
  85                         // ------------ 2 - for backups "i - n" (to the left of i)
  86                         tmp = myRank - i;
  87                         if (tmp >= 0) {
  88                                 rankOfBackTask = tmp % numOfTasks;
  89                         } else {
  90                                 rankOfBackTask = numOfTasks - (Math.abs(tmp) % numOfTasks);
  91                         }
  92                         // System.out.println("i : " + i + ", rankOfBackTask : " +
  93                         // rankOfBackTask);
  94                         Backup b_left = new Backup(rankOfBackTask);
  95                         addBackupTask(b_left, 0); // erase if exists so no redondancy
  96                         Backup b_leftConv = new Backup(rankOfBackTask);
  97                         addBackupTask(b_leftConv, 1); // erase if exists so no redondancy
  98                 }
  99
 100                 // ****************************** STEP 2 : get the Backup for my task
 101                 // ** get an eventual Backup (if there is one) to restart on me (try 3
 102                 // times)
 103                 if (req == 0) {
 104                         int res = -1;
 105                         int j = 0;
 106
 107                         while (j < 3 && res == -1) {
 108                                 // scan all backup Nodes to know the rank of task
 109                                 // which Backup is the most recent for my tasks
 110                                 lastBackupRank = getLastRemoteBackupRank(); // return -1 if no
 111                                                                                                                         // Backups
 112                                 lastBackupRankConv = getLastRemoteBackupRankConvg();
 113                                 // Knowing the Node which has the last (most recent) Backup for
 114                                 // me,
 115                                 // I get this Backup in order to restart it
 116                                 System.out.println("I am going to get the Backup on "
 117                                                 + lastBackupRank);
 118                                 System.out.println("I am going to get the Backup Conv on "
 119                                                 + lastBackupRankConv);
 120                                 res = restartMyTask(lastBackupRank, lastBackupRankConv);
 121                                 if (res != -1) {
 122                                         System.out.println("Backup successfully got and restarted");
 123                                 } else {
 124                                         System.out
 125                                                         .println("FAILED to get or restart the Backup at try "
 126                                                                         + j
 127                                                                         + "... I retry to get a Backup on another Node ("
 128                                                                         + (2 - j) + " times again)");
 129                                 }
 130                                 j++;
 131                         }
 132
 133                         // get backups of all neighboring nodes
 134                         int destRank;
 135                         TaskId destTaskId;
 136                         TaskId id = Register.Instance().getListeOfTasks()
 137                                         .getTaskIdOfHostStub(LocalHost.Instance().getStub());
 138                         int myRank = id.getRank();
 139                         JaceInterface destStub;
 140                         for (int i = 0; i < BackupsManager.Instance().size(); i++) {
 141                                 destRank = BackupsManager.Instance().getBackupTaskAtIndex(i, 0)
 142                                                 .getTaskRank();
 143                                 destTaskId = Register.Instance().getListeOfTasks()
 144                                                 .getTaskIdOfRank(destRank);
 145                                 destStub = destTaskId.getHostStub();
 146                                 new GetBackupForNewNode(destStub, myRank).start();
 147                         }
 148
 149                 } else
 150                         restartMyTask(-1, -1);
 151         }
 152
 153         public class GetBackupForNewNode extends Thread {
 154                 JaceInterface stub;
 155                 int myRank;
 156
 157                 public GetBackupForNewNode(JaceInterface destStub, int myRank) {
 158                         stub = destStub;
 159                         this.myRank = myRank;
 160                 }
 161
 162                 public void run() {
 163                         try {
 164
 165                                 stub.getBackupForNewNode(myRank);
 166                         } catch (Exception e) {
 167                         }
 168                 }
 169         }
 170
 171         public synchronized void addBackupTask(Backup t, int tag) {
 172
 173                 // regarder si existe cette tache ds le vecteur
 174                 if (tag == 0) {
 175                         int isIn = existBackupTaskOfRank(t.getTaskRank(), tag);
 176
 177                         if (isIn == -1) { // si elle y est pas on l'isere
 178                                 liste.addElement(t);
 179
 180                         }
 181
 182                         else { // si elle y est on remplace l'ancienne
 183                                 liste.set(isIn, t);
 184
 185                         }
 186                 } else {
 187                         int isIn = existBackupTaskOfRank(t.getTaskRank(), tag);
 188
 189                         if (isIn == -1) {
 190                                 liste_Convg.addElement(t);
 191                         } else
 192                                 liste_Convg.set(isIn, t);
 193                 }
 194         }
 195
 196         public int existBackupTaskOfRank(int rank, int tag) {
 197                 int existe = -1;
 198                 int index = 0;
 199                 if (tag == 0)
 200                         while ((existe == -1) && (index < liste.size())) {
 201                                 if (rank == ((Backup) liste.get(index)).getTaskRank()) {
 202                                         existe = index;
 203                                 } else
 204                                         index++;
 205                         }
 206                 else
 207                         while ((existe == -1) && (index < liste_Convg.size())) {
 208                                 if (rank == ((Backup) liste_Convg.get(index)).getTaskRank()) {
 209                                         existe = index;
 210                                 } else
 211                                         index++;
 212                         }
 213                 return existe;
 214         }
 215
 216         // returns rank of the task that has my most recent Backup
 217         private int getLastRemoteBackupRank() {
 218                 int rank;
 219                 TaskId task;
 220                 JaceInterface stub = null;
 221                 int ite;
 222                 int lastIte = -1;
 223                 int lastBackupRank = -1;
 224                 Vector<?> v;
 225                 int timeStep;
 226                 int lastStep = -1;
 227                 boolean ack = false;
 228                 int count;
 229
 230                 // ask for ite number of Backups of all my Backup Nodes
 231                 for (int i = 0; i < liste.size(); i++) {
 232                         ite = -1;
 233                         timeStep = -1;
 234                         rank = ((Backup) liste.get(i)).getTaskRank();
 235                         task = Register.Instance().getListeOfTasks().getTaskIdOfRank(rank);
 236                         if (task == null)
 237                                 System.out.println("la tache " + rank
 238                                                 + "n'est pas trouvee dans le registre de " + myRank);
 239
 240                         stub = task.getHostStub();
 241                         if (stub == null) {
 242                                 System.out.println("stub is null, this node is dead !!!!");
 243                         } else {
 244                                 count = 0;
 245                                 // if node not dead, try 3 times to know
 246                                 // the ite number of its Backup for me
 247                                 do {
 248                                         try {
 249                                                 // TODO ???
 250                                                 // threads or not, for the invokation ?
 251                                                 count++;
 252                                                 v = stub.getIterationOfBackup(myRank, 0);
 253                                                 ite = ((Integer) v.get(0)).intValue();
 254
 255                                                 timeStep = ((Integer) v.get(1)).intValue();
 256                                                 System.out.println(" data ite = " + ite + " timeStep="
 257                                                                 + timeStep + " available from task " + rank);
 258                                                 ack = true;
 259                                         } catch (Exception e) {
 260                                                 System.out.println("The Node " + task.getHostIP()
 261                                                                 + " does not answer at try " + count);
 262                                         }
 263                                 } while ((ack == false) && (count < MAX_COUNT_NOT_ALIVE));
 264                                 if (lastStep < timeStep) {
 265                                         lastStep = timeStep;
 266                                         lastIte = ite;
 267                                         lastBackupRank = rank;
 268                                 } else if (lastStep == timeStep && ite > lastIte) {
 269                                         lastIte = ite;
 270                                         lastBackupRank = rank;
 271                                 }
 272                         }
 273                 }
 274                 System.out.println("last backup rank =" + lastBackupRank);
 275                 return lastBackupRank;
 276         }
 277
 278         private int getLastRemoteBackupRankConvg() {
 279                 int rank;
 280                 TaskId task;
 281                 JaceInterface stub = null;
 282                 int ite;
 283                 int lastIte = -1;
 284                 int lastBackupRank = -1;
 285                 boolean ack = false;
 286                 int count;
 287                 Vector<?> v;
 288                 int timeStep;
 289                 int lastStep = -1;
 290                 // ask for ite number of Backups of all my Backup Nodes
 291                 for (int i = 0; i < liste_Convg.size(); i++) {
 292                         ite = -1;
 293                         timeStep = -1;
 294                         rank = ((Backup) liste_Convg.get(i)).getTaskRank();
 295                         task = Register.Instance().getListeOfTasks().getTaskIdOfRank(rank);
 296                         stub = task.getHostStub();
 297                         if (stub == null) {
 298                                 System.out.println("stub is null, this node is dead !!!!");
 299                         } else {
 300                                 count = 0;
 301                                 // if node not dead, try 3 times to know
 302                                 // the ite number of its Backup for me
 303                                 do {
 304                                         try {
 305                                                 // TODO ???
 306                                                 // threads or not, for the invokation ?
 307                                                 count++;
 308                                                 v = stub.getIterationOfBackup(myRank, 1);
 309                                                 ite = ((Integer) v.get(0)).intValue();
 310                                                 timeStep = ((Integer) v.get(1)).intValue();
 311                                                 System.out.println(" conv ite = " + ite + " timeStep="
 312                                                                 + timeStep + " available from task " + rank);
 313                                                 // System.out.println("ite = " + ite +
 314                                                 // " available for task " + rank);
 315                                                 ack = true;
 316                                         } catch (Exception e) {
 317                                                 System.out.println("The Node " + task.getHostIP()
 318                                                                 + " does not answer at try " + count);
 319                                         }
 320                                 } while ((ack == false) && (count < MAX_COUNT_NOT_ALIVE));
 321                                 if (lastStep < timeStep) {
 322                                         lastStep = timeStep;
 323                                         lastIte = ite;
 324                                         lastBackupRank = rank;
 325                                 } else if (lastStep == timeStep && ite > lastIte) {
 326                                         lastIte = ite;
 327                                         lastBackupRank = rank;
 328                                 }
 329
 330                         }
 331                 }
 332                 return lastBackupRank;
 333         }
 334
 335         // return 0 if good (if I successfully got a Backup),
 336         // return -1 elsewhere
 337         private synchronized int restartMyTask(int lastBackupRank,
 338                         int lastBackupRankConv) {
 339                 Backup newBackup = null;
 340                 Backup newBackupConvg = null;
 341                 TaskId task;
 342                 JaceInterface stub = null;
 343
 344                 // If no Backups, lastBackupRank = -1, we start the thread at beginning
 345                 if (lastBackupRank == -1) {
 346                         newBackup = null;
 347                 } else {
 348                         // get the lastBackupRank on the corresponding BackupNode
 349                         task = Register.Instance().getListeOfTasks().getTaskIdOfRank(
 350                                         lastBackupRank);
 351                         stub = task.getHostStub();
 352                         try {
 353                                 newBackup = stub.getRemoteBackup(myRank, 0);
 354                                 // System.out.println("got new back normale for "+myRank);
 355                         } catch (Exception e) {
 356                                 System.out.println("the node " + task.getHostIP()
 357                                                 + " does not answer");
 358                                 // exit in order to get back and get a previous Backup
 359                                 // since this one which failed was the most recent
 360                                 return -1;
 361                         }
 362                 }
 363
 364                 if (lastBackupRankConv == -1) {
 365                         newBackupConvg = null;
 366                 } else {
 367                         // get the lastBackupRank on the corresponding BackupNode
 368                         task = Register.Instance().getListeOfTasks().getTaskIdOfRank(
 369                                         lastBackupRankConv);
 370                         stub = task.getHostStub();
 371                         try {
 372
 373                                 newBackupConvg = stub.getRemoteBackup(myRank, 1);
 374                                 // System.out.println("got new back conv for "+myRank);
 375                         } catch (Exception e) {
 376                                 System.out.println("the node " + task.getHostIP()
 377                                                 + " does not answer");
 378                                 // exit in order to get back and get a previous Backup
 379                                 // since this one which failed was the most recent
 380                                 return -1;
 381                         }
 382                 }
 383
 384                 // in JaceSession, clean the taskObject (Task)
 385                 // and the taskThread (Thread)
 386                 JaceSession.Instance().init();
 387                 // create 1 TaskLauncher that will (re)start the local task within a
 388                 // computing thread
 389                 TaskLauncher launcher = new TaskLauncher();
 390                 launcher.loadOrReloadTask(newBackup, newBackupConvg);
 391                 return 0;
 392         }
 393
 394         public Backup getBackupTaskOfRank(int rank, int tag) {
 395                 int is = -1;
 396                 if (tag == 0) {
 397                         if (liste.isEmpty()) {
 398                                 return null;
 399                         } else {
 400                                 is = existBackupTaskOfRank(rank, tag);
 401                                 if (is != -1) {
 402                                         // System.out.println("chercher un backup normal");
 403                                         return (Backup) liste.get(is);
 404                                 } else {
 405                                         System.out.println("cette tache ou ce backup existe pas");
 406                                         return null;
 407                                 }
 408                         }
 409                 } else {
 410                         if (liste_Convg.isEmpty()) {
 411                                 return null;
 412                         } else {
 413                                 is = existBackupTaskOfRank(rank, tag);
 414                                 if (is != -1) {
 415                                         // System.out.println("chercher un backup convg");
 416                                         return (Backup) liste_Convg.get(is);
 417                                 } else {
 418                                         System.out.println("cette tache ou ce backup existe pas");
 419                                         return null;
 420                                 }
 421                         }
 422                 }
 423         }
 424
 425         public synchronized Backup getBackupTaskAtIndex(int index, int tag) {
 426                 if (tag == 0)
 427                         if (index < liste.size()) {
 428                                 return (Backup) liste.get(index);
 429                         } else {
 430                                 System.out.println("cette task n'existe pas");
 431                                 return null;
 432                         }
 433                 else if (index < liste_Convg.size()) {
 434                         return (Backup) liste_Convg.get(index);
 435                 } else {
 436                         System.out.println("cette task n'existe pas");
 437                         return null;
 438                 }
 439         }
 440 }