TResStatHandler.h

Go to the documentation of this file.

#ifndef TRESSTATHANDLER_H
#define TRESSTATHANDLER_H
#include <new>
#include <string.h>
#include <BaseHandler.h>
#include <Thread.h>
#include <AStorageHandler.h>
#include <UpdateExtendedTypes.h>

template <class T>
class TResStatHandler:public BaseHandler, private Thread
{
  public:
    TResStatHandler(T *storage, AStorageHandler *statisticHandler):BaseHandler(140)
    {
      this->statisticHandler = statisticHandler;
      this->storage = storage;
      queue = NULL;
      queuePos = 0;
      queueSize = 0;
      current = 0;
      inProgress = false;
      statisticHandler->setValue("AdminSiteClearRequestCounter", 0ll);
      statisticHandler->setValue("AdminSiteClearResourceCounter", 0ll);
      statisticHandler->setValue("AdminResListDelRequestCounter", 0ll);
      statisticHandler->setValue("AdminResListDelResourceCounter", 0ll);
      statisticHandler->setValue("AdminResListRequestCounter", 0ll);
    } 
    ~TResStatHandler()
    {
      if(queue)free(queue);
    }
    void* handle(char code, ...)
    {
      setError(0, NULL);
      switch(code)
      {
        case 'a':
        {
          statisticHandler->addToValue("AdminResListRequestCounter", 1ll);
          size_t size = 8192;
          char *ret = (char*)malloc(size + sizeof(int));
          unsigned int *curSize = (unsigned int*)ret;
          *curSize = 0;
          u_int32_t count;
          u_int8_t *res = storage->getResourceList(count);
          for(u_int32_t i = 0; i < count; i ++)
          {
            if(size < (size_t)*curSize + 64)
            {
              size <<= 1;
              ret = (char*)realloc(ret, size);
              curSize = (unsigned int*)ret;
            }
            *curSize += sprintf(ret + sizeof(int) + *curSize, "%llu %u ", *(u_int64_t*)(res + i * (sizeof(u_int64_t) + sizeof(u_int8_t))), (u_int32_t)(*(res + i * (sizeof(u_int64_t) + sizeof(u_int8_t)) + sizeof(u_int64_t))));
          }
          if(res)free(res);
          ret[sizeof(int) + *curSize] = '\0';
          return ret;
          break;
        }
        case 'b':
        {
          statisticHandler->addToValue("AdminResListDelRequestCounter", 1ll);
          va_list list;
          va_start(list, code);
          int *ret = (int*)malloc(sizeof(int));
          *ret = 0;
          char *resources = va_arg(list, char*);
          String str(resources);
          str.urlDecode();
          resources = (char*)str.c_str();
          if(resources)
          {
            int count = 0;
            int len = strlen(resources) / 16;
            char **endptr = NULL;
            if (len > 0)
            {
             u_int64_t *ids = new u_int64_t[len];
             while(*resources && count < len)
             {
               while(*resources && (*resources < '0' || *resources > '9'))resources++;
               if(*resources)
               {
                 ids[count++] = (u_int64_t)strtoull(resources, endptr, 10);
                 resources = *endptr;
                 if (!resources)
                 {
                   break;
                 }
               }
             }
             *ret = storage->delResourceList(ids, count);
             statisticHandler->addToValue("AdminResListDelResourceCounter", (long long)(*ret));             
             delete []ids;
            } 
          }          
/*         
          statisticHandler->addToValue("AdminResListDelRequestCounter", 1ll);
          va_list list;
          va_start(list, code);
          int *ret = (int*)malloc(sizeof(int));
          *ret = 0;
          char *resources = va_arg(list, char*);
          String str(resources);
          str.urlDecode();
          resources = (char*)str.c_str();
          if(resources)
          {
            int count = atoi(resources);
            if(count)
            {
              u_int64_t *ids = new u_int64_t[count];
              int i = 0;
              while(*resources >= '0' && *resources <='9')resources++;
              while(*resources && i < count)
              {
                while(*resources && (*resources < '0' || *resources > '9'))resources++;
                if(*resources)
                {
                  ids[i++] = (u_int64_t)strtoull(resources, NULL, 10);
                }
                while(*resources >= '0' && *resources <='9')resources++;
              }
              count = i;
              *ret = storage->delResourceList(ids, count);
              statisticHandler->addToValue("AdminResListDelResourceCounter", (long long)(*ret));
              delete []ids;
            }
          }
          va_end(list);
          return ret;
          break;
*/          
        }
        case 'c':
        {
          statisticHandler->addToValue("AdminSiteClearRequestCounter", 1ll);
          va_list list;
          va_start(list, code);
          int *ret = (int*)malloc(sizeof(int));
          u_int32_t siteId = va_arg(list, u_int32_t);
          mutex.lock();
          for(u_int32_t i = 0; i < queuePos; i++)
            if(queue[i] == siteId)
            {
              *ret = 0;
//.. FIX MUTEX UNLOCKING 
              mutex.unlock();
              return ret;
            }
          if(queuePos == queueSize)
          {
            queueSize = queueSize == 0 ? 1: (queueSize << 1);
            queue = (u_int32_t*)realloc(queue, sizeof(u_int32_t) * queueSize);
          }
          queue[queuePos++] = siteId;
          *ret = queuePos;
          mutex.unlock();
          if(!inProgress)
          {
            start();
            detach();
          }
          va_end(list);
          return ret;
          break;
        }
        case 'd':
        {
          char *ret = (char*)malloc(128);
          va_list list;
          va_start(list, code);
          u_int32_t siteId = va_arg(list, u_int32_t);
          if(!siteId)
          {
            sprintf(ret, "v1=%u&v2=%u&v3=%u", inProgress?1:0, queuePos, current);//inProgress, count in queue
          }
          else
          {
            bool find = false;
            u_int32_t foundPos = 0;
            mutex.lock();
            if(inProgress && current == siteId)find = true;
            else
            {
              for(u_int32_t i = 0; i < queuePos && !find; i++)
                if(queue[i] == siteId)
                {
                  find = true;
                  foundPos = i;
                }
            }
            mutex.unlock();
            sprintf(ret, "v1=%u&v2=%u&v3=%u", find?1:0, foundPos, current);//inProgress, count in queue
          }
          return ret;
        }
        case 'e':
        {
          bool *ret = (bool*)malloc(1);
          va_list list;
          va_start(list, code);
          char *encodeExtendedTypes = va_arg(list, char *);
          if (!encodeExtendedTypes)
          {
            sprintf((char *)ret, "%c", 0);
          }
          else
          {
            String decodeString (encodeExtendedTypes);
            decodeString.urlDecode();
            if (decodeString.c_str());
            {
               UpdatedExtendedTypes updateExtendedTypes;
               string s (decodeString.c_str());
               updateExtendedTypes.parse (s);
               *ret = storage->updateResourcesParams(updateExtendedTypes.getUpdatedTypesList());
            }
          }
          return ret;
        }
        
// ADD new handle code here
        default:
        {
          setError(1, "Wrong command code");
          break;
        }
      }
      return NULL;
    }
 private:
    T *storage;
    AStorageHandler *statisticHandler;
    u_int32_t *queue;
    u_int32_t queuePos;
    u_int32_t queueSize;
    u_int32_t current;
    bool inProgress;
    Mutex  mutex;

    void *run()
    {
      inProgress = true;
      u_int32_t siteId; 
      do
      {
        siteId = u_int32_t(-1);
        mutex.lock();
        if(queuePos)siteId = queue[--queuePos];
        mutex.unlock();
        if(siteId != u_int32_t(-1))
        {
          current = siteId;
          statisticHandler->addToValue("AdminSiteClearResourceCounter", (long long)storage->delBySite(siteId));
        }
      }while(siteId != u_int32_t(-1));
      inProgress = false;
      return NULL;
    }
};

#endif