Changeset 366


Ignore:
Timestamp:
04/15/2010 05:57:17 PM (10 years ago)
Author:
pedro.cuba
Message:

Added the Halt migration feature (for components which cannot immediatly save its state).
Divided the Migrating interface into Migrating and MigrationAware?.

Location:
libs/cmion/cmionMain/src/cmion
Files:
4 added
9 edited

Legend:

Unmodified
Added
Removed
  • libs/cmion/cmionMain/src/cmion/level2/competencies/Migration.java

    r362 r366  
    3333import cmion.architecture.IArchitecture; 
    3434import cmion.level2.Competency; 
     35import cmion.level2.migration.HaltMigration; 
    3536import cmion.level2.migration.IncomingMigration; 
    3637import cmion.level2.migration.MessageDelivered; 
     
    4041import cmion.level2.migration.MigrationStart; 
    4142import cmion.level2.migration.Reply; 
     43import cmion.level2.migration.ResumeMigration; 
    4244import cmion.level2.migration.SynchronizationFailed; 
    4345import cmion.level2.migration.SynchronizationStart; 
     
    5961        private String configFile; 
    6062        private DocumentBuilder docBuilder;  
     63        private Set<Object> lockingObjects; 
     64        private boolean migrationOnHalt; 
    6165         
    6266        /* This class represents a Device to which the agent is able 
     
    97101 
    98102                super(architecture); 
    99                 competencyName = "MigrationCompetency"; 
    100                 competencyType = "Migration"; 
     103                this.competencyName = "MigrationCompetency"; 
     104                this.competencyType = "Migration"; 
     105                 
    101106                this.configFile = configFile; 
     107                this.lockingObjects = new HashSet<Object>(); 
     108                this.migrationOnHalt = false; 
    102109                 
    103110                try { 
     
    141148                 
    142149                this.getRequestHandlers().add(new MigrationExecuter()); 
     150                this.getEventHandlers().add(new MigrationStartHandler()); 
    143151                 
    144152                //Get and parse the initialization file 
     
    196204                migrationDocument = docBuilder.newDocument(); 
    197205                raise(new MigrationStart(destination, migrationDocument)); 
    198                 schedule(new ExecuteMigration()); 
    199206                 
    200207                while(!finishedMigration){ 
     
    227234         
    228235        public void addMigrationData(Element xmlElement){ 
    229                 System.out.println("Adding Migration Data"); 
    230236                migrationElements.add(xmlElement); 
    231237        } 
     
    392398                @Override 
    393399                public void invoke(IEvent evt) { 
    394                         System.out.println("Synchronization Start"); 
    395400                        SynchronizationStart synchStart = (SynchronizationStart) evt; 
    396401                         
     
    408413                 
    409414                public MigrationExecuter() { 
    410                         super(new TypeSet(ExecuteMigration.class)); 
     415                        super(new TypeSet(ExecuteMigration.class, HaltMigration.class, ResumeMigration.class)); 
    411416                } 
    412417                 
    413418                @Override 
    414419                public void invoke(IReadOnlyQueueSet<Request> requests) { 
    415                         sync.schedule(new Synchronize(destination.getHost(), destination.getPort())); 
     420                         
     421                        for(HaltMigration request : requests.get(HaltMigration.class)){ 
     422                                lockingObjects.add(request.lockingObject); 
     423                        } 
     424                         
     425                        for(ResumeMigration request : requests.get(ResumeMigration.class)){ 
     426                                lockingObjects.remove(request.lockingObject); 
     427                        } 
     428                         
     429                        if(!requests.get(ExecuteMigration.class).isEmpty() || migrationOnHalt){ 
     430                                 
     431                                if(lockingObjects.isEmpty()){ 
     432                                        migrationOnHalt = false; 
     433                                        sync.schedule(new Synchronize(destination.getHost(), destination.getPort())); 
     434                                } else { 
     435                                        migrationOnHalt = true; 
     436                                } 
     437                        } 
     438                } 
     439        } 
     440         
     441        private class MigrationStartHandler extends EventHandler{ 
     442                 
     443                public MigrationStartHandler(){ 
     444                        super(MigrationStart.class); 
     445                } 
     446                 
     447                @Override 
     448                public void invoke(IEvent evt) { 
     449                        schedule(new ExecuteMigration()); 
    416450                } 
    417451        } 
  • libs/cmion/cmionMain/src/cmion/level2/migration/Migrating.java

    r362 r366  
    3131        public Element saveState(Document document); 
    3232         
    33         public void onMigrationIn(); 
    34          
    35         public void onMigrationOut(); 
    36          
    37         public void onMigrationSuccess(); 
    38          
    39         public void onMigrationFailure(); 
    40          
    4133} 
  • libs/cmion/cmionMain/src/cmion/level2/migration/MigrationFailedHandler.java

    r362 r366  
    88         
    99        private Migration competency; 
    10         private Migrating component; 
     10        private MigrationAware component; 
    1111         
    12         public MigrationFailedHandler(Migration competency, Migrating component){ 
     12        public MigrationFailedHandler(Migration competency, MigrationAware component){ 
    1313                super(MigrationFailed.class); 
    1414                this.competency = competency; 
     
    2525        } 
    2626         
    27         public Migrating getComponent(){ 
     27        public MigrationAware getComponent(){ 
    2828                return this.component; 
    2929        } 
  • libs/cmion/cmionMain/src/cmion/level2/migration/MigrationReceivedHandler.java

    r362 r366  
    88 
    99        private Migration competency; 
    10         private Migrating component; 
     10        private MigrationAware component; 
    1111         
    12         public MigrationReceivedHandler(Migration competency, Migrating component){ 
     12        public MigrationReceivedHandler(Migration competency, MigrationAware component){ 
    1313                super(IncomingMigration.class); 
    1414                this.competency = competency; 
     
    2525        } 
    2626         
    27         public Migrating getComponent(){ 
     27        public MigrationAware getComponent(){ 
    2828                return this.component; 
    2929        } 
  • libs/cmion/cmionMain/src/cmion/level2/migration/MigrationSucceededHandler.java

    r362 r366  
    88 
    99        private Migration competency; 
    10         private Migrating component; 
     10        private MigrationAware component; 
    1111         
    12         public MigrationSucceededHandler(Migration competency, Migrating component){ 
     12        public MigrationSucceededHandler(Migration competency, MigrationAware component){ 
    1313                super(MigrationComplete.class); 
    1414                this.competency = competency; 
     
    2525        } 
    2626         
    27         public Migrating getComponent(){ 
     27        public MigrationAware getComponent(){ 
    2828                return this.component; 
    2929        } 
  • libs/cmion/cmionMain/src/cmion/level2/migration/MigrationUtils.java

    r362 r366  
    88public class MigrationUtils { 
    99 
    10         public static void registerAllComponents(Simulation simulation){ 
    11                  
     10        public static Migration getMigration(Simulation simulation){ 
    1211                for(Element element : simulation.getElements()){ 
    1312                        if(element instanceof Migration){ 
    14                                 Migration competency = (Migration) element; 
    15                                  
    16                                 registerAllComponents(simulation, competency); 
    17                                  
    18                                 break; 
     13                                return (Migration) element; 
    1914                        } 
    2015                } 
    2116                 
     17                return null; 
    2218        } 
    2319         
    24         public static void registerAllComponents(Simulation simulation, Migration competency){ 
     20        public static void registerAllComponents(){ 
     21                registerAllComponents(Simulation.instance); 
     22        } 
     23         
     24        public static void registerAllComponents(Simulation simulation){ 
     25                registerMigratingComponents(simulation); 
     26                registerMigrationAwareComponents(simulation); 
     27        } 
     28         
     29        public static void registerMigratingComponents(){ 
     30                registerMigratingComponents(Simulation.instance); 
     31        } 
     32         
     33        public static void registerMigratingComponents(Simulation simulation){ 
     34 
     35                Migration competency = getMigration(simulation); 
     36                registerMigratingComponents(simulation, competency); 
     37 
     38        } 
     39         
     40        public static void registerMigratingComponents(Migration competency){ 
     41                registerMigratingComponents(Simulation.instance, competency); 
     42        } 
     43         
     44        public static void registerMigratingComponents(Simulation simulation, Migration competency){ 
    2545                 
    2646                for(Element migratingElement : simulation.getElements()){ 
     
    2848                                Migrating component = (Migrating) migratingElement; 
    2949                                 
    30                                 registerComponent(competency, component); 
     50                                registerMigratingComponent(competency, component); 
    3151                        } 
    3252                } 
    3353        } 
    3454         
    35         public static void registerComponent(Migration competency, Migrating component){ 
     55        public static void registerMigratingComponent(Migration competency, Migrating component){ 
     56                 
    3657                EventHandler handler = new SaveStateHandler(competency, component); 
    3758                competency.getEventHandlers().add(handler); 
     
    3960                handler = new RestoreStateHandler(competency, component); 
    4061                competency.getEventHandlers().add(handler); 
     62        } 
     63         
     64        public static void registerMigrationAwareComponents(){ 
     65                registerMigrationAwareComponents(Simulation.instance); 
     66        } 
     67         
     68        public static void registerMigrationAwareComponents(Simulation simulation){ 
     69 
     70                Migration competency = getMigration(simulation); 
     71                registerMigrationAwareComponents(simulation, competency); 
     72 
     73        } 
     74         
     75        public static void registerMigrationAwareComponents(Migration competency){ 
     76                registerMigrationAwareComponents(Simulation.instance, competency); 
     77        } 
     78         
     79        public static void registerMigrationAwareComponents(Simulation simulation, Migration competency){ 
    4180                 
    42                 handler = new MigrationReceivedHandler(competency, component); 
     81                for(Element migratingElement : simulation.getElements()){ 
     82                        if(migratingElement instanceof MigrationAware){ 
     83                                MigrationAware component = (MigrationAware) migratingElement; 
     84                                 
     85                                registerMigrationAwareComponent(competency, component); 
     86                        } 
     87                } 
     88        } 
     89         
     90        public static void registerMigrationAwareComponent(Migration competency, MigrationAware component){ 
     91 
     92                EventHandler handler = new MigrationReceivedHandler(competency, component); 
     93                competency.getEventHandlers().add(handler); 
     94                 
     95                handler = new SendingMigrationHandler(competency, component); 
    4396                competency.getEventHandlers().add(handler); 
    4497                 
     
    49102                competency.getEventHandlers().add(handler); 
    50103        } 
     104         
     105        public static void haltMigration(Object lockingObject){ 
     106                haltMigration(getMigration(Simulation.instance), lockingObject); 
     107        } 
     108         
     109        public static void haltMigration(Migration competency, Object lockingObject){ 
     110                competency.schedule(new HaltMigration(lockingObject)); 
     111        } 
     112         
     113        public static void resumeMigration(Object lockingObject){ 
     114                resumeMigration(getMigration(Simulation.instance), lockingObject); 
     115        } 
     116         
     117        public static void resumeMigration(Migration competency, Object lockingObject){ 
     118                competency.schedule(new ResumeMigration(lockingObject)); 
     119        } 
     120         
     121        public static void addMigrationData(org.w3c.dom.Element data){ 
     122                addMigrationData(getMigration(Simulation.instance), data); 
     123        } 
     124         
     125        public static void addMigrationData(Migration competency, org.w3c.dom.Element data){ 
     126                competency.addMigrationData(data); 
     127        } 
    51128} 
  • libs/cmion/cmionMain/src/cmion/level2/migration/SaveStateHandler.java

    r362 r366  
    2020        @Override 
    2121        public void invoke(IEvent evt) { 
    22                 component.onMigrationOut(); 
    23                  
    2422                MigrationStart migrationStart = (MigrationStart) evt; 
    2523                Element state = component.saveState(migrationStart.document); 
    26                 competency.addMigrationData(state); 
     24                 
     25                if(state != null){ 
     26                        competency.addMigrationData(state); 
     27                } 
    2728        } 
    2829 
  • libs/cmion/cmionMain/src/cmion/level2/migration/Synchronizer.java

    r362 r366  
    255255                         
    256256                        for (Synchronize request : requests.get(Synchronize.class)) { 
    257                                 System.out.println("Synchronization Manager"); 
    258257                                fullMessage = docBuilder.newDocument(); 
    259258                                org.w3c.dom.Element root = fullMessage.createElement(SYNC_TAG); 
     
    324323                                root.appendChild(messageNode); 
    325324                                 
    326                                 writeXML(doc, System.out); 
    327                                  
    328325                                try { 
    329326                                        sendXMLMessage(doc, receivedConnection); 
  • libs/cmion/cmionMain/src/cmion/level3/supersimplemind/SuperSimpleMigratingMindConnector.java

    r362 r366  
    3535import cmion.architecture.IArchitecture; 
    3636import cmion.level2.migration.Migrating; 
     37import cmion.level2.migration.MigrationAware; 
     38import cmion.level2.migration.MigrationUtils; 
    3739import cmion.level3.AgentMindConnector; 
    3840import cmion.level3.MindAction; 
    3941 
    4042/** The connector to a SuperSimpleMind (example implementation of a simple mind interface) */ 
    41 public class SuperSimpleMigratingMindConnector extends AgentMindConnector implements Migrating { 
     43public class SuperSimpleMigratingMindConnector extends AgentMindConnector implements Migrating, MigrationAware { 
    4244 
    4345         
     
    138140        @Override 
    139141        public Element saveState(Document doc) { 
     142                 
     143                //This is the regular case of  migration, where the component can 
     144                //save it's state immediately. 
    140145                Element state = doc.createElement(getMessageTag()); 
    141146                 
     
    145150                 
    146151                return state; 
     152                 
     153                //This simulates a case where you need for information before migrating 
     154                /* 
     155                System.out.println("MIND-Halting migration."); 
     156                MigrationUtils.haltMigration(this); 
     157                DelayedMigration delayedMigration = new DelayedMigration(doc); 
     158                new Thread(delayedMigration).start(); 
     159                return null; 
     160                */ 
    147161        } 
    148162 
     
    171185        } 
    172186 
     187        private class DelayedMigration implements Runnable{ 
     188                 
     189                private Document doc; 
     190                 
     191                public DelayedMigration(Document doc){ 
     192                        this.doc = doc; 
     193                } 
     194                 
     195                @Override 
     196                public void run() { 
     197                         
     198                        try { 
     199                                Thread.sleep(5000); 
     200                        } catch (InterruptedException e) { 
     201                                // TODO Auto-generated catch block 
     202                                e.printStackTrace(); 
     203                        } 
     204                         
     205                        Element state = doc.createElement(getMessageTag()); 
     206                         
     207                        Element goal = doc.createElement("goal"); 
     208                        goal.setAttribute("value", "Migrate Mind with delay"); 
     209                        state.appendChild(goal); 
     210                         
     211                        MigrationUtils.addMigrationData(state); 
     212                        MigrationUtils.resumeMigration(SuperSimpleMigratingMindConnector.this); 
     213                         
     214                        System.out.println("MIND-Migration resumed."); 
     215                } 
     216        } 
    173217} 
Note: See TracChangeset for help on using the changeset viewer.