void LodWorkQueueWorker::addRequestToQueue( LodConfig& lodConfig, LodCollapseCostPtr& cost, LodDataPtr& data, LodInputProviderPtr& input, LodOutputProviderPtr& output, LodCollapserPtr& collapser ) { LodWorkQueueRequest* req = new LodWorkQueueRequest(); req->config = lodConfig; req->cost = cost; req->data = data; req->input = input; req->output = output; req->collapser = collapser; addRequestToQueue(req); }
void *accept_request(void *sockid){ struct sockaddr_in client_addr; unsigned clientLength; int cSockfd; int nThreads; char *clientip; FILE *fin; FILE *fout; //creating queue if debug!=1 if(runTimeArgs->debug!=1) requeue= newReqQueue(-1); else requeue=newReqQueue(1); schedQueue=newReqQueue(1); pthread_key_create(&tName, NULL); time_t t; t = time(NULL); char requestString[1024]; int sockfd = *((int*) sockid); listen(sockfd, 5); if(runTimeArgs->debug==1) nThreads=1; else if(runTimeArgs->threadCount>0) nThreads=runTimeArgs->threadCount; else nThreads=4; createSchedulerAndSlaves(nThreads); while(1){ clientLength = sizeof(client_addr); cSockfd = accept(sockfd, (struct sockaddr *) &client_addr, &clientLength); if(cSockfd < 0){ exit(0); } struct requestData *req=malloc(1* sizeof(*req)); req->next=NULL; req->socketID=cSockfd; clientip=inet_ntoa(client_addr.sin_addr); req->clientIP=strdup(clientip); read(cSockfd, requestString, sizeof(requestString)); // read request from socket //printf("\n%s\n",requestString); process_request(req,requestString); req->queuedTime=strdup(asctime(gmtime(&t)));//gmtime(&t);//storing request queuing time in GMT addRequestToQueue(requeue, req); } }
PlatformNATTraversalWorker::~PlatformNATTraversalWorker() { stopRequested = true; addRequestToQueue(boost::shared_ptr<PlatformNATTraversalRequest>()); thread->join(); delete thread; #ifdef HAVE_LIBNATPMP delete natPMPInterface; #endif #ifdef HAVE_LIBMINIUPNPC delete miniUPnPInterface; #endif delete nullNATTraversalInterface; }
void *scheduleRequest(void *arg){ delayScheduling(); time_t tim; tim=time(NULL); struct requestData *iterator; struct requestData *req = NULL; int *id = (int *)arg; pthread_setspecific(tName,(void *)id); int minsize; while (1) { pthread_mutex_lock(&requeue->lock); while(requeue->head == NULL){ fflush(stdout); pthread_cond_wait(&requeue -> not_empty,&requeue->lock); fflush(stdout); } pthread_mutex_lock(&schedQueue->lock); while (schedQueue->queueSize == schedQueue->capacity) { fflush(stdout); pthread_cond_wait(&schedQueue->not_full, &schedQueue->lock); fflush(stdout); } pthread_mutex_unlock(&schedQueue->lock); iterator = requeue->head; minsize = -1; req = iterator; if (runTimeArgs->schedAlg != NULL && strcmp(runTimeArgs->schedAlg, "sjf") == 0) { while (iterator != NULL) { if (minsize == -1) { minsize = iterator->fileSize; } if (minsize > iterator->fileSize) { minsize = iterator->fileSize; req = iterator; } iterator = iterator->next; } } pthread_mutex_unlock(&requeue->lock); if (req != NULL) { deleteReqFromQueue(requeue, req); req->scheduledTime = strdup(asctime(gmtime(&tim)));//strdup(get_current_time_gmt()); addRequestToQueue(schedQueue, req); } fflush(stdout); } }
/** * Try to load file from cache or download a remote file if not in cache * * @param m the maps containing the settings of the main.cfg file * @param content the map to update * @param hInternet the HINTERNET pointer * @param url the url to fetch * @return 0 */ int loadRemoteFile(maps** m,map** content,HINTERNET* hInternet,char *url){ char* fcontent = NULL; char* cached=isInCache(*m,url); char *mimeType=NULL; int fsize=0; map* t=getMap(*content,"xlink:href"); if(t==NULL){ t=getMap((*content),"href"); addToMap(*content,"xlink:href",url); } if(cached!=NULL){ struct stat f_status; int s=stat(cached, &f_status); if(s==0){ fcontent=(char*)malloc(sizeof(char)*(f_status.st_size+1)); FILE* f=fopen(cached,"rb"); fread(fcontent,f_status.st_size,1,f); fsize=f_status.st_size; fcontent[fsize]=0; fclose(f); addToMap(*content,"cache_file",cached); } cached[strlen(cached)-1]='m'; s=stat(cached, &f_status); if(s==0){ mimeType=(char*)malloc(sizeof(char)*(f_status.st_size+1)); FILE* f=fopen(cached,"rb"); fread(mimeType,f_status.st_size,1,f); mimeType[f_status.st_size]=0; fclose(f); } }else{ addRequestToQueue(m,hInternet,url,true); return 0; } if(fsize==0){ return errorException(*m, _("Unable to download the file."), "InternalError",NULL); } if(mimeType!=NULL){ addToMap(*content,"fmimeType",mimeType); } map* tmpMap=getMapOrFill(content,"value",""); free(tmpMap->value); tmpMap->value=(char*)malloc((fsize+1)*sizeof(char)); if(tmpMap->value==NULL || fcontent == NULL) return errorException(*m, _("Unable to allocate memory"), "InternalError",NULL); memcpy(tmpMap->value,fcontent,(fsize+1)*sizeof(char)); char ltmp1[256]; sprintf(ltmp1,"%d",fsize); addToMap(*content,"size",ltmp1); if(cached==NULL){ addToCache(*m,url,fcontent,mimeType,fsize, NULL, 0); } else{ addToMap(*content,"isCached","true"); map* tmp=getMapFromMaps(*m,"main","cacheDir"); if(tmp!=NULL){ map *c=getMap((*content),"xlink:href"); char* md5str=getMd5(c->value); char* fname=(char*)malloc(sizeof(char)*(strlen(tmp->value)+strlen(md5str)+6)); sprintf(fname,"%s/%s.zca",tmp->value,md5str); addToMap(*content,"cache_file",fname); free(fname); } } free(fcontent); free(mimeType); free(cached); return 0; }