src/jaceP2P/JaceSuperNodeServer.java

   1 package jaceP2P;
   2
   3 import java.rmi.RemoteException;
   4 import java.rmi.server.UnicastRemoteObject;
   5 import java.util.ArrayList;
   6 import java.util.Vector;
   7
   8 import and.Mapping.Algo;
   9 import and.Mapping.DefaultMapping;
  10 import and.Mapping.GNode;
  11 import and.Mapping.GTask;
  12 import and.Mapping.Graph;
  13 import and.Mapping.Grid;
  14 import and.Mapping.LSM;
  15 import and.Mapping.Mapping;
  16 import and.Mapping.QM;
  17 import and.Mapping.Simple;
  18 import and.Mapping.Utils;
  19
  20
  21 public class JaceSuperNodeServer extends UnicastRemoteObject implements
  22                 JaceSuperNodeInterface {
  23         private static final long serialVersionUID = 1L;
  24
  25         // Attributes
  26         private int beat;
  27         private ArrayList<GNode> gnodes = null;
  28         private Algo al = null ;
  29         private int count = 0 ;
  30         private boolean inDemand = false, operating = false, authorized = false ;
  31 //      private boolean daemonListChange ;
  32
  33         // Constructors
  34
  35         public JaceSuperNodeServer(int timeBeat) throws RemoteException {
  36                 super() ;
  37                 beat = timeBeat ;
  38                 gnodes = new ArrayList<GNode>() ;
  39 //              daemonListChange = true ;
  40         }
  41
  42         public int getSuperNodeBeat() throws RemoteException {
  43                 return beat;
  44         }
  45
  46         public Vector<?> sendStub(String IP, int port, JaceSuperNodeInterface stub)
  47                         throws RemoteException {
  48                 SuperNodeListe.Instance().addStubOf(IP, port, stub);
  49                 System.out.println("Added new superNode (" + IP
  50                                 + ") to list and return List");
  51                 return SuperNodeListe.Instance().getListe();
  52         }
  53
  54         public void updateCountNode(String IP, int nb) throws RemoteException {
  55                 SuperNodeListe.Instance().modifCountNode(IP, nb);
  56                 // System.out.println( "SuperNode " + IP + " has registered " + nb +
  57                 // " Daemons" ) ;
  58                 SuperNodeListe.Instance().viewAll();
  59         }
  60
  61         public void sendSurplus(Vector<?> nodes, ArrayList<GNode> _gnodes) throws RemoteException {
  62                 System.out.println("Recieved " + nodes.size() + " nodes");
  63
  64                 for (int i = 0; i < nodes.size(); i++) {
  65                         Register.Instance().getListe().add((Node) nodes.elementAt(i));
  66
  67                         System.out.println("Adding "
  68                                         + ((Node) nodes.elementAt(i)).getName());
  69
  70                         try {
  71                                 ((Node) nodes.elementAt(i)).getStub().updateHeart(
  72                                                 LocalHost.Instance().getSuperNodeStub());
  73                                 int index = SuperNodeListe.Instance().existSuperNode(
  74                                                 LocalHost.Instance().getIP());
  75                                 ((SuperNodeData) SuperNodeListe.Instance().getListe()
  76                                                 .get(index))
  77                                                 .setNbOfNodes(Register.Instance().getSize());
  78                                 new ForwardCount().start();
  79                         } catch (Exception e) {
  80                                 System.err.println("Error changing Server in SendSurplus : "
  81                                                 + e);
  82                         }
  83                 }
  84
  85                 /** Updating gnodes **/
  86                 if( _gnodes != null )
  87                 {
  88                         gnodes = _gnodes ;
  89                 }
  90         }
  91
  92         public void setToken() throws RemoteException {
  93                 System.out.println("I got Token");
  94
  95                 TokenThread.Instance().setToken();
  96
  97                 try {
  98                         HeartBeatSNode.Instance().getServer().beating(true);
  99
 100                         System.out.println("Put token to true");
 101                 } catch (Exception e) {
 102                         System.err
 103                                         .println("Unable to heartBeat the next SuperNode with the new Token : "
 104                                                         + e);
 105                 }
 106         }
 107
 108         public void updateHeart(JaceSuperNodeInterface stub) throws RemoteException {
 109                 System.out.println("I change to ping a superNode");
 110
 111                 HeartBeatSNode.Instance().setServer(stub);
 112         }
 113
 114         public synchronized void removeSuperNode(SuperNodeData d)
 115                         throws RemoteException {
 116                 SuperNodeListe.Instance().removeSuperNode(d);
 117         }
 118
 119         /****************************************************/
 120         /****************************************************/
 121
 122         // Register a Daemon in the Register.Instance() of the SuperNode
 123         public synchronized void workerRegistering(JaceInterface workerStub,
 124                         String workerIP, String workerName, int port, GNode g)
 125                         throws RemoteException {
 126                 System.out.println("CONNECTION of " + workerName);
 127
 128                 // Create the node
 129                 Node noeud = new Node(workerStub);
 130                 noeud.setName(workerName);
 131                 noeud.setIP(workerIP);
 132                 noeud.setAliveFlag(true);
 133                 noeud.setAliveTime();
 134                 noeud.setPort(port);
 135                 noeud.setAppliName(null);
 136                 noeud.setNbOfBeats(0);
 137                 noeud.setId( count ) ;
 138                 noeud.setId( Long.parseLong( workerIP.replace( ".", "" ) ) ) ;
 139
 140                 g.setNode(noeud);
 141                 g.setId( noeud.getId() ) ;
 142
 143                 workingOnGnodes() ;
 144
 145                 gnodes.add(g);
 146
 147 //              daemonListChange = true ;
 148
 149                 // Insert the node in the Register.Instance() of the Super Node
 150                 Register.Instance().addNode(noeud);
 151
 152                 // Register.Instance().viewAll() ;
 153                 // SuperNodeListe.Instance().viewAll() ;
 154
 155                 // Inform the other superNode and tell them the nb of Daemon I have
 156                 // registered
 157                 int index = SuperNodeListe.Instance().existSuperNode(
 158                                 LocalHost.Instance().getIP());
 159
 160                 ((SuperNodeData) SuperNodeListe.Instance().getListe().get(index))
 161                                 .setNbOfNodes(Register.Instance().getSize());
 162                 SuperNodeListe.Instance().forwardCountNode();
 163
 164                 authorized = true ;
 165                 SuperNodeListe.Instance().addGNode( g ) ;
 166                 authorized = false ;
 167
 168                 operating = false ;
 169         }
 170
 171         /****************************************************/
 172         /****************************************************/
 173
 174         // HeartBeat that detects if a Daemon is dead or alive
 175         public void beating(JaceInterface stub) throws RemoteException {
 176                 Node noeud = Register.Instance().getNodeOfStub(stub);
 177
 178                 if (noeud != null) {
 179                         noeud.setAliveFlag(true);
 180                         noeud.setAliveTime();
 181                         noeud.incrementNbOfBeats();
 182                         // -- sm modif
 183                         // System.out.println( noeud.getName() + " is pinging me" ) ;
 184                 } else {
 185                         // System.out.println( noeud.getName() +
 186                         // ".................. is not in my list" ) ;
 187                 }
 188         }
 189
 190         // HeartBeat that detects if a Super Node is dead or alive
 191         public void beating(boolean token) throws RemoteException {
 192                 ScanThreadSuperNode.Instance().setAliveTime();
 193                 ScanThreadSuperNode.Instance().setToken(token);
 194                 // -- sm modif
 195                 // System.out.println( "Super Node is pinging me" ) ;
 196         }
 197
 198
 199         /*********************************/
 200         /** Mapping !! Sébastien Miquée **/
 201         /*********************************/
 202
 203         @Override
 204         public Register getRegisterSpawner(String spawnerIP, int nbTasks, Task t,
 205                         int nbNoeuds, int algo, double paramAlgo) throws RemoteException {
 206
 207                 // Have we the correct application ?
 208                 if (t == null) {
 209                         System.err.println( "Problem of class transmission !" ) ;
 210                         return null ;
 211                 }
 212
 213                 if( t.getDependencies( 0 ) == null )
 214                 {
 215                         System.err.println( "No redifinition of getDependencies() functions !" ) ;
 216                         return null ;
 217                 }
 218
 219
 220                 /** Creation of an empty new Register **/
 221                 Register reg = new Register() ;
 222
 223                 workingOnGnodes() ;
 224
 225                 /** Initialization of Grid architecture (G5K for now) **/
 226                 Grid grid = Utils.createGridG5k(gnodes);
 227                 grid.initClusters();
 228
 229
 230                 /** Creation of tasks GTask **/
 231                 ArrayList<GTask> ts = new ArrayList<GTask>();
 232                 for (int i = 0; i < nbTasks; i++) {
 233                         ts.add(new GTask( i ) ) ;
 234                 }
 235
 236                 /** Research of dependencies **/
 237                 for (int i = 0; i < nbTasks; i++) {
 238                         int dep[] = null;
 239                         dep = t.getDependencies(i);
 240
 241                         /** Adding dependencies to tasks **/
 242                         for (int j = 0; j < dep.length; j++) {
 243                                 if (dep[j] != -1) {
 244                                         ts.get(i).addDependance(ts.get(dep[j]));
 245                                 } else {
 246                                         break;
 247                                 }
 248                         }
 249                 }
 250
 251
 252                 Graph graph = new Graph();
 253
 254                 for( int i = 0 ; i < ts.size() ; i++)
 255                 {
 256                         graph.addGTask(ts.get(i));
 257                 }
 258
 259                 // -- debug !
 260                 // graph.print() ;
 261
 262                 // try {
 263                 // Thread.sleep(10000) ;
 264                 // } catch( Exception e ) {}
 265
 266                 // grid.print() ;
 267                 //
 268                 // try {
 269                 // Thread.sleep( 10000 ) ;
 270                 // } catch( Exception e ) {}
 271
 272                 /** Selection of the mapping algorithm **/
 273                 al = null ;
 274
 275                 switch (algo) {
 276                 case 0:
 277                         al = new Simple(graph, grid);
 278                         break;
 279                 case 1:
 280                         al = new QM(graph, grid, paramAlgo);
 281                         break;
 282                 case 2:
 283                         al = new LSM(graph, grid, paramAlgo);
 284                         break;
 285                 default:
 286                         al = new DefaultMapping( graph, grid, gnodes ) ;
 287                 }
 288
 289                 if (al != null) {
 290                         /** Launching the Mapping **/
 291                         al.map();
 292
 293
 294                         /** Transforming mapping in register **/
 295                         Mapping mp = al.getMapping();
 296
 297
 298                         /** Creating the register **/
 299                         ArrayList<GNode> ag = mp.getMappedGNodes();
 300
 301                         authorized = true ;
 302
 303                         for( int i = 0; i < ag.size(); i++ ) {
 304                                 reg.addNode((Node) ag.get(i).getNode());
 305                                 delGNodeFromList( (Node) ag.get(i).getNode(), 0 ) ;
 306 //                              gnodes.remove(ag.get(i));
 307 //                              Register.Instance().removeNode((Node) ag.get(i).getNode());
 308                         }
 309
 310
 311                         /** Searching extra nodes if any **/
 312                         if( nbNoeuds > nbTasks )
 313                         {
 314                                 int nb = nbNoeuds - nbTasks ;
 315                                 GNode sup = null ;
 316
 317                                 for( int i = 0 ; i < nb ; i ++ )
 318                                 {
 319                                         sup = al.getOtherGNode( gnodes ) ;
 320                                         reg.addNodeBeg( (Node) sup.getNode() ) ;
 321                                         delGNodeFromList( (Node) sup.getNode(), 0 ) ;
 322                                 }
 323                         }
 324
 325                         authorized = false ;
 326
 327                         if (ag.size() != 0) {
 328                                 SuperNodeListe.Instance().forwardCountNode();
 329                         }
 330
 331                 }
 332
 333 //              System.out.println( "Spawner returned reg: " + reg ) ;
 334
 335                 /** Mapping distribution over other Super Nodes */
 336                 SuperNodeListe.Instance().setMapping( al ) ;
 337
 338                 operating = false ;
 339
 340                 /** Returning result **/
 341                 return reg ;
 342         }
 343
 344
 345         @Override
 346         public GNode delGNodeFromList( Node _n, int _mode ) throws RemoteException
 347         {
 348                 GNode removedGNode = null ;
 349
 350                 if( _n != null )
 351                 {
 352                         boolean free = false ;
 353
 354                         if( ! operating )
 355                         {
 356                                 workingOnGnodes() ;
 357                                 free = true ;
 358                         }
 359
 360                         /** The dead node is not in the mapping **/
 361                         if( _mode == 0 )
 362                         {
 363                                 for( int i = 0 ; i < gnodes.size() ; i++ )
 364                                 {
 365                                         if( ((Node)gnodes.get(i).getNode()).getId() == _n.getId() )
 366                                         {
 367                                                 removedGNode = gnodes.remove( i ) ;
 368                                                 Register.Instance().removeNodeOfName( removedGNode.getName() ) ;
 369                                                 break ;
 370                                         }
 371                                 }
 372                         }
 373
 374                         /** The dead node is in the mapping **/
 375                         if( _mode == 1 )
 376                         {
 377                                 ArrayList<GNode> temp = al.getMapping().getMappedGNodes() ;
 378
 379                                 for( int i = 0 ; i < temp.size() ; i++ )
 380                                 {
 381                                         if( ((Node)temp.get(i).getNode()).getId() == _n.getId() )
 382                                         {
 383                                                 removedGNode = temp.get( i ) ;
 384                                                 Register.Instance().removeNodeOfName( removedGNode.getName() ) ;
 385                                                 break ;
 386                                         }
 387                                 }
 388                         }
 389
 390                         /** Removing the dead node from the Grid **/
 391                         al.getGrid().removeGNode( removedGNode ) ;
 392
 393                         SuperNodeListe.Instance().removeGNode( removedGNode, _mode ) ;
 394
 395                         if( free )
 396                         {
 397                                 operating = false ;
 398                         }
 399
 400                 }
 401
 402                 return removedGNode ;
 403         }
 404
 405
 406         private void workingOnGnodes()
 407         {
 408                 boolean tmp = true ;
 409
 410                 inDemand = false ;
 411                 operating = false ;
 412
 413                 while( ! operating )
 414                 {
 415                         inDemand = true ;
 416                         tmp = true ;
 417
 418                         tmp = tmp && SuperNodeListe.Instance().workingOnGnodes() ;
 419
 420                         operating = tmp ;
 421
 422                         if( ! tmp )
 423                         {
 424                                 inDemand = false ;
 425
 426                                 try {
 427                                         Thread.sleep( 10 ) ;
 428                                 } catch (InterruptedException e) {
 429                                         e.printStackTrace();
 430                                 }
 431                         }
 432                 }
 433
 434                 inDemand = false ;
 435         }
 436
 437         @Override
 438         public Node getNewNode( String _spawnerIP, Node _deadNode ) throws RemoteException
 439         {
 440                 Node node = null ;
 441                 GNode remp = null, gnode = null ;
 442
 443                 /** Can we use gnodes ?**/
 444                 workingOnGnodes() ;
 445
 446                 if( _deadNode != null )
 447                 {
 448                         authorized = true ;
 449
 450                         gnode = delGNodeFromList( _deadNode, 1 ) ;
 451
 452                         remp = al.replaceNode( gnode, gnodes ) ;
 453
 454                         if( remp != null )
 455                         {
 456                                 System.out.println( "Replacing node found." ) ;
 457                                 node = (Node) remp.getNode() ;
 458
 459                                 delGNodeFromList( node, 0 ) ;
 460
 461                                 /** Updating all mapping **/
 462                                 updateMappedNode( gnode, remp ) ;
 463                                 propagateReplaceNode( gnode, remp ) ;
 464
 465                                 authorized = false ;
 466
 467                                 SuperNodeListe.Instance().forwardCountNode();
 468                         } else {
 469                                 System.err.println( "Replacing node not found !!" ) ;
 470                         }
 471                 } else {
 472                         remp = al.getOtherGNode( gnodes ) ;
 473
 474                         if( remp != null )
 475                         {
 476                                 System.out.println( "Other new node found." ) ;
 477                                 node = (Node) remp.getNode() ;
 478
 479                                 authorized = true ;
 480
 481                                 delGNodeFromList( node, 0 ) ;
 482
 483                                 authorized = false ;
 484
 485                                 SuperNodeListe.Instance().forwardCountNode();
 486                         } else {
 487                                 System.err.println( "Other new node not found !!" ) ;
 488                         }
 489                 }
 490
 491                 /** Free the gnodes use **/
 492                 operating = false ;
 493
 494                 return node ;
 495         }
 496
 497         @Override
 498         public void updateMappedNode( GNode _dead, GNode _remp )
 499         {
 500                 int pos = 0 ;
 501                 pos = al.getMapping().getIdOfAssociation( _dead ) ;
 502
 503                 if( pos == -1 )
 504                 {
 505                         System.err.println( "GNode "+_dead+" does not exist in the mapping!" ) ;
 506                         return ;
 507                 }
 508
 509                 al.getMapping().getMapping().get( pos ).setGNode( _remp ) ;
 510
 511                 System.out.println( "Succesfully replacing the fallen node in the mapping." ) ;
 512         }
 513
 514
 515         /**
 516          * Inform all SuperNodes of the replacement of a fallen computing node.
 517          * @param _dead The fallen node
 518          * @param _remp The replacing node
 519          */
 520         private void propagateReplaceNode( GNode _dead, GNode _remp ) throws RemoteException
 521         {
 522                 if( _dead != null && _remp != null )
 523                 {
 524                         SuperNodeListe.Instance().propagateReplaceNode( _dead, _remp ) ;
 525                 }
 526         }
 527
 528         /**********************************************************/
 529         /**********************************************************/
 530
 531         @Override
 532         /**
 533          * Add a new node in the list.
 534          * @param _g The new node
 535          */
 536         public void addGNode( GNode _g ) throws RemoteException
 537         {
 538                 if( _g != null )
 539                 {
 540                         boolean free = false ;
 541
 542                         if( ! operating )
 543                         {
 544                                 workingOnGnodes() ;
 545                                 free = true ;
 546                         }
 547
 548                         gnodes.add( _g ) ;
 549
 550                         if( free )
 551                                 operating = false ;
 552                 }
 553         }
 554
 555
 556 //      @Override
 557 //      public void removeGNode( GNode _g ) throws RemoteException
 558 //      {
 559 //              if( _g != null )
 560 //              {
 561 //                      boolean free = false ;
 562 //
 563 //                      if( ! operating )
 564 //                      {
 565 //                              workingOnGnodes() ;
 566 //                              free = true ;
 567 //                      }
 568 //
 569 //                      for( int i = 0 ; i < gnodes.size() ; i++ )
 570 //                      {
 571 //                              if( ((Node)gnodes.get(i).getNode()).getId() == ((Node)_g.getNode()).getId() )
 572 //                              {
 573 //                                      gnodes.remove( i ) ;
 574 //                                      Register.Instance().removeNodeOfName( _g.getName() ) ;
 575 //                                      break ;
 576 //                              }
 577 //                      }
 578 //
 579 //                      if( free )
 580 //                              operating = false ;
 581 //              }
 582 //
 583 //      }
 584
 585
 586         @Override
 587         public void setMapping( Algo _al ) throws RemoteException
 588         {
 589                 al = _al ;
 590         }
 591
 592
 593         @Override
 594         /**
 595          * Allow or deny the use of operations on the gnodes list, in order to
 596          * do a mapping operation.
 597          * @author miquee
 598          * @return The authorization or not to block gnodes
 599          */
 600         public boolean blockForMapping() throws RemoteException
 601         {
 602                 while( inDemand )
 603                 {
 604                         try {
 605                                 Thread.sleep( 10 ) ;
 606                         } catch (InterruptedException e) {
 607                                 e.printStackTrace();
 608                         }
 609                 }
 610
 611                 if( operating && ! authorized )
 612                 {
 613                         return false ;
 614                 } else {
 615                         return true ;
 616                 }
 617         }
 618
 619         @Override
 620         public ArrayList<GNode> getGNodes() throws RemoteException
 621         {
 622                 return gnodes ;
 623         }
 624
 625 }
 626
 627 /** ! **/