Ignore:
Timestamp:
06/11/13 09:33:58 (11 years ago)
Author:
jripsl
Message:

Improve "config-card" file handling.
Use explicite function for "repo_io" module initialization

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/Monitoring/smon/repo_io.py

    r866 r871  
    3131 
    3232 
    33 # -- methods -- # 
    34  
    35 def init(): 
    36         if mode==CSTE_MODE_LOCAL_REPO: 
    37                 repo.connect() 
    38         elif mode==CSTE_MODE_REMOTE_REPO: 
    39                 _CONNECTION = "postgresql://postgres:Silence107!@localhost:5432/prodiguer" 
    40                 prodiguer_shared.connect(_CONNECTION) 
    41         elif mode==CSTE_MODE_REMOTE_REPO_STUB: 
    42                 pass 
    43         else: 
    44                 raise Exception("ERR004 - incorrect mode") 
    45  
    46 def free(): 
    47         if mode==CSTE_MODE_LOCAL_REPO: 
    48                 repo.close() 
    49         elif mode==CSTE_MODE_REMOTE_REPO: 
    50  
    51                 #prodiguer_shared.close() 
    52                 pass 
    53         elif mode==CSTE_MODE_REMOTE_REPO_STUB: 
    54                 pass 
    55         else: 
    56                 raise Exception("ERR009 - incorrect mode") 
    57  
    58 def test(): 
    59         repo.create_message("test2", 2, "bla2") 
    60         commit() 
    61  
    62         repo.update_simulation_status('1pctCO22', 'ERROR') 
    63         commit() 
    64  
    65         repo.create_message("test3", 3, "bla3") 
    66         rollback() 
    67  
    68 def commit(): 
    69         if mode==CSTE_MODE_LOCAL_REPO: 
    70                 repo.commit() 
    71         elif mode==CSTE_MODE_REMOTE_REPO: 
    72                 elixir.session.commit() 
    73         elif mode==CSTE_MODE_REMOTE_REPO_STUB: 
    74                 pass 
    75         else: 
    76                 raise Exception("ERR002 - incorrect mode") 
    77  
    78 def rollback(): 
    79         if mode==CSTE_MODE_LOCAL_REPO: 
    80                 repo.rollback() 
    81         elif mode==CSTE_MODE_REMOTE_REPO: 
    82                 elixir.session.rollback() 
    83         elif mode==CSTE_MODE_REMOTE_REPO_STUB: 
    84                 pass 
    85         else: 
    86                 raise Exception("ERR003 - incorrect mode") 
    87  
    88 def retrieve_simulation(name): 
    89         simulation=None 
    90  
    91         if mode==CSTE_MODE_LOCAL_REPO: 
    92                 simulation=repo.retrieve_simulation(name) 
    93         elif mode==CSTE_MODE_REMOTE_REPO: 
    94  
    95                 # prepare args 
    96                 # .. 
    97  
    98                 # execute 
    99                 s=repo.retrieve_simulation(name) 
    100  
    101                 # process return values 
    102                 simulation=smon.types.Simulation(exec_start_date=s.ExecutionStartDate,exec_end_date=s.ExecutionEndDate,status=s.ExecutionState) # ExecutionState example: EXECUTION_STATE_RUNNING, EXECUTION_STATE_SET.. 
    103  
    104         elif mode==CSTE_MODE_REMOTE_REPO_STUB: 
    105                 pass 
    106         else: 
    107                 raise Exception("ERR014 - incorrect mode") 
    108  
    109         return simulation 
    110  
    111 def delete_simulation(name): 
    112         if mode==CSTE_MODE_LOCAL_REPO: 
    113                 repo.delete_simulation(name) 
    114         elif mode==CSTE_MODE_REMOTE_REPO: 
    115  
    116                 # prepare args 
    117                 # .. 
    118  
    119                 # execute 
    120                 repo.delete_simulation(name) 
    121  
    122                 # process return values 
    123                 # .. 
    124  
    125         elif mode==CSTE_MODE_REMOTE_REPO_STUB: 
    126                 pass 
    127         else: 
    128                 raise Exception("ERR015 - incorrect mode") 
    129  
    130 def create_simulation(simulation): 
    131         if mode==CSTE_MODE_LOCAL_REPO: 
    132                 repo.create_simulation(simulation) 
    133         elif mode==CSTE_MODE_REMOTE_REPO: 
    134  
    135                 # prepare args 
    136                 # .. 
    137  
    138                 # execute 
    139                 repo.create_simulation(activity) 
    140  
    141                 # process return values 
    142                 # .. 
    143  
    144         elif mode==CSTE_MODE_REMOTE_REPO_STUB: 
    145                 pass 
    146         else: 
    147                 raise Exception("ERR016 - incorrect mode") 
    148  
    149 def update_simulation_status(simulation): 
    150         if mode==CSTE_MODE_LOCAL_REPO: 
    151                 repo.update_simulation_status(simulation) 
    152         elif mode==CSTE_MODE_REMOTE_REPO: 
    153  
    154                 # prepare args 
    155                 # .. 
    156  
    157                 # execute 
    158                 repo.update_simulation_status(name) 
    159  
    160                 # process return values 
    161                 # .. 
    162  
    163         elif mode==CSTE_MODE_REMOTE_REPO_STUB: 
    164                 pass 
    165         else: 
    166                 raise Exception("ERR017 - incorrect mode") 
    167  
    168 def retrieve_messages(simulation): 
    169         message=None 
    170  
    171         if mode==CSTE_MODE_LOCAL_REPO: 
    172                 message=repo.retrieve_messages(simulation) 
    173         elif mode==CSTE_MODE_REMOTE_REPO: 
    174  
    175                 # prepare args 
    176                 # .. 
    177  
    178                 # execute 
    179                 repo.retrieve_messages(name) 
    180  
    181                 # process return values 
    182                 # .. 
    183  
    184         elif mode==CSTE_MODE_REMOTE_REPO_STUB: 
    185                 pass 
    186         else: 
    187                 raise Exception("ERR018 - incorrect mode") 
    188  
    189         return message 
    190  
    191 def delete_messages(simulation): 
    192         if mode==CSTE_MODE_LOCAL_REPO: 
    193                 repo.delete_messages(name) 
    194         elif mode==CSTE_MODE_REMOTE_REPO: 
    195  
    196                 # prepare args 
    197                 # .. 
    198  
    199                 # execute 
    200                 repo.delete_messages(name) 
    201  
    202                 # process return values 
    203                 # .. 
    204  
    205         elif mode==CSTE_MODE_REMOTE_REPO_STUB: 
    206                 pass 
    207         else: 
    208                 raise Exception("ERR019 - incorrect mode") 
    209  
    210 def create_message(message): 
    211         if mode==CSTE_MODE_LOCAL_REPO: 
    212                 repo.create_message(message) 
    213         elif mode==CSTE_MODE_REMOTE_REPO: 
    214  
    215                 # prepare args 
    216                 # .. 
    217  
    218                 # execute 
    219                 repo.create_message() 
    220  
    221                 # process return values 
    222                 # .. 
    223  
    224         elif mode==CSTE_MODE_REMOTE_REPO_STUB: 
    225                 pass 
    226         else: 
    227                 raise Exception("ERR020 - incorrect mode") 
    228  
    229 def retrieve_last_message(simulation): 
    230         message=None 
    231  
    232         if mode==CSTE_MODE_LOCAL_REPO: 
    233                 message=repo.retrieve_last_message(simulation) 
    234         elif mode==CSTE_MODE_REMOTE_REPO: 
    235  
    236                 # prepare args 
    237                 # .. 
    238  
    239                 # execute 
    240                 repo.retrieve_last_message(simulation) 
    241  
    242                 # process return values 
    243                 # .. 
    244  
    245         elif mode==CSTE_MODE_REMOTE_REPO_STUB: 
    246                 pass 
    247         else: 
    248                 raise Exception("ERR021 - incorrect mode") 
    249  
    250         return message 
    251  
    252  
    253 # --- higher level methods --- # 
    254  
    255 def get_running_simulations(): 
    256         running_simulation=[] 
    257  
    258         for s in retrieve_simulation(): 
    259                 if s.status=="running": 
    260                         running_simulation.append(s) 
    261                          
    262         return running_simulation 
    263  
    264  
    265 # --- module init --- # 
     33# --- module static initialization --- # 
    26634 
    26735CSTE_MODE_LOCAL_REPO="local_repo" 
    … …  
    28351 
    28452 
    285 # note that by putting init() call here, it will only be called when first imported by the first import statement 
    286 init() 
    287  
     53 
     54 
     55 
     56 
     57# -- methods -- # 
     58 
     59def init(): 
     60        if mode==CSTE_MODE_LOCAL_REPO: 
     61                repo.connect() 
     62        elif mode==CSTE_MODE_REMOTE_REPO: 
     63                _CONNECTION = "postgresql://postgres:Silence107!@localhost:5432/prodiguer" 
     64                prodiguer_shared.connect(_CONNECTION) 
     65        elif mode==CSTE_MODE_REMOTE_REPO_STUB: 
     66                pass 
     67        else: 
     68                raise Exception("ERR004 - incorrect mode") 
     69 
     70def free(): 
     71        if mode==CSTE_MODE_LOCAL_REPO: 
     72                repo.free() 
     73        elif mode==CSTE_MODE_REMOTE_REPO: 
     74 
     75                #prodiguer_shared.close() 
     76                pass 
     77        elif mode==CSTE_MODE_REMOTE_REPO_STUB: 
     78                pass 
     79        else: 
     80                raise Exception("ERR009 - incorrect mode") 
     81 
     82def populate_tables_with_sample(): 
     83        repo.populate_tables_with_sample() 
     84 
     85def retrieve_simulations(): 
     86        return repo.retrieve_simulations() 
     87 
     88def test(): 
     89        repo.create_message("test2", 2, "bla2") 
     90        commit() 
     91 
     92        repo.update_simulation_status('1pctCO22', 'ERROR') 
     93        commit() 
     94 
     95        repo.create_message("test3", 3, "bla3") 
     96        rollback() 
     97 
     98def commit(): 
     99        if mode==CSTE_MODE_LOCAL_REPO: 
     100                repo.commit() 
     101        elif mode==CSTE_MODE_REMOTE_REPO: 
     102                elixir.session.commit() 
     103        elif mode==CSTE_MODE_REMOTE_REPO_STUB: 
     104                pass 
     105        else: 
     106                raise Exception("ERR002 - incorrect mode") 
     107 
     108def rollback(): 
     109        if mode==CSTE_MODE_LOCAL_REPO: 
     110                repo.rollback() 
     111        elif mode==CSTE_MODE_REMOTE_REPO: 
     112                elixir.session.rollback() 
     113        elif mode==CSTE_MODE_REMOTE_REPO_STUB: 
     114                pass 
     115        else: 
     116                raise Exception("ERR003 - incorrect mode") 
     117 
     118def retrieve_simulation(name): 
     119        simulation=None 
     120 
     121        if mode==CSTE_MODE_LOCAL_REPO: 
     122                simulation=repo.retrieve_simulation(name) 
     123        elif mode==CSTE_MODE_REMOTE_REPO: 
     124 
     125                # prepare args 
     126                # .. 
     127 
     128                # execute 
     129                s=repo.retrieve_simulation(name) 
     130 
     131                # process return values 
     132                simulation=smon.types.Simulation(exec_start_date=s.ExecutionStartDate,exec_end_date=s.ExecutionEndDate,status=s.ExecutionState) # ExecutionState example: EXECUTION_STATE_RUNNING, EXECUTION_STATE_SET.. 
     133 
     134        elif mode==CSTE_MODE_REMOTE_REPO_STUB: 
     135                pass 
     136        else: 
     137                raise Exception("ERR014 - incorrect mode") 
     138 
     139        return simulation 
     140 
     141def delete_simulation(name): 
     142        if mode==CSTE_MODE_LOCAL_REPO: 
     143                repo.delete_simulation(name) 
     144        elif mode==CSTE_MODE_REMOTE_REPO: 
     145 
     146                # prepare args 
     147                # .. 
     148 
     149                # execute 
     150                repo.delete_simulation(name) 
     151 
     152                # process return values 
     153                # .. 
     154 
     155        elif mode==CSTE_MODE_REMOTE_REPO_STUB: 
     156                pass 
     157        else: 
     158                raise Exception("ERR015 - incorrect mode") 
     159 
     160def create_simulation(simulation): 
     161        if mode==CSTE_MODE_LOCAL_REPO: 
     162                repo.create_simulation(simulation) 
     163        elif mode==CSTE_MODE_REMOTE_REPO: 
     164 
     165                # prepare args 
     166                # .. 
     167 
     168                # execute 
     169                repo.create_simulation(activity) 
     170 
     171                # process return values 
     172                # .. 
     173 
     174        elif mode==CSTE_MODE_REMOTE_REPO_STUB: 
     175                pass 
     176        else: 
     177                raise Exception("ERR016 - incorrect mode") 
     178 
     179def update_simulation_status(simulation): 
     180        if mode==CSTE_MODE_LOCAL_REPO: 
     181                repo.update_simulation_status(simulation) 
     182        elif mode==CSTE_MODE_REMOTE_REPO: 
     183 
     184                # prepare args 
     185                # .. 
     186 
     187                # execute 
     188                repo.update_simulation_status(name) 
     189 
     190                # process return values 
     191                # .. 
     192 
     193        elif mode==CSTE_MODE_REMOTE_REPO_STUB: 
     194                pass 
     195        else: 
     196                raise Exception("ERR017 - incorrect mode") 
     197 
     198def retrieve_messages(simulation): 
     199        message=None 
     200 
     201        if mode==CSTE_MODE_LOCAL_REPO: 
     202                message=repo.retrieve_messages(simulation) 
     203        elif mode==CSTE_MODE_REMOTE_REPO: 
     204 
     205                # prepare args 
     206                # .. 
     207 
     208                # execute 
     209                repo.retrieve_messages(name) 
     210 
     211                # process return values 
     212                # .. 
     213 
     214        elif mode==CSTE_MODE_REMOTE_REPO_STUB: 
     215                pass 
     216        else: 
     217                raise Exception("ERR018 - incorrect mode") 
     218 
     219        return message 
     220 
     221def delete_messages(simulation): 
     222        if mode==CSTE_MODE_LOCAL_REPO: 
     223                repo.delete_messages(name) 
     224        elif mode==CSTE_MODE_REMOTE_REPO: 
     225 
     226                # prepare args 
     227                # .. 
     228 
     229                # execute 
     230                repo.delete_messages(name) 
     231 
     232                # process return values 
     233                # .. 
     234 
     235        elif mode==CSTE_MODE_REMOTE_REPO_STUB: 
     236                pass 
     237        else: 
     238                raise Exception("ERR019 - incorrect mode") 
     239 
     240def create_message(message): 
     241        if mode==CSTE_MODE_LOCAL_REPO: 
     242                repo.create_message(message) 
     243        elif mode==CSTE_MODE_REMOTE_REPO: 
     244 
     245                # prepare args 
     246                # .. 
     247 
     248                # execute 
     249                repo.create_message() 
     250 
     251                # process return values 
     252                # .. 
     253 
     254        elif mode==CSTE_MODE_REMOTE_REPO_STUB: 
     255                pass 
     256        else: 
     257                raise Exception("ERR020 - incorrect mode") 
     258 
     259def retrieve_last_message(simulation): 
     260        message=None 
     261 
     262        if mode==CSTE_MODE_LOCAL_REPO: 
     263                message=repo.retrieve_last_message(simulation) 
     264        elif mode==CSTE_MODE_REMOTE_REPO: 
     265 
     266                # prepare args 
     267                # .. 
     268 
     269                # execute 
     270                repo.retrieve_last_message(simulation) 
     271 
     272                # process return values 
     273                # .. 
     274 
     275        elif mode==CSTE_MODE_REMOTE_REPO_STUB: 
     276                pass 
     277        else: 
     278                raise Exception("ERR021 - incorrect mode") 
     279 
     280        return message 
     281 
     282 
     283# --- higher level methods --- # 
     284 
     285def get_running_simulations(): 
     286        running_simulation=[] 
     287 
     288        for s in retrieve_simulation(): 
     289                if s.status=="running": 
     290                        running_simulation.append(s) 
     291                         
     292        return running_simulation 
     293 
     294 
Note: See TracChangeset for help on using the changeset viewer.