Changeset 32 for Plugins


Ignore:
Timestamp:
04/10/2007 11:05:42 PM (12 years ago)
Author:
art
Message:
 
Location:
Plugins
Files:
2 added
5 edited

Legend:

Unmodified
Added
Removed
  • Plugins/dynamicResources/Makefile

    r31 r32  
    1111CPPFILES = Plugin.cpp\ 
    1212          Monitor.cpp 
     13 
     14# if we are on linux system, then add this 
     15ifeq ($(OS), Linux) 
     16        CPPFILES += inotify-cxx.cpp 
     17endif 
     18 
    1319                         
    1420# some definitions 
  • Plugins/dynamicResources/Monitor.cpp

    r31 r32  
    2121{ 
    2222        setTaskName("DynamicResourceMonitor"); 
    23          
    24         #ifdef USE_INOTIFY 
    25         mFileDescriptor = 0; 
    26         #endif 
    2723} 
    2824 
     
    3531 
    3632//---------------------------------------------------------------------------------- 
    37 Result Monitor::onAddTask() 
    38 { 
     33Result Monitor::onStartTask() 
     34{ 
     35        Result res = UNKNOWN_ERROR; 
     36         
    3937        // use inotify if supported 
    4038        #ifdef USE_INOTIFY 
    41                 return initInotify(); 
     39                res = initInotify(); 
    4240        #endif 
    4341 
     42        init(); 
    4443         
    4544        // nothing supported, so return an error 
    46         return UNKNOWN_ERROR; 
     45        return res; 
    4746} 
    4847 
     
    5251        // if we support inotify, then do 
    5352        #ifdef USE_INOTIFY 
    54         close(mFileDescriptor); 
    55         NR_Log(Log::LOG_PLUGIN, "dynamicResources: Close inotify subsystem"); 
     53                mInotify->Close(); 
     54                NR_Log(Log::LOG_PLUGIN, "dynamicResources: Close inotify subsystem"); 
    5655        #endif 
    5756         
     
    6867        NR_Log(Log::LOG_PLUGIN, "dynamicResources: Use inotify interface for file monitoring"); 
    6968         
    70         mFileDescriptor = inotify_init(); 
    71         if (mFileDescriptor < 0) 
    72         { 
    73                 NR_Log(Log::LOG_PLUGIN, "dynamicResources: There was an error by initilizing the inotify interafce"); 
     69        try 
     70        { 
     71                mInotify.reset(new Inotify()); 
     72                //mInotify->SetNonBlock(true); 
     73        }catch(InotifyException& e) 
     74        { 
     75                NR_Log(Log::LOG_PLUGIN, Log::LL_ERROR, "dynamicResources: There was an error by initilizing the inotify interafce"); 
     76                NR_Log(Log::LOG_PLUGIN, Log::LL_ERROR, "dynamicResources: %s", e.GetMessage().c_str()); 
    7477                return UNKNOWN_ERROR; 
    7578        } 
    7679         
     80        return OK; 
     81} 
     82#endif 
     83 
     84//---------------------------------------------------------------------------------- 
     85void Monitor::init() 
     86{ 
    7787        // now scan through all resources, which are already loaded 
    7888        const ResourceManager::ResourceGroupMap& res = mRoot->sResourceManager()->getResourceMap(); 
     
    8797                        IResourcePtr pr = mRoot->sResourceManager()->getByHandle(*jt); 
    8898                         
     99                        // resource is valid, so do 
    89100                        if (pr.valid()) 
    90101                        { 
    91102                                // now get the file name associated with the resource  
    92103                                pr.lockPure(); 
    93                                 const std::string& fileName = pr.getBase()->getResFileName(); 
    94                                 printf("found %s - %s\n", pr.getBase()->getResName().c_str(), fileName.c_str()); 
     104                                        const std::list<std::string>& files = pr.getBase()->getResFilenameList(); 
     105                                        std::list<std::string>::const_iterator kt = files.begin(); 
     106                                         
     107                                        // for each filename add a monitor  
     108                                        for (; kt != files.end(); kt ++) 
     109                                        { 
     110                                                addMonitor(pr, *kt); 
     111                                        } 
    95112                                pr.unlockPure(); 
    96                                  
    97113                        }else{ 
    98                                 printf("warning\n"); 
     114                                NR_Log(Log::LOG_PLUGIN, Log::LL_WARNING, "dynamicResources: Resource %s seems to be NULL", pr.getBase()->getResName().c_str()); 
    99115                        } 
    100116                         
    101117                } 
    102118        } 
    103          
    104          
    105         // ok 
    106         return OK; 
    107 } 
     119} 
     120 
     121#ifdef USE_INOTIFY 
     122//---------------------------------------------------------------------------------- 
     123void Monitor::addMonitor(IResourcePtr res, const std::string& file) 
     124{ 
     125        // do only add a watcher if inotify already initialized 
     126        if (!mInotify || !res.valid() || file.length() < 1) return; 
     127         
     128        // we monitor only non-empty resources 
     129        res.lockPure(); 
     130        { 
     131                // create a watch descriptor 
     132                try 
     133                { 
     134                        // create watcher 
     135                        SharedPtr<InotifyWatch> watch(new InotifyWatch(file, IN_MODIFY)); 
     136                         
     137                        // add new watcher 
     138                        NR_Log(Log::LOG_PLUGIN, Log::LL_DEBUG, "dynamicResources: Monitor %s --> %s", res.getBase()->getResName().c_str(), file.c_str()); 
     139                         
     140                        // add the watcher into the map 
     141                        WatchData data; 
     142                        data.resource = res; 
     143                        data.watcher = watch; 
     144                        data.resourceName = res.getBase()->getResName(); 
     145                        mWatchMap[watch->GetDescriptor()] = data; 
     146                         
     147                        // add the new watch  
     148                        mInotify->Add(watch.get()); 
     149                         
     150                }catch(InotifyException& e) 
     151                { 
     152                        NR_Log(Log::LOG_PLUGIN, Log::LL_ERROR, "dynamicResources: Cannot add a monitor %s --> %s", res.getBase()->getResName().c_str(), file.c_str()); 
     153                        NR_Log(Log::LOG_PLUGIN, Log::LL_ERROR, "dynamicResources: %s", e.GetMessage().c_str()); 
     154                        return; 
     155                } 
     156                 
     157        } 
     158        res.unlockPure(); 
     159} 
     160 
     161#else 
     162 
     163//---------------------------------------------------------------------------------- 
     164void Monitor::addMonitor(IResourcePtr res, const std::string& file) 
     165{ 
     166        NR_Log(Log::LOG_PLUGIN, Log::LL_WARNING, "dynamicResources: Not valid monitor interface used to monitor %s --> %s", res.getBase()->getResName().c_str(), file.c_str()); 
     167} 
     168 
    108169#endif 
    109170 
    110 //---------------------------------------------------------------------------------- 
    111 Result Monitor::updateTask() 
    112 { 
    113  
    114         return OK; 
    115 } 
     171 
     172 
     173#ifdef USE_INOTIFY 
     174//---------------------------------------------------------------------------------- 
     175Result Monitor::update() 
     176{ 
     177        if (!mInotify) return OK; 
     178         
     179        printf("update\n"); 
     180        // wait for inotify events 
     181        try{ 
     182                mInotify->WaitForEvents(); 
     183        }catch(InotifyException& e) 
     184        { 
     185                NR_Log(Log::LOG_PLUGIN, Log::LL_ERROR, "dynamicResources: INotify Monitor cannot get events!"); 
     186                NR_Log(Log::LOG_PLUGIN, Log::LL_ERROR, "dynamicResources: %s", e.GetMessage().c_str()); 
     187                return OK; 
     188        } 
     189        printf("ok\n"); 
     190         
     191        // now extract events until there are no more of them  
     192        InotifyEvent event; 
     193        while(mInotify->GetEventCount() > 0) 
     194        { 
     195                // get event 
     196                try 
     197                { 
     198                        mInotify->GetEvent(&event); 
     199                        WatchData& data = mWatchMap[event.GetDescriptor()]; 
     200                         
     201                        if (data.resource.valid()) 
     202                        { 
     203                                data.resource.lockPure(); 
     204                                        printf("modified: %s\n", data.resource.getBase()->getResName().c_str()); 
     205                                data.resource.unlockPure(); 
     206                        }else{ 
     207                                NR_Log(Log::LOG_PLUGIN, Log::LL_WARNING, "dynamicResources: Monitored %s resource is not valid!", data.resourceName.c_str()); 
     208                        } 
     209                } 
     210                catch(InotifyException& e) 
     211                { 
     212                        NR_Log(Log::LOG_PLUGIN, Log::LL_ERROR, "dynamicResources: Cannot retrieve INotify-Event !"); 
     213                        NR_Log(Log::LOG_PLUGIN, Log::LL_ERROR, "dynamicResources: %s", e.GetMessage().c_str()); 
     214                        return OK; 
     215                } 
     216                 
     217        } 
     218 
     219         
     220        return OK; 
     221} 
     222 
     223 
     224#else 
     225//---------------------------------------------------------------------------------- 
     226Result Monitor::update() 
     227{ 
     228        return OK; 
     229} 
     230 
     231#endif 
     232 
     233 
  • Plugins/dynamicResources/Monitor.h

    r31 r32  
    2424 
    2525#if NR_PLATFORM == NR_PLATFORM_LINUX 
    26         #include "inotify.h" 
    27         #include "inotify-syscalls.h" 
     26        #include "inotify-cxx.h" 
    2827        #define USE_INOTIFY 
    2928#endif 
     
    4847                 
    4948                //! Initialize the task, cause ti was added to the kernel 
    50                 Result onAddTask(); 
     49                Result onStartTask(); 
    5150                 
    5251                //! Update the task 
    53                 Result updateTask(); 
     52                Result updateTask() { return update();} 
    5453 
    5554 
     
    5958                Engine* mRoot; 
    6059                 
     60                //! Initialize the monitor  
     61                void init(); 
     62                 
     63                //! Update the monitoring interface 
     64                Result update(); 
     65                 
     66                //! Add new file and associated resource to watch on 
     67                void addMonitor (IResourcePtr res, const std::string& file); 
     68 
    6169                // We are using inotify interface 
    6270                #ifdef USE_INOTIFY 
    6371                 
    64                 //! file descriptor 
    65                 int mFileDescriptor; 
     72                        //! file descriptor 
     73                        SharedPtr<Inotify> mInotify; 
     74                         
     75                        //! To watch we use this structures 
     76                        typedef struct _WatchData 
     77                        { 
     78                                IResourcePtr resource; 
     79                                SharedPtr<InotifyWatch> watcher; 
     80                                std::string resourceName; 
     81                        } WatchData; 
     82                         
     83                        //! Define map type for appropriate storing of watch descriptors 
     84                        typedef std::map<int, WatchData > WatcherMap; 
     85                         
     86                        //! Here we store the watching descriptors for the files 
     87                        WatcherMap mWatchMap; 
     88                         
     89                        //! Initialize inotify interface 
     90                        Result initInotify(); 
     91                #endif 
    6692                 
    67                 //! Initialize inotify interface 
    68                 Result initInotify(); 
    69                  
    70                 #endif 
    7193}; 
    7294 
  • Plugins/dynamicResources/Plugin.cpp

    r31 r32  
    1616//--------------------------------------------------------- 
    1717Engine*  mRoot = NULL; 
    18 bool     mThreaded = false; 
     18bool     mThreaded = true; 
    1919SharedPtr<Monitor>  mTask; 
    2020TaskId   mTaskId = 0; 
     
    3838        if (args) 
    3939        { 
    40                 if (args->exists("threaded")) 
     40                if (args->exists("isThreade")) 
    4141                { 
    42                         Property& prop = (*args)["threaded"]; 
    43                         NR_Log(Log::LOG_PLUGIN, "dynamicResources: Parameter 'threaded' is given, use it!"); 
     42                        Property& prop = (*args)["isThreaded"]; 
     43                        NR_Log(Log::LOG_PLUGIN, "dynamicResources: Parameter 'isThreaded' is given, use it!"); 
    4444                        try{ 
    4545                                mThreaded = prop.get<bool>(); 
     
    4848                                if (!prop.hasUserData()) 
    4949                                { 
    50                                         NR_Log(Log::LOG_PLUGIN, "dynamicResources: Parameter 'threaded' does not contain valid value nor user data!"); 
     50                                        NR_Log(Log::LOG_PLUGIN, "dynamicResources: Parameter 'isThreaded' does not contain valid value nor user data!"); 
    5151                                }else 
    5252                                        mThreaded = *(static_cast<bool*>(prop.getUserData())); 
  • Plugins/luaScripting/ScriptLoader.h

    r15 r32  
    6767        IResource* createResourceImpl(const std::string& resourceType, PropertyList* params = NULL); 
    6868 
     69        /** 
     70        * @see IResourceLoader::getSuffix() 
     71        **/ 
     72        std::string getSuffix(const std::string& resType) { return "lua"; } 
     73 
    6974}; 
    7075 
Note: See TracChangeset for help on using the changeset viewer.