source: trunk/zoo-project/zoo-kernel/sqlapi.c

Last change on this file was 985, checked in by djay, 8 months ago

Move jobs management and execution endpoint from /processes/{procssId}/jobs to /jobs

  • Property svn:keywords set to Id
File size: 19.0 KB
Line 
1/*
2 * Authors : David Saggiorato
3 *           Gérald Fenoy
4 *  Copyright 2015 GeoLabs SARL. All rights reserved.
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 * THE SOFTWARE.
23 */
24
25#include "ogr_api.h"
26#include "ogrsf_frmts.h"
27#include "ogr_p.h"
28#include "response_print.h"
29#if GDAL_VERSION_MAJOR >= 2
30#include <gdal_priv.h>
31#endif
32
33#include <fcgi_stdio.h>
34#include "sqlapi.h"
35#include "service_callback.h"
36
37/**
38 * Global GDALDataset pointer
39 */
40#if GDAL_VERSION_MAJOR >=2
41GDALDataset
42#else
43OGRDataSource
44#endif
45 **zoo_DS = NULL;
46
47/**
48 * Global OGRLayer pointer pointing to the lastest result set
49 */
50OGRLayer *zoo_ResultSet = NULL;
51
52/**
53 * Create a GDAL / OGR string for connecting to a db backend defined in the
54 * key section.
55 *
56 * @param conf the maps containing the setting of the main.cfg file
57 * @param key the name of the section containing the connection setting
58 * @return the OGR connection string
59 */
60char* _createInitString(maps* conf,const char* key){
61  char* res=NULL;
62  char keywords[6][14]={
63    "dbname",
64    "host",
65    "port",
66    "user",
67    "password",
68    "active_schema"   
69  };
70  int i=0;
71  maps* cconf=getMaps(conf,key);
72  if(cconf==NULL){
73    return "-1";
74  }
75  int len=0;
76  for(i=0;i<6;i++){
77    map* tmp=getMap(cconf->content,keywords[i]);
78    if(tmp!=NULL){
79      if(res==NULL){
80        res=(char*)malloc((strlen(keywords[i])+strlen(tmp->value)+4)*sizeof(char));
81        sprintf(res,"%s='%s'",keywords[i],tmp->value);
82        len+=strlen(res);
83      }else{
84        char* res1=(char*)malloc((strlen(keywords[i])+strlen(tmp->value)+5)*sizeof(char));
85        sprintf(res1," %s='%s'",keywords[i],tmp->value);
86        res=(char*)realloc(res,(len+strlen(keywords[i])+strlen(tmp->value)+5)*sizeof(char));
87        memcpy(res+len,res1,(strlen(keywords[i])+strlen(tmp->value)+5)*sizeof(char));
88        len+=strlen(res1);
89        res[len]=0;
90        free(res1);
91      }
92    }
93  }
94  map* tmp=getMap(cconf->content,"type");
95  if(tmp!=NULL){
96    char* fres=(char*)malloc((strlen(res)+strlen(tmp->value)+2)*sizeof(char));
97    sprintf(fres,"%s:%s",tmp->value,res);
98    free(res);
99    return fres;
100  }
101  return res;
102}
103
104/**
105 * Create a GDAL / OGR string for connecting to the db backend
106 *
107 * @param conf the maps containing the setting of the main.cfg file
108 * @return the OGR connection string
109 */
110char* createInitString(maps* conf){
111  return _createInitString(conf,"database");
112}
113
114/**
115 * Connect to a db backend.
116 *
117 * @param conf the maps containing the setting of the main.cfg file
118 * @see createInitString
119 */
120int _init_sql(maps* conf,const char* key){
121  char* sqlInitString=_createInitString(conf,key);
122#ifdef SQL_DEBUG
123  fprintf(stderr,"Try to connect to: %s %s !\n",key,sqlInitString);
124  fflush(stderr); 
125#endif
126  if(strncmp(sqlInitString,"-1",2)==0)
127    return -1;
128  OGRSFDriver *poDriver = NULL;
129  OGRRegisterAll();
130  int zoo_ds_nb=0;
131  map* dsNb=getMapFromMaps(conf,"lenv","ds_nb");
132  if(dsNb==NULL){
133    setMapInMaps(conf,"lenv","ds_nb","1");
134  }else{
135    zoo_ds_nb=atoi(dsNb->value);
136    char* tmp=(char*)malloc(11*sizeof(char));
137    sprintf(tmp,"%d",zoo_ds_nb+1);
138    setMapInMaps(conf,"lenv","ds_nb",(const char*)tmp);
139    free(tmp);
140  }
141  if(zoo_DS==NULL)
142    zoo_DS=
143#if GDAL_VERSION_MAJOR >= 2
144      (GDALDataset**) malloc(sizeof(GDALDataset*))
145#else
146      (OGRDataSource**) malloc(sizeof(OGRDataSource*))
147#endif
148      ;
149  else
150    zoo_DS=     
151#if GDAL_VERSION_MAJOR >= 2
152      (GDALDataset**)realloc(zoo_DS,(zoo_ds_nb+1)*sizeof(GDALDataset*))
153#else
154      (OGRDataSource**)realloc(zoo_DS,(zoo_ds_nb+1)*sizeof(OGRDataSource*))
155#endif
156      ;
157 
158#if GDAL_VERSION_MAJOR >= 2
159  zoo_DS[zoo_ds_nb] = (GDALDataset*) GDALOpenEx( sqlInitString,
160                                      GDAL_OF_UPDATE | GDAL_OF_VECTOR,
161                                      NULL, NULL, NULL );
162#else
163  zoo_DS[zoo_ds_nb] = OGRSFDriverRegistrar::Open(sqlInitString,false,&poDriver);
164#endif
165  if( zoo_DS[zoo_ds_nb] == NULL ){
166#ifdef SQL_DEBUG
167    fprintf(stderr,"sqlInitString: %s FAILED !\n",sqlInitString);
168    fflush(stderr);
169#endif
170    free(sqlInitString);
171    setMapInMaps(conf,"lenv","dbIssue","1");
172    setMapInMaps(conf,"lenv","message",_("Failed to connect to the database backend"));
173    return -2;
174  }
175#ifdef SQL_DEBUG
176  fprintf(stderr,"sqlInitString: %s SUCEED !\n",sqlInitString);
177  fflush(stderr);
178#endif
179  free(sqlInitString);
180  zoo_ds_nb++;
181  return zoo_ds_nb;
182}
183
184/**
185 * Connect to the db backend.
186 *
187 * @param conf the maps containing the setting of the main.cfg file
188 * @see createInitString
189 */
190int init_sql(maps* conf){
191  return _init_sql(conf,"database");
192}
193
194/**
195 * Close any connection to the db backend.
196 *
197 * @param conf the maps containing the setting of the main.cfg file
198 */
199void close_sql(maps* conf,int cid){
200  if( zoo_ResultSet != NULL ){
201    zoo_DS[cid]->ReleaseResultSet( zoo_ResultSet );
202    zoo_ResultSet=NULL;
203  }
204  if(zoo_DS!=NULL && zoo_DS[cid]!=NULL){
205#if GDAL_VERSION_MAJOR >= 2
206    GDALClose(zoo_DS[cid]);
207#else
208    OGRDataSource::DestroyDataSource( zoo_DS[cid] );
209#endif
210    zoo_DS[cid]=NULL;
211  }
212}
213
214/**
215 * Call OGRCleanupAll.
216 *
217 */
218void end_sql(){
219  OGRCleanupAll();
220}
221
222/**
223 * Fetch a tuple set by executing a SQL query to the Database Backend.
224 *
225 * @param conf the maps containing the setting of the main.cfg file
226 * @param sqlQuery the SQL query to run
227 * @return NULL in case of failure or an OGRLayer pointer if the query succeed.
228 */
229OGRLayer *fetchSql(maps* conf,int cid,const char* sqlQuery){
230  if(zoo_DS==NULL || zoo_DS[cid]==NULL)
231    return NULL;
232  OGRLayer *res=NULL;
233#ifdef SQL_DEBUG
234  fprintf(stderr,"************************* %s %s %d\n\n",sqlQuery,__FILE__,__LINE__);
235  fflush(stderr);
236#endif
237  res = zoo_DS[cid]->ExecuteSQL( sqlQuery, NULL, NULL);
238  return res;
239}
240
241void cleanFetchSql(maps* conf,int cid,OGRLayer *objects){
242  if( objects != NULL ){
243    zoo_DS[cid]->ReleaseResultSet( objects );
244    objects=NULL;
245  }
246}
247
248/**
249 * Execute a SQL query to the SQL Database Backend.
250 *
251 * @param conf the maps containing the setting of the main.cfg file
252 * @param sqlQuery the SQL query to run
253 * @return -1 in case of failure and 1 if the query succeed.
254 */
255int execSql(maps* conf,int cid,const char* sqlQuery){
256  int res=-1;
257  if(zoo_DS == NULL || zoo_DS[cid]==NULL)
258    return -1;
259  zoo_ResultSet = zoo_DS[cid]->ExecuteSQL( sqlQuery, NULL, NULL);
260  if( zoo_ResultSet != NULL ){
261    res=1;
262  }
263  return res;
264}
265
266/**
267 * Clean any memory allocated by executing a request
268 *
269 * @param conf the maps containing the setting of the main.cfg file
270 * @param sqlQuery the SQL query to run
271 * @return -1 in case of failure and 1 if the query succeed.
272 */
273void cleanUpResultSet(const maps* conf,int cid){
274  if( zoo_ResultSet != NULL ){
275    zoo_DS[cid]->ReleaseResultSet( zoo_ResultSet );
276    zoo_ResultSet=NULL;
277  }
278}
279
280#ifdef RELY_ON_DB
281int getCurrentId(maps* conf){
282  int res=0;
283  map* dsNb=getMapFromMaps(conf,"lenv","ds_nb");
284  if(dsNb!=NULL)
285    res=atoi(dsNb->value);
286  return res;
287}
288
289/**
290 * Record a file stored during ZOO-Kernel execution
291 *
292 * @param conf the maps containing the setting of the main.cfg file
293 * @param filename the file's name
294 * @param type the type (Intput,Output,Response)
295 * @param name the maps containing the setting of the main.cfg file
296 */
297void recordStoredFile(maps* conf,const char* filename,const char* type,const char* name){
298  int zoo_ds_nb=getCurrentId(conf);
299  map *uusid=getMapFromMaps(conf,"lenv","usid");
300  map *schema=getMapFromMaps(conf,"database","schema");
301  char *sqlQuery=(char*)malloc((strlen(schema->value)+strlen(uusid->value)+strlen(filename)+strlen(type)+(name!=NULL?strlen(name):2)+68+1)*sizeof(char));
302  if(name!=NULL)
303    sprintf(sqlQuery,"INSERT INTO %s.files (uuid,filename,nature,name) VALUES ('%s','%s','%s','%s');",schema->value,uusid->value,filename,type,name);
304  else
305    sprintf(sqlQuery,"INSERT INTO %s.files (uuid,filename,nature,name) VALUES ('%s','%s','%s',NULL);",schema->value,uusid->value,filename,type);
306  execSql(conf,zoo_ds_nb-1,sqlQuery);
307  free(sqlQuery);
308  cleanUpResultSet(conf,zoo_ds_nb-1);
309}
310
311/**
312 * Insert the reference tuple corresponding to the running service
313 *
314 * @param conf the maps containing the setting of the main.cfg file
315 */
316void recordServiceStatus(maps* conf){
317  int zoo_ds_nb=getCurrentId(conf);
318  map *sid=getMapFromMaps(conf,"lenv","sid");
319  map *osid=getMapFromMaps(conf,"lenv","osid");
320  map *uusid=getMapFromMaps(conf,"lenv","usid");
321  map *schema=getMapFromMaps(conf,"database","schema");
322  char *sqlQuery=(char*)malloc((strlen(schema->value)+
323                                strlen(uusid->value)+
324                                strlen(osid->value)+
325                                strlen(sid->value)+
326                                strlen(wpsStatus[2])+66+1)*sizeof(char));
327  sprintf(sqlQuery,
328          "INSERT INTO %s.services (uuid,sid,osid,fstate)"
329          "VALUES ('%s','%s','%s','%s');",
330          schema->value,
331          uusid->value,
332          sid->value,
333          osid->value,
334          wpsStatus[2]);
335  execSql(conf,zoo_ds_nb-1,sqlQuery);
336  free(sqlQuery);
337  cleanUpResultSet(conf,zoo_ds_nb-1);
338}
339
340/**
341 * Store the content of the result file
342 *
343 * @param conf the maps containing the setting of the main.cfg file
344 * @param filename the file's name
345 */
346void recordResponse(maps* conf,char* filename){
347  int zoo_ds_nb=getCurrentId(conf);
348  FILE *file = fopen (filename, "rb");
349  fseek (file, 0, SEEK_END);
350  long flen = ftell (file);
351  fseek (file, 0, SEEK_SET);
352  char *tmps = (char *) malloc ((flen + 1) * sizeof (char));
353  fread (tmps, flen, 1, file);
354  tmps[flen]=0;
355  fclose(file);
356  map *sid=getMapFromMaps(conf,"lenv","usid");
357  map *schema=getMapFromMaps(conf,"database","schema");
358  char *sqlQuery=(char*)malloc((strlen(schema->value)+flen+strlen(sid->value)+57+1)*sizeof(char));
359  sprintf(sqlQuery,"INSERT INTO %s.responses (content,uuid) VALUES ($$%s$$,$$%s$$);",schema->value,tmps,sid->value);
360  execSql(conf,zoo_ds_nb-1,sqlQuery);
361  free(sqlQuery);
362  free(tmps);
363  cleanUpResultSet(conf,zoo_ds_nb-1);
364}
365
366/**
367 * Update the current status of the running service.
368 *
369 * @param conf the map containing the setting of the main.cfg file
370 * @return 0 on success, -2 if shmget failed, -1 if shmat failed
371 */
372int _updateStatus(maps* conf){
373  int zoo_ds_nb=getCurrentId(conf);
374  map *sid=getMapFromMaps(conf,"lenv","usid");
375  map *p=getMapFromMaps(conf,"lenv","status");
376  map *msg=getMapFromMaps(conf,"lenv","message");
377  map *schema=getMapFromMaps(conf,"database","schema");
378  char *sqlQuery=(char*)malloc((strlen(schema->value)+strlen(msg->value)+strlen(p->value)+strlen(sid->value)+62+1)*sizeof(char));
379  sprintf(sqlQuery,"UPDATE %s.services set status=$$%s$$,message=$$%s$$ where uuid=$$%s$$;",schema->value,p->value,msg->value,sid->value);
380  if( zoo_DS == NULL || zoo_DS[zoo_ds_nb-1]==NULL ){
381    if(getMapFromMaps(conf,"lenv","file.log")==NULL){
382      free(sqlQuery);
383      return 1;
384    }
385    init_sql(conf);
386    zoo_ds_nb++;
387  }
388  execSql(conf,zoo_ds_nb-1,sqlQuery);
389  cleanUpResultSet(conf,zoo_ds_nb-1);
390  free(sqlQuery);
391#ifdef USE_JSON 
392  invokeBasicCallback(conf,SERVICE_STARTED);
393#endif
394  return 0;
395}
396
397/**
398 * Get the ongoing status of a running service
399 *
400 * @param conf the maps containing the setting of the main.cfg file
401 * @param pid the service identifier (usid key from the [lenv] section)
402 * @return the reported status char* (MESSAGE|POURCENTAGE)
403 */
404char* _getStatus(maps* conf,char* pid){
405  int zoo_ds_nb=getCurrentId(conf);
406  int created=-1;
407  map *schema=getMapFromMaps(conf,"database","schema");
408  char *sqlQuery=(char*)malloc((strlen(schema->value)+strlen(pid)+104+1)*sizeof(char)); 
409  sprintf(sqlQuery,"select CASE WHEN message is null THEN '-1' ELSE status||'|'||message END from %s.services where uuid=$$%s$$;",schema->value,pid);
410  if( zoo_ds_nb==
411#ifdef META_DB
412      1
413#else
414      0
415#endif
416      ){
417    init_sql(conf);
418    zoo_ds_nb++;
419    created=1;
420  }
421  execSql(conf,zoo_ds_nb-1,sqlQuery);
422  OGRFeature  *poFeature = NULL;
423  const char *tmp1;
424  while( (poFeature = zoo_ResultSet->GetNextFeature()) != NULL ){
425    for( int iField = 0; iField < poFeature->GetFieldCount(); iField++ ){
426      if( poFeature->IsFieldSet( iField ) ){
427        tmp1=zStrdup(poFeature->GetFieldAsString( iField ));
428      }
429      else
430        tmp1=NULL;
431    }
432    OGRFeature::DestroyFeature( poFeature );
433  }
434  cleanUpResultSet(conf,zoo_ds_nb-1);
435  free(sqlQuery);
436  return (char*)tmp1;
437}
438
439/**
440 * Read the cache file of a running service
441 *
442 * @param conf the maps containing the setting of the main.cfg file
443 * @param pid the service identifier (usid key from the [lenv] section)
444 * @return the reported status char* (temporary/final result)
445 */
446char* _getStatusFile(maps* conf,char* pid){
447  int zoo_ds_nb=getCurrentId(conf);
448  map *schema=getMapFromMaps(conf,"database","schema");
449  OGRFeature  *poFeature = NULL;
450  const char *tmp1=NULL;
451  int hasRes=-1;
452  char *sqlQuery=(char*)malloc((strlen(schema->value)+strlen(pid)+82+1)*sizeof(char));
453  sprintf(sqlQuery,
454          "select content from %s.responses where uuid=$$%s$$"
455          " order by creation_time desc limit 1",schema->value,pid);
456  if( zoo_ds_nb==
457#ifdef META_DB
458      1
459#else
460      0
461#endif
462      ){
463    init_sql(conf);
464    zoo_ds_nb++;
465  }
466  execSql(conf,zoo_ds_nb-1,sqlQuery);
467  if(zoo_ResultSet!=NULL){
468      while( (poFeature = zoo_ResultSet->GetNextFeature()) != NULL ){
469        for( int iField = 0; iField < poFeature->GetFieldCount(); iField++ ){
470          if( poFeature->IsFieldSet( iField ) ){
471            tmp1=zStrdup(poFeature->GetFieldAsString( iField ));
472            hasRes=1;
473          }
474          else
475            tmp1=NULL;
476        }
477        OGRFeature::DestroyFeature( poFeature );
478      }
479  }
480  if(hasRes<0)
481    tmp1=NULL;
482  cleanUpResultSet(conf,zoo_ds_nb-1);
483  free(sqlQuery);
484  return (char*)tmp1;
485}
486
487/**
488 * Delete a service reference from the database.
489 *
490 * @param conf the map containing the setting of the main.cfg file
491 * @param pid the service identifier (usid key from the [lenv] section)
492 */
493void removeService(maps* conf,char* pid){
494  int zoo_ds_nb=getCurrentId(conf);
495  map *schema=getMapFromMaps(conf,"database","schema");
496  char *sqlQuery=(char*)
497    malloc((strlen(pid)+strlen(schema->value)+38+1)
498           *sizeof(char));
499  if( zoo_ds_nb==
500#ifdef META_DB
501      1
502#else
503      0
504#endif
505      ){
506    init_sql(conf);
507    zoo_ds_nb++;
508  }
509  sprintf(sqlQuery,
510          "DELETE FROM %s.services where uuid=$$%s$$;",
511          schema->value,pid);
512  execSql(conf,zoo_ds_nb-1,sqlQuery);
513  cleanUpResultSet(conf,zoo_ds_nb-1);
514  close_sql(conf,zoo_ds_nb-1);
515  free(sqlQuery);
516  end_sql();
517}
518
519/**
520 * Stop handling status repport.
521 *
522 * @param conf the map containing the setting of the main.cfg file
523 */
524void unhandleStatus(maps* conf){
525  int zoo_ds_nb=getCurrentId(conf);
526  map *schema=getMapFromMaps(conf,"database","schema");
527  map *sid=getMapFromMaps(conf,"lenv","usid");
528  map *fstate=getMapFromMaps(conf,"lenv","fstate");
529  char *sqlQuery=(char*)malloc((strlen(sid->value)+
530                                strlen(schema->value)+
531                                (fstate!=NULL?
532                                 strlen(fstate->value):
533                                 6)
534                                +66+1)*sizeof(char));
535  sprintf(sqlQuery,
536          "UPDATE %s.services set end_time=now(), fstate=$$%s$$"
537          " where uuid=$$%s$$;",
538          schema->value,(fstate!=NULL?fstate->value:"Failed"),sid->value);
539  execSql(conf,zoo_ds_nb-1,sqlQuery);
540  cleanUpResultSet(conf,zoo_ds_nb-1);
541  //close_sql(conf,zoo_ds_nb-1);
542  free(sqlQuery);
543  //end_sql();
544}
545
546/**
547 * Read the sid identifier attached of a service if any
548 *
549 * @param conf the maps containing the setting of the main.cfg file
550 * @param pid the service identifier (usid key from the [lenv] section)
551 * @return the sid value
552 */
553char* getStatusId(maps* conf,char* pid){
554  int zoo_ds_nb=getCurrentId(conf);
555  map *schema=getMapFromMaps(conf,"database","schema");
556  char *sqlQuery=(char*)malloc((strlen(schema->value)+strlen(pid)+58+1)*sizeof(char));
557  sprintf(sqlQuery,
558          "select osid from %s.services where uuid=$$%s$$",
559          schema->value,pid);
560  if( zoo_ds_nb==0 ){
561    init_sql(conf);
562    zoo_ds_nb++;
563  }
564  if(execSql(conf,zoo_ds_nb-1,sqlQuery)<0)
565    return NULL;
566  OGRFeature  *poFeature = NULL;
567  char *tmp1;
568  int hasRes=-1;
569  while( (poFeature = zoo_ResultSet->GetNextFeature()) != NULL ){
570    for( int iField = 0; iField < poFeature->GetFieldCount(); iField++ ){
571      if( poFeature->IsFieldSet( iField ) ){
572        tmp1=zStrdup(poFeature->GetFieldAsString( iField ));
573        hasRes=1;
574        break;
575      }
576    }
577    OGRFeature::DestroyFeature( poFeature );
578  }
579  if(hasRes<0)
580    tmp1=NULL;
581  free(sqlQuery);
582  cleanUpResultSet(conf,zoo_ds_nb-1);
583  return (char*)tmp1;
584}
585
586/**
587 * Read the Result file (.res).
588 *
589 * @param conf the maps containing the setting of the main.cfg file
590 * @param pid the service identifier (usid key from the [lenv] section)
591 */
592void readFinalRes(maps* conf,char* pid,map* statusInfo){
593  int zoo_ds_nb=getCurrentId(conf);
594  map *schema=getMapFromMaps(conf,"database","schema");
595  char *sqlQuery=(char*)malloc((strlen(schema->value)+strlen(pid)+58+1)*sizeof(char));
596  sprintf(sqlQuery,
597          "select fstate from %s.services where uuid=$$%s$$",
598          schema->value,pid);
599  if( zoo_DS == NULL )
600    init_sql(conf);
601  execSql(conf,zoo_ds_nb-1,sqlQuery);
602  OGRFeature  *poFeature = NULL;
603  int hasRes=-1;
604  while( (poFeature = zoo_ResultSet->GetNextFeature()) != NULL ){
605    for( int iField = 0; iField < poFeature->GetFieldCount(); iField++ ){
606      if( poFeature->IsFieldSet( iField ) ){
607        addToMap(statusInfo,"Status",poFeature->GetFieldAsString( iField ));
608        hasRes=1;
609        break;
610      }
611    }
612    OGRFeature::DestroyFeature( poFeature );
613  }
614  cleanUpResultSet(conf,zoo_ds_nb-1);
615  if(hasRes<0)
616    addToMap(statusInfo,"Status","Failed");
617  free(sqlQuery);
618  return;
619}
620
621/**
622 * Check if a service is running.
623 *
624 * @param conf the maps containing the setting of the main.cfg file
625 * @param pid the unique service identifier (usid from the lenv section)
626 * @return 1 in case the service is still running, 0 otherwise
627 */
628int isRunning(maps* conf,char* pid){
629  int res=0;
630  int zoo_ds_nb=getCurrentId(conf);
631  map *schema=getMapFromMaps(conf,"database","schema");
632  char *sqlQuery=(char*)malloc((strlen(schema->value)+strlen(pid)+73+1)*sizeof(char));
633  sprintf(sqlQuery,"select count(*) as t from %s.services where uuid=$$%s$$ and end_time is null;",schema->value,pid);
634  if( zoo_ds_nb == 0 ){
635    init_sql(conf);
636    zoo_ds_nb++;
637  }
638  execSql(conf,zoo_ds_nb-1,sqlQuery);
639  OGRFeature  *poFeature = NULL;
640  const char *tmp1;
641  while( (poFeature = zoo_ResultSet->GetNextFeature()) != NULL ){
642    for( int iField = 0; iField < poFeature->GetFieldCount(); iField++ ){
643      if( poFeature->IsFieldSet( iField ) && 
644          atoi(poFeature->GetFieldAsString( iField ))>0 ){
645        res=1;
646        break;
647      }
648    }
649    OGRFeature::DestroyFeature( poFeature );
650  }
651  cleanUpResultSet(conf,zoo_ds_nb-1);
652  free(sqlQuery);
653  return res;
654}
655
656#endif
Note: See TracBrowser for help on using the repository browser.

Search

Context Navigation

ZOO Sponsors

http://www.zoo-project.org/trac/chrome/site/img/geolabs-logo.pnghttp://www.zoo-project.org/trac/chrome/site/img/neogeo-logo.png http://www.zoo-project.org/trac/chrome/site/img/apptech-logo.png http://www.zoo-project.org/trac/chrome/site/img/3liz-logo.png http://www.zoo-project.org/trac/chrome/site/img/gateway-logo.png

Become a sponsor !

Knowledge partners

http://www.zoo-project.org/trac/chrome/site/img/ocu-logo.png http://www.zoo-project.org/trac/chrome/site/img/gucas-logo.png http://www.zoo-project.org/trac/chrome/site/img/polimi-logo.png http://www.zoo-project.org/trac/chrome/site/img/fem-logo.png http://www.zoo-project.org/trac/chrome/site/img/supsi-logo.png http://www.zoo-project.org/trac/chrome/site/img/cumtb-logo.png

Become a knowledge partner

Related links

http://zoo-project.org/img/ogclogo.png http://zoo-project.org/img/osgeologo.png