Changeset 839 for branches/prototype-v0/zoo-project/zoo-kernel

Timestamp:

Aug 7, 2017, 2:56:24 PM (7 years ago)

Author:

djay

Message:

Update the source code for HPC support. Automatically adding nested outputs for the HPC support (should this be available for every support?). Add capability to store the metadata in the Collection DataBase?. Addition of the zcfg2sql to import any existing ZCFG file into the Collection DB. Add the support to invoke a callback (for history purpose) in case a [callback] section contains at least one parameter defined (url). Add support to convert maps and map to JSON (for callback use only by now). Fix some memory leaks (some are still there).

Location:

branches/prototype-v0/zoo-project/zoo-kernel

Files:

• Makefile.in (modified) (4 diffs)
• ZOOMakefile.opts.in (modified) (2 diffs)
• caching.c (modified) (6 diffs)
• configure.ac (modified) (1 diff)
• main_conf_read.y (modified) (2 diffs)
• mimetypes.h (modified) (2 diffs)
• request_parser.c (modified) (9 diffs)
• response_print.c (modified) (19 diffs)
• response_print.h (modified) (2 diffs)
• server_internal.c (modified) (7 diffs)
• service.c (modified) (11 diffs)
• service.h (modified) (5 diffs)
• service_conf.y (modified) (5 diffs)
• service_internal.c (modified) (2 diffs)
• service_internal_hpc.c (modified) (15 diffs)
• service_internal_hpc.h (modified) (2 diffs)
• service_internal_js.c (modified) (1 diff)
• service_internal_ms.c (modified) (27 diffs)
• sql/schema.sql (modified) (2 diffs)
• sql/zoo_collectiondb.sql (added)
• sqlapi.c (modified) (33 diffs)
• sqlapi.h (modified) (2 diffs)
• sshapi.c (modified) (15 diffs)
• sshapi.h (modified) (1 diff)
• ulinet.c (modified) (9 diffs)
• ulinet.h (modified) (2 diffs)
• zoo_service_loader.c (modified) (39 diffs)

branches/prototype-v0/zoo-project/zoo-kernel/Makefile.in

@@ -41 +41 @@
         g++ -fPIC ${CFLAGS} -c sshapi.c
 
+service_json.o: service_json.c
+        g++ -fPIC ${JSON_CFLAGS} ${CFLAGS} -c service_json.c
+
+service_callback.o: service_callback.c
+        g++ -fPIC ${JSON_CFLAGS} ${CFLAGS} -c service_callback.c
+
 request_parser.o: request_parser.c request_parser.h
         g++ -fPIC ${XML2CFLAGS} ${CFLAGS} ${JSCFLAGS} ${JS_ENABLED} -c request_parser.c
@@ -51 +57 @@
 
 response_print.o: response_print.c response_print.h
-        g++ -fPIC ${GDAL_CFLAGS} ${XML2CFLAGS} ${CFLAGS} ${JSCFLAGS} ${JS_ENABLED} -c response_print.c
+        g++ -fPIC ${GDAL_CFLAGS} ${XML2CFLAGS} ${CFLAGS} ${JSCFLAGS} ${JS_ENABLED} ${HPC_ENABLED} -c response_print.c
 
 server_internal.o: server_internal.c server_internal.h service.h mimetypes.h
@@ -76 +82 @@
 
 service_internal_hpc.o: service_internal_hpc.c service_internal_hpc.h service.h
-        g++  ${XML2CFLAGS} ${HPCCFLAGS} ${CFLAGS} -c service_internal_hpc.c
+        g++  ${JSON_CFLAGS} ${XML2CFLAGS} ${HPCCFLAGS} ${CFLAGS} -c service_internal_hpc.c
 
 service_internal_saga.o: service_internal_saga.c service_internal_saga.h service.h
@@ -109 +115 @@
 
 zoo_service_loader.o: zoo_service_loader.c service.h version.h ${MS_FILE} ${PYTHON_FILE} ${PHP_FILE} ${JAVA_FILE} ${JS_FILE} ${PERL_FILE} ${RUBY_FILE} ${YAML_FILE} ${OTB_FILE} ${SAGA_FILE} ${MONO_FILE} ${HPC_FILES} ${METADB_FILE}
-        g++ -g -O2 ${GDAL_CFLAGS} ${XML2CFLAGS} ${CFLAGS} ${MONO_CFLAGS} ${SAGA_CFLAGS} ${OTBCFLAGS} ${PYTHONCFLAGS} ${JAVACFLAGS} ${JSCFLAGS} ${PERLCFLAGS} ${PHPCFLAGS} ${SAGA_ENABLED} ${OTB_ENABLED} ${HPC_ENABLED} ${PYTHON_ENABLED} ${JS_ENABLED} ${PHP_ENABLED} ${PERL_ENABLED} ${JAVA_ENABLED} ${MONO_ENABLED} ${METADB_ENABLED} -c zoo_service_loader.c  -fno-common -DPIC -o zoo_service_loader.o
+        g++ -g -O2 ${JSON_CFLAGS} ${GDAL_CFLAGS} ${XML2CFLAGS} ${CFLAGS} ${MONO_CFLAGS} ${SAGA_CFLAGS} ${OTBCFLAGS} ${PYTHONCFLAGS} ${JAVACFLAGS} ${JSCFLAGS} ${PERLCFLAGS} ${PHPCFLAGS} ${SAGA_ENABLED} ${OTB_ENABLED} ${HPC_ENABLED} ${PYTHON_ENABLED} ${JS_ENABLED} ${PHP_ENABLED} ${PERL_ENABLED} ${JAVA_ENABLED} ${MONO_ENABLED} ${METADB_ENABLED} -c zoo_service_loader.c  -fno-common -DPIC -o zoo_service_loader.o
 
 libzoo_service.${EXT}: version.h service_internal.o service.o sqlapi.o
-        gcc -shared  ${GDAL_CFLAGS} ${DEFAULT_OPTS} -fpic -o libzoo_service.${EXT} ${CFLAGS}  service_internal.o service.o sqlapi.o ${FCGI_LDFLAGS} ${GDAL_LIBS}
+        gcc -shared  ${GDAL_CFLAGS} ${DEFAULT_OPTS} -fpic -o libzoo_service.${EXT} ${CFLAGS}  service_internal.o service.o sqlapi.o ${FCGI_LDFLAGS} ${GDAL_LIBS} ${ZOO_LDFLAGS}
 
-zoo_loader.cgi: version.h libzoo_service.${EXT} zoo_loader.c zoo_service_loader.o  ulinet.o service.h lex.sr.o service_conf.tab.o service_conf.y ulinet.o main_conf_read.tab.o lex.cr.o request_parser.o response_print.o server_internal.o caching.o ${MS_FILE} ${PYTHON_FILE} ${PHP_FILE} ${JAVA_FILE} ${JS_FILE} ${PERL_FILE} ${RUBY_FILE} ${YAML_FILE} ${OTB_FILE} ${SAGA_FILE} ${HPC_FILES} ${METADB_FILE}
-        g++ -g -O2 ${JSCFLAGS} ${PHPCFLAGS}  ${PERLCFLAGS} ${RUBYCFLAGS}  ${JAVACFLAGS} ${XML2CFLAGS} ${PYTHONCFLAGS} ${CFLAGS} -c zoo_loader.c  -fno-common -DPIC -o zoo_loader.o
-        g++  ${JSCFLAGS} ${SAGA_CFLAGS} ${OTBCFLAGS} ${GDAL_CFLAGS} ${XML2CFLAGS} ${PHPCFLAGS} ${PERLCFLAGS} ${JAVACFLAGS} ${PYTHONCFLAGS} ${CFLAGS} zoo_loader.o zoo_service_loader.o ${MS_FILE} ${PYTHON_FILE}  ${PERL_FILE} ${PHP_FILE}  ${JS_FILE} ${JAVA_FILE} ${YAML_FILE} ${OTB_FILE} ${SAGA_FILE} ${MONO_FILE} ${HPC_FILES} ${METADB_FILE} response_print.o server_internal.o caching.o request_parser.o ulinet.o lex.cr.o lex.sr.o service_conf.tab.o main_conf_read.tab.o -o zoo_loader.cgi -L. ${LDFLAGS}
+zoo_loader.cgi: version.h libzoo_service.${EXT} zoo_loader.c zoo_service_loader.o  ulinet.o service.h lex.sr.o service_conf.tab.o service_conf.y ulinet.o main_conf_read.tab.o lex.cr.o request_parser.o response_print.o server_internal.o caching.o ${MS_FILE} ${PYTHON_FILE} ${PHP_FILE} ${JAVA_FILE} ${JS_FILE} ${PERL_FILE} ${RUBY_FILE} ${YAML_FILE} ${OTB_FILE} ${SAGA_FILE} ${HPC_FILES} ${METADB_FILE} ${JSON_FILE} service_callback.o
+        g++ -g -O2 ${JSON_CFLAGS} ${JSCFLAGS} ${PHPCFLAGS}  ${PERLCFLAGS} ${RUBYCFLAGS}  ${JAVACFLAGS} ${XML2CFLAGS} ${PYTHONCFLAGS} ${CFLAGS} -c zoo_loader.c  -fno-common -DPIC -o zoo_loader.o
+        g++  ${JSON_CFLAGS} ${JSCFLAGS} ${SAGA_CFLAGS} ${OTBCFLAGS} ${GDAL_CFLAGS} ${XML2CFLAGS} ${PHPCFLAGS} ${PERLCFLAGS} ${JAVACFLAGS} ${PYTHONCFLAGS} ${CFLAGS} zoo_loader.o zoo_service_loader.o ${MS_FILE} ${PYTHON_FILE}  ${PERL_FILE} ${PHP_FILE}  ${JS_FILE} ${JAVA_FILE} ${YAML_FILE} ${OTB_FILE} ${SAGA_FILE} ${MONO_FILE} ${HPC_FILES} ${METADB_FILE} ${JSON_FILE} service_callback.o response_print.o server_internal.o caching.o request_parser.o ulinet.o lex.cr.o lex.sr.o service_conf.tab.o main_conf_read.tab.o -o zoo_loader.cgi -L. ${LDFLAGS}
 
 zcfg2yaml: zcfg2yaml.c service.h lex.sr.o service_conf.tab.o service_conf.y main_conf_read.tab.o lex.cr.o response_print.o server_internal.o service_internal.o ${MS_FILE} ${YAML_FILE}

branches/prototype-v0/zoo-project/zoo-kernel/ZOOMakefile.opts.in

@@ -29 +29 @@
 YAML_FILE=@YAML_FILE@
 YAML_FILE1=@YAML_FILE1@
+
+JSON_CFLAGS=@JSON_CPPFLAGS@
+JSON_LDFLAGS=@JSON_LDFLAGS@
+JSON_FILE=@JSON_FILE@
 
 METADB_ENABLED=@METADB@
@@ -111 +115 @@
 
 CFLAGS=@SSH2_CPPFLAGS@ @GETTEXT_CFLAGS@ @PROJ_CPPFLAGS@ @RELY_ON_DB@ @DEB_DEF@ -fpic @OPENSSL_CFLAGS@ @UUID_CFLAGS@ ${FCGI_CFLAGS} ${YAML_CFLAGS} ${MACOS_CFLAGS} ${MS_CFLAGS} -I../../thirds/cgic206 -I. -DLINUX_FREE_ISSUE #-DDEBUG #-DDEBUG_SERVICE_CONF
-LDFLAGS=-lzoo_service @SSH2_LDFLAGS@ @PROJ_LDFLAGS@ @DEFAULT_LIBS@ -L../../thirds/cgic206 -lcgic ${GDAL_LIBS} ${XML2LDFLAGS} ${PYTHONLDFLAGS} ${PERLLDFLAGS}  ${PHPLDFLAGS} ${JAVALDFLAGS} ${JSLDFLAGS}  ${FCGI_LDFLAGS} @OPENSSL_LDFLAGS@ @UUID_LDFLAGS@ ${MS_LDFLAGS} ${MACOS_LD_FLAGS} ${MACOS_LD_NET_FLAGS} ${YAML_LDFLAGS} ${OTBLDFLAGS} ${SAGA_LDFLAGS} ${MONO_LDFLAGS} @GETTEXT_LDFLAGS@
+LDFLAGS=-lzoo_service @SSH2_LDFLAGS@ @PROJ_LDFLAGS@ @DEFAULT_LIBS@ -L../../thirds/cgic206 -lcgic ${GDAL_LIBS} ${XML2LDFLAGS} ${PYTHONLDFLAGS} ${PERLLDFLAGS}  ${PHPLDFLAGS} ${JAVALDFLAGS} ${JSLDFLAGS}  ${FCGI_LDFLAGS} @OPENSSL_LDFLAGS@ @UUID_LDFLAGS@ ${MS_LDFLAGS} ${MACOS_LD_FLAGS} ${MACOS_LD_NET_FLAGS} ${YAML_LDFLAGS} ${OTBLDFLAGS} ${SAGA_LDFLAGS} ${MONO_LDFLAGS} @GETTEXT_LDFLAGS@ @JSON_LDFLAGS@
 
 DATAROOTDIR=@datarootdir@/zoo-project

branches/prototype-v0/zoo-project/zoo-kernel/caching.c

@@ -158 +158 @@
  */
 int readCurrentInput(maps** m,maps** in,int* index,HINTERNET* hInternet,map** error){
+  
   map* tmp1;
   char sindex[5];
@@ -212 +213 @@
     sprintf(sindex,"%d",*index+1);
     if((tmp1=getMap(content->content,xname))!=NULL && tmap!=NULL && strcasecmp(tmap->value,sindex)==0){
-      
-      if(getMap(content->content,icname)==NULL){
+
+      if(getMap(content->content,icname)==NULL){        
         fcontent=(char*)malloc((hInternet->ihandle[*index].nDataLen+1)*sizeof(char));
         if(fcontent == NULL){
@@ -266 +267 @@
           char* md5str=NULL;
           if((tmp2=getMap(content->content,bname))!=NULL){
-            dumpMap(tmp2);
             char *tmpStr=(char*)malloc((strlen(tmp1->value)+strlen(tmp2->value)+1)*sizeof(char));
             sprintf(tmpStr,"%s%s",tmp1->value,tmp2->value);
             if((tmp2=getMap(content->content,"headers"))!=NULL){
               char *tmpStr2=zStrdup(tmpStr);
+              free(tmpStr);
               tmpStr=(char*)malloc((strlen(tmpStr2)+strlen(tmp2->value)+1)*sizeof(char));
               sprintf(tmpStr,"%s%s",tmpStr2,tmp2->value);
@@ -293 +294 @@
         free(mimeType);
         free(request);
-        *index++;
-        
+        (*index)++;
       }
     }
@@ -361 +361 @@
     free(oreq);
   }else{
-    setMapArray(oreq->content,"value",hInternet->nb-1,url);
+    setMapArray(oreq->content,"value",hInternet->nb,url);
   }
 }
@@ -444 +444 @@
       addToMap(*content,"cache_file",fname);
       free(fname);
+      free(md5str);
     }
   }

branches/prototype-v0/zoo-project/zoo-kernel/configure.ac

@@ -60 +60 @@
 AC_SUBST([UUID_CFLAGS])
 AC_SUBST([UUID_LDFLAGS])
+
+#============================================================================
+# Detect if json-c is available
+#============================================================================
+
+AC_ARG_WITH([json],
+    [AS_HELP_STRING([--with-json=PATH], [Specifies an alternative location for the json-c library])],
+    [JSON_DIR="$withval"], [JSON_DIR="/usr/"])
+JSON_CPPFLAGS="-I$JSON_DIR/include/json-c/"
+JSON_LDFLAGS="-L$JSON_DIR/lib -ljson-c"
+CPPFLAGS_SAVE="$CPPFLAGS"
+CPPFLAGS="$JSON_CPPFLAGS"
+LIBS_SAVE="$LIBS"
+LIBS="$JSON_LDFLAGS"
+echo $CPPFLAGS
+AC_CHECK_HEADERS([json_object.h],
+                        [], [AC_MSG_ERROR([could not find header file json_object.h])])
+AC_CHECK_LIB([json-c], [json_object_new_object],
+                        [], [AC_MSG_ERROR([could not find function in json-c library])])
+CPPFLAGS="$CPPFLAGS_SAVE"
+JSON_FILE="service_json.o"
+JSON_ENABLED="-DJSON"
+AC_SUBST([JSON_CPPFLAGS])
+AC_SUBST([JSON_LDFLAGS])
+AC_SUBST([JSON_FILE])
+AC_SUBST([JSON_ENABLED])
 
 #============================================================================

branches/prototype-v0/zoo-project/zoo-kernel/main_conf_read.y

@@ -99 +99 @@
   }
   free(curr_key);
+  curr_key=NULL;
   }
 | SPAIR  {curr_key=zStrdup($1);if(debug) printf("SPAIR FOUND !!\n"); }
@@ -162 +163 @@
     free(current_content);
   }
+  if(curr_key!=NULL){
+    free(curr_key);
+  }
 
   fclose(crin);

branches/prototype-v0/zoo-project/zoo-kernel/mimetypes.h

@@ -180 +180 @@
         { "application/vnd.dece.unspecified", "uvx" },
         { "application/vnd.dece.zip", "uvz" },
-        { "application/vnd.denovo.fcselayout-link", "fe_launch" },
+        { "application/vnd.denovo.fcselayout-link", "fe_launch" },      
         { "application/vnd.dna", "dna" },
         { "application/vnd.dolby.mlp", "mlp" },
@@ -836 +836 @@
         return ext;
 }
+
+static int isGeographic(const char* mimeType){
+  char* imageMimeType[4]={
+    "image/tiff",
+    "image/png",
+    "image/jpeg",
+    "application/vnd.google-earth.kmz"
+  };
+  char* vectorMimeType[5]={
+    "text/xml",
+    "application/json",
+    "application/gml+xml",
+    "application/zip",
+    "application/vnd.google-earth.kml+xml"
+  };
+  int i=0;
+  for(;i<4;i++){
+    if(strncmp(imageMimeType[i],mimeType,strlen(imageMimeType[i]))==0)
+      return 1;
+  }
+  i=0;
+  for(;i<5;i++){
+    if(strncmp(vectorMimeType[i],mimeType,strlen(vectorMimeType[i]))==0)
+      return 2;
+  }
+  return -1;
+}

branches/prototype-v0/zoo-project/zoo-kernel/request_parser.c

@@ -533 +533 @@
             xmlChar *val = xmlGetProp (cur, BAD_CAST "id");
             tmpmaps = createMaps((char *) val);
+            xmlFree(val);
           }
 
@@ -624 +625 @@
                             tmpmaps->content =
                               createMap (refs[l], (char *) val);
-
                           map *ltmp = getMap (tmpmaps->content, "method");
                           if (l == 4 )
@@ -750 +750 @@
                                       map *btmp =
                                         getMap (tmpmaps->content, "Reference");
+                                      addToMap (tmpmaps->content, "Body", tmp);
                                       if (btmp != NULL)
                                         {
@@ -815 +816 @@
                                                   &bRead);
                                 tmp[bInternet.ihandle[0].nDataLen] = 0;
-                                InternetCloseHandle (&bInternet);
+                                InternetCloseHandle(&bInternet);
+                                addToMap (tmpmaps->content, "Body", tmp);
                                 map *btmp =
                                   getMap (tmpmaps->content, "href");
@@ -832 +834 @@
                                   }
                                 free (tmp);
+                                xmlFree (val);
                               }
                         }
@@ -1120 +1123 @@
       const char ress[4][13] =
         { "mimeType", "encoding", "schema", "transmission" };
+      xmlFree (val);
       for (l = 0; l < 4; l++){
         val = xmlGetProp (cur, BAD_CAST ress[l]);
@@ -1139 +1143 @@
         while (ccur != NULL){
           if(ccur->type == XML_ELEMENT_NODE){
-            char *xpathExpr=(char*)malloc(65+strlen(tmpmaps->name));
-            sprintf(xpathExpr,"/*/*[local-name()='Output' and @id='%s']/*[local-name()='Output']",tmpmaps->name);
+            char *xpathExpr=(char*)malloc(66+strlen(tmpmaps->name));
+            sprintf(xpathExpr,"/*/*[local-name()='Output' and @id='%s']/*[local-name()='Output']",tmpmaps->name);           
             xmlXPathObjectPtr tmpsptr = extractFromDoc (doc, xpathExpr);
             xmlNodeSet* cnodes = tmpsptr->nodesetval;
             xmlParseOutputs2(main_conf,request_inputs,&tmpmaps->child,doc,cnodes);
+            xmlXPathFreeObject (tmpsptr);
+            free(xpathExpr);
             break;
           }
@@ -1424 +1430 @@
           else
             addToMap(*request_inputs,"mode","auto");
+          xmlFree(val);
           val = xmlGetProp (cur, BAD_CAST "response");
           if(val!=NULL){
@@ -1436 +1443 @@
             addToMap(*request_inputs,"ResponseDocument","");
           }
+          xmlFree(val);
         }
       }

branches/prototype-v0/zoo-project/zoo-kernel/response_print.c

@@ -23 +23 @@
  */
 
+#include "service.h"
 #include "response_print.h"
 #include "request_parser.h"
@@ -644 +645 @@
  * @return the generated wps:ProcessOfferings xmlNodePtr 
  */
-void printGetCapabilitiesForProcess(registry *reg, maps* m,xmlNodePtr nc,service* serv){
+void printGetCapabilitiesForProcess(registry *reg, maps* m,xmlDocPtr doc,xmlNodePtr nc,service* serv){
   xmlNsPtr ns,ns_ows,ns_xml,ns_xlink;
   xmlNodePtr n=NULL,nc1,nc2,nc3;
@@ -692 +693 @@
     tmp1=serv->metadata;
 
-    addMetadata(tmp1,nc1,ns_ows,ns_xlink);
-
-    /*while(tmp1!=NULL){
-      nc2 = xmlNewNode(ns_ows, BAD_CAST "Metadata");
-      if(strcmp(tmp1->name,"title")==0 ||
-         strcmp(tmp1->name,"href")==0 ||
-         strcmp(tmp1->name,"role")==0 ||
-         strcmp(tmp1->name,"link_type")==0){
-        xmlNewNsProp(nc2,ns_xlink,BAD_CAST tmp1->name,BAD_CAST tmp1->value);
-        xmlAddChild(nc1,nc2);
-      }else{
-        if(nc3==NULL)
-          nc3 = xmlNewNode(ns_ows, BAD_CAST "AdditionalParameter");
-        xmlNodePtr nc4 = xmlNewNode(ns_ows, BAD_CAST "Name");
-        xmlAddChild(nc4,xmlNewText(BAD_CAST tmp1->name));
-        xmlNodePtr nc5 = xmlNewNode(ns_ows, BAD_CAST "Value");
-        xmlAddChild(nc5,xmlNewText(BAD_CAST tmp1->value));
-        xmlAddChild(nc3,nc4);
-        xmlAddChild(nc3,nc5);
-      }
-      tmp1=tmp1->next;
-      }*/
+    addMetadata(tmp1,doc,nc1,ns_ows,ns_xlink);
+    tmp1=serv->additional_parameters;
+    int fromDb=-1;
+    map* test=getMap(serv->content,"fromDb");
+    if(test!=NULL && strncasecmp(test->value,"true",4)==0)
+      fromDb=1;
+    addAdditionalParameters(tmp1,doc,nc1,ns_ows,ns_xlink,fromDb);
+
     if(nc3!=NULL)
       xmlAddChild(nc1,nc3);
@@ -756 +743 @@
 }
 
-int addMetadata(map* meta,xmlNodePtr nc,xmlNsPtr ns_ows,xmlNsPtr ns_xlink){
+int addMetadata(map* meta,xmlDocPtr doc,xmlNodePtr nc,xmlNsPtr ns_ows,xmlNsPtr ns_xlink){
     int hasTitle=-1;
     int hasValue=-1;
@@ -830 +817 @@
 }
 
+
+int addAdditionalParameters(map* meta,xmlDocPtr doc,xmlNodePtr nc,xmlNsPtr ns_ows,xmlNsPtr ns_xlink,int fromDb){
+    int hasTitle=-1;
+    int hasValue=-1;
+    xmlNodePtr nc1;
+    map* oMeta=meta;
+    int isAdditionalParameters=-1;
+    //if(count(oMeta)>=2){
+    int level=0;
+    map* test=getMap(meta,"title");
+    if(test!=NULL)
+      level+=1;
+    test=getMap(meta,"href");
+    if(test!=NULL)
+      level+=1;
+    test=getMap(meta,"role");
+    if(test!=NULL)
+      level+=1;
+    if(count(oMeta)>level+1)
+      isAdditionalParameters=1;
+    //}
+    char *ctitle=NULL;
+    while(meta!=NULL){
+      if(hasTitle<0)
+        if(hasValue<0)
+          nc1 = xmlNewNode(ns_ows, BAD_CAST "AdditionalParameters");
+      if(strncasecmp(meta->name,"title",5)==0 ||
+         strcasecmp(meta->name,"href")==0 ||
+         strcasecmp(meta->name,"role")==0 ){
+        int index=5;
+        if(strncasecmp(meta->name,"title",5)==0){
+          index=6;
+          hasTitle=1;
+          if(ctitle!=NULL && strcasecmp(meta->value,ctitle)!=0){
+              xmlAddChild(nc,nc1);
+              nc1 = xmlNewNode(ns_ows, BAD_CAST "AdditionalParameters");
+              free(ctitle);
+              ctitle=NULL;
+          }
+          if(ctitle==NULL){
+            char *tmp=(char*)malloc((strlen(meta->name)+1)*sizeof(char));
+            snprintf(tmp,index,"%s",meta->name);
+            xmlNewNsProp(nc1,ns_xlink,BAD_CAST tmp,BAD_CAST meta->value);
+            free(tmp);
+          }       
+          if(ctitle!=NULL)
+            free(ctitle);
+          ctitle=zStrdup(meta->value);
+        }
+      }else{
+        xmlNodePtr nc2 = xmlNewNode(ns_ows, BAD_CAST "AdditionalParameter");
+        xmlNodePtr nc3 = xmlNewNode(ns_ows, BAD_CAST "Name");
+        xmlAddChild(nc3,xmlNewText(BAD_CAST meta->name));
+        xmlAddChild(nc2,nc3);
+        if(fromDb<0){
+          char *mptr;
+          char* meta_values=strtok_r(meta->value,",",&mptr);
+          while(meta_values!=NULL){
+            xmlNodePtr nc4 = xmlNewNode(ns_ows, BAD_CAST "Value");
+            xmlAddChild(nc4,xmlNewText(BAD_CAST meta_values));
+            xmlAddChild(nc2,nc4);
+            meta_values=strtok_r(NULL,",",&mptr);
+          }
+        }else{
+          xmlNodePtr nc4 = xmlNewNode(ns_ows, BAD_CAST "Value");
+          xmlAddChild(nc4,xmlNewCDataBlock(doc,BAD_CAST meta->value,strlen(meta->value)));
+          xmlAddChild(nc2,nc4);
+        }
+        xmlAddChild(nc1,nc2);
+        hasTitle=-1;
+      }
+      meta=meta->next;
+      if(hasTitle<0){
+        xmlAddChild(nc,nc1);
+        hasValue=1;
+      }
+    }
+    if(oMeta!=NULL && hasValue<0 && nc1!=NULL){
+      xmlAddChild(nc,nc1);
+    }
+}
+
 /**
  * Add the ows:Metadata nodes relative to the profile registry
@@ -886 +955 @@
  * @return the generated wps:ProcessOfferings xmlNodePtr 
  */
-void printDescribeProcessForProcess(registry *reg, maps* m,xmlNodePtr nc,service* serv){
+void printDescribeProcessForProcess(registry *reg, maps* m,xmlDocPtr doc,xmlNodePtr nc,service* serv){
   xmlNsPtr ns,ns_ows,ns_xlink;
   xmlNodePtr n,nc1;
@@ -892 +961 @@
   map* version=getMapFromMaps(m,"main","rversion");
   int vid=getVersionId(version->value);
+  int fromDb=-1;
+  map* serviceType=getMap(serv->content,"serviceType");
+  map* test=getMap(serv->content,"fromDb");
+  if(test!=NULL && strncasecmp(test->value,"true",4)==0)
+    fromDb=1;
 
   n=nc;
@@ -937 +1011 @@
     tmp1=serv->metadata;
     while(tmp1!=NULL){
-      addMetadata(tmp1,nc,ns_ows,ns_xlink);
+      addMetadata(tmp1,doc,nc,ns_ows,ns_xlink);
       /*nc1 = xmlNewNode(ns_ows, BAD_CAST "Metadata");
       xmlNewNsProp(nc1,ns_xlink,BAD_CAST tmp1->name,BAD_CAST tmp1->value);
@@ -951 +1025 @@
   }else{
     tmp1=serv->metadata;
-    addMetadata(tmp1,nc,ns_ows,ns_xlink);
+    addMetadata(tmp1,doc,nc,ns_ows,ns_xlink);
     addInheritedMetadata(nc,ns_ows,ns_xlink,reg,m,serv);
+    tmp1=serv->additional_parameters;
+    addAdditionalParameters(tmp1,doc,nc,ns_ows,ns_xlink,fromDb);
   }
 
@@ -959 +1035 @@
     if(vid==0){
       nc1 = xmlNewNode(NULL, BAD_CAST "DataInputs");
-      printFullDescription(1,e,"Input",ns,ns_ows,nc1,vid);
+      printFullDescription(doc,1,e,"Input",ns,ns_ows,nc1,vid,fromDb,NULL);
       xmlAddChild(nc,nc1);
     }
     else{
-      printFullDescription(1,e,"wps:Input",ns,ns_ows,nc,vid);
+      printFullDescription(doc,1,e,"wps:Input",ns,ns_ows,nc,vid,fromDb,NULL);
     }
   }
@@ -970 +1046 @@
   if(vid==0){
     nc1 = xmlNewNode(NULL, BAD_CAST "ProcessOutputs");
-    printFullDescription(0,e,"Output",ns,ns_ows,nc1,vid);
+    printFullDescription(doc,0,e,"Output",ns,ns_ows,nc1,vid,fromDb,NULL);
     xmlAddChild(nc,nc1);
   }
   else{
-    printFullDescription(0,e,"wps:Output",ns,ns_ows,nc,vid);
+    printFullDescription(doc,0,e,"wps:Output",ns,ns_ows,nc,vid,fromDb,serviceType);
   }
   if(vid==0)
@@ -996 +1072 @@
  * @param nc1 the XML node to use to add the created tree
  * @param vid the WPS version id (0 for 1.0.0, 1 for 2.0.0)
- */
-void printFullDescription(int in,elements *elem,const char* type,xmlNsPtr ns,xmlNsPtr ns_ows,xmlNodePtr nc1,int vid){
+ * @param fromDb 1 in case the metadata comes from the DB, -1 in other cases
+ * @param serviceType the serviceType found in the ZCFG file or the DB
+ */
+void printFullDescription(xmlDocPtr doc,int in,elements *elem,const char* type,xmlNsPtr ns,xmlNsPtr ns_ows,xmlNodePtr nc1,int vid,int fromDb,const map* serviceType){
   xmlNsPtr ns1=NULL;
   if(vid==1)
@@ -1032 +1110 @@
 
     if(e->format!=NULL){
+#ifdef USE_HPC      
+    DEFAULT_OUT:
+#endif
       const char orderedFields[13][14]={
         "mimeType",
@@ -1138 +1219 @@
               char *tmps=strdup(token);
               tmps[strlen(tmps)]=0;
-              xmlAddChild(nc7,xmlNewText(BAD_CAST tmps));
+              nc8 = xmlNewText(BAD_CAST tmps);
+              xmlAddChild(nc7,nc8);
               free(tmps);
               xmlAddChild(nc6,nc7);
@@ -1437 +1519 @@
         xmlNsPtr ns_xlink=usedNs[xlinkId];
 
-        dumpMap(metadata);
-        addMetadata(metadata,nc2,ns_ows,ns_xlink);
+        //dumpMap(metadata);
+        addMetadata(metadata,doc,nc2,ns_ows,ns_xlink);
+        addAdditionalParameters(e->additional_parameters,doc,nc2,ns_ows,ns_xlink,fromDb);
 
       }
@@ -1583 +1666 @@
       xmlAddChild(nc2,nc3);
     }else{
-      if(e->child!=NULL && vid!=0){
-        printFullDescription(in,e->child,type,ns,ns_ows,nc2,vid);
-      }
-    }
-    
+      if(e->child!=NULL){
+        if(e->child!=NULL && vid!=0){
+          printFullDescription(doc,in,e->child,type,ns,ns_ows,nc2,vid,fromDb,NULL);
+        }
+      }
+    }
     if(e->child!=NULL && vid==0){
       elements* children=dupElements(e->child);
@@ -1598 +1682 @@
         cursor=cursor->next;
       }
-      printFullDescription(in,children,type,ns,ns_ows,nc2,vid);
+      printFullDescription(doc,in,children,type,ns,ns_ows,nc2,vid,fromDb,serviceType);
       xmlAddChild(nc1,nc2);
       freeElements(&children);
@@ -1604 +1688 @@
     }else
       xmlAddChild(nc1,nc2);
-    
     e=e->next;
   }
@@ -2588 +2671 @@
       toto=getMap(tmpI->content,"asReference");
 #ifdef USE_MS
-      if(toto!=NULL && strcasecmp(toto->value,"true")==0 && testMap==NULL)
+      if(toto!=NULL && strcasecmp(toto->value,"true")==0 && (testMap==NULL || strncasecmp(testMap->value,"true",4)!=0) )
 #else
       if(toto!=NULL && strcasecmp(toto->value,"true")==0)

branches/prototype-v0/zoo-project/zoo-kernel/response_print.h

@@ -209 +209 @@
   xmlNodePtr printWPSHeader(xmlDocPtr,maps*,const char*,const char*,const char*,int);
   xmlNodePtr printGetCapabilitiesHeader(xmlDocPtr,maps*,const char*);
-  void printGetCapabilitiesForProcess(registry*,maps*,xmlNodePtr,service*);
-  void printDescribeProcessForProcess(registry*,maps*,xmlNodePtr,service*);
-  void printFullDescription(int,elements*,const char*,xmlNsPtr,xmlNsPtr,xmlNodePtr,int);
+  void printGetCapabilitiesForProcess(registry*,maps*,xmlDocPtr,xmlNodePtr,service*);
+  void printDescribeProcessForProcess(registry*,maps*,xmlDocPtr,xmlNodePtr,service*);
+  void printFullDescription(xmlDocPtr,int,elements*,const char*,xmlNsPtr,xmlNsPtr,xmlNodePtr,int,int,const map*);
   void printDocument(maps*,xmlDocPtr,int);
   void printDescription(xmlNodePtr,xmlNsPtr,const char*,map*,int);
@@ -220 +220 @@
   void printOutputDefinitions(xmlDocPtr,xmlNodePtr,xmlNsPtr,xmlNsPtr,elements*,maps*,const char*);
   void printStatusInfo(maps*,map*,char*);
-  int addMetadata(map* meta,xmlNodePtr nc,xmlNsPtr ns_ows,xmlNsPtr ns_xlink);
+  int addAdditionalParameters(map*,xmlDocPtr,xmlNodePtr,xmlNsPtr,xmlNsPtr,int);
+  int addMetadata(map*,xmlDocPtr,xmlNodePtr,xmlNsPtr,xmlNsPtr);
 
   void outputResponse(service*,maps*,maps*,map*,int,maps*,int);

branches/prototype-v0/zoo-project/zoo-kernel/server_internal.c

@@ -597 +597 @@
           setMapArray(res,"value",nb,out1->name);
         }
-
         nb++;
         result=out1->name;
@@ -806 +805 @@
          */
         if(tmpIoType!=NULL){
-          map* tmpCheck=getMap(tmpIoType->content,"useMapServer");
-          if(tmpCheck!=NULL){
+          map* tmpCheck=getMap(tmpIoType->content,"useMapserver");
+          if(tmpCheck!=NULL && strncasecmp(tmpCheck->value,"true",4)==0){
             // Get the default value
             tmpIoType=getIoTypeFromElement(tmpInputs,tmpInputs->name,NULL);
@@ -841 +840 @@
       }
     }
-    /*if(tmpInputs->child!=NULL){
+    if(tmpInputs->child!=NULL){
       tmpInputss=tmpInputs->next;
       tmpInputs=tmpInputs->child;
@@ -848 +847 @@
         out1s=tmpMaps;
       }
-      }else*/
-      tmpInputs=tmpInputs->next;
+    }
+    tmpInputs=tmpInputs->next;
   }
   if(tmpInputss!=NULL){
@@ -980 +979 @@
     if(isRunning(conf,pid)>0){
       if(strncasecmp(req,"GetResult",strlen(req))==0){
-        errorException (conf, _("The result for the requested JobID has not yet been generated. "),
+        errorException (conf, _("The result for the requested JobID has not yet been generated. (1)"),
                         "ResultNotReady", pid);
         return;
@@ -1012 +1011 @@
           return;
         }else{
-          errorException (conf, _("The result for the requested JobID has not yet been generated. "),
+          errorException (conf, _("The result for the requested JobID has not yet been generated. (2)"),
                           "ResultNotReady", pid);
           freeMap(&statusInfo);
@@ -1034 +1033 @@
         }
     }
+    free(sid);
     printStatusInfo(conf,statusInfo,req);
     freeMap(&statusInfo);

branches/prototype-v0/zoo-project/zoo-kernel/service.c

@@ -146 +146 @@
 
 /**
+ * Create a new iotype*
+ *
+ * @return a pointer to the allocated iotype 
+ */
+iotype* createIoType(){
+  iotype* io=(iotype*)malloc(IOTYPE_SIZE);
+  io->content=NULL;
+  io->next=NULL;
+  return io;
+}
+
+/**
  * Create a new map
  *
@@ -400 +412 @@
     if(tmp->metadata!=NULL)
       free(tmp->metadata);
+    freeMap(&tmp->additional_parameters);
+    if(tmp->additional_parameters!=NULL)
+      free(tmp->additional_parameters);
     if(tmp->format!=NULL)
       free(tmp->format);
@@ -831 +846 @@
     }
   }
-  else
+  else{
     sprintf(tmp,"%s",key);
+    addToMap(m,"length","1");
+  }
   map* tmpSize=getMapArray(m,"size",index);
   if(tmpSize!=NULL && strncasecmp(key,"value",5)==0){
@@ -964 +981 @@
   res->content=NULL;
   res->metadata=NULL;
+  res->additional_parameters=NULL;  
   res->format=NULL;
   res->defaults=NULL;
@@ -983 +1001 @@
   res->content=NULL;
   res->metadata=NULL;
+  res->additional_parameters=NULL;
   res->format=NULL;
   res->defaults=NULL;
@@ -1022 +1041 @@
     fprintf(stderr," > METADATA [%s]\n",tmp->name);
     dumpMap(tmp->metadata);
+    fprintf(stderr," > ADDITIONAL PARAMETERS [%s]\n",tmp->name);
+    dumpMap(tmp->additional_parameters);
     fprintf(stderr," > FORMAT [%s]\n",tmp->format);
     iotype* tmpio=tmp->defaults;
@@ -1139 +1160 @@
   elements* cursor=e;
   elements* tmp=NULL;
-  if(cursor!=NULL){
+  if(cursor!=NULL && e->name!=NULL){
 #ifdef DEBUG
     fprintf(stderr,">> %s %i\n",__FILE__,__LINE__);
@@ -1151 +1172 @@
     tmp->metadata=NULL;
     addMapToMap(&tmp->metadata,e->metadata);
+    tmp->additional_parameters=NULL;
+    addMapToMap(&tmp->additional_parameters,e->additional_parameters);
     if(e->format!=NULL)
       tmp->format=zStrdup(e->format);
@@ -1187 +1210 @@
     else
       tmp->child=NULL;
-    tmp->next=dupElements(cursor->next);
+    if(cursor->next!=NULL)
+      tmp->next=dupElements(cursor->next);
+    else
+      tmp->next=NULL;
   }
   return tmp;
@@ -1234 +1260 @@
     fprintf(stderr,"CONTENT MAP\n");
     dumpMap(s->content);
-    fprintf(stderr,"CONTENT METADATA\n");
+    if(s->metadata!=NULL)
+      fprintf(stderr,"CONTENT METADATA\n");
     dumpMap(s->metadata);
+    if(s->additional_parameters!=NULL)
+      fprintf(stderr,"CONTENT AdditionalParameters\n");
+    dumpMap(s->additional_parameters);
   }
   if(s->inputs!=NULL){
@@ -1293 +1323 @@
   res->metadata=NULL;
   addMapToMap(&res->metadata,s->metadata);
+  res->additional_parameters=NULL;
+  addMapToMap(&res->additional_parameters,s->additional_parameters);
   res->inputs=dupElements(s->inputs);
   res->outputs=dupElements(s->outputs);

branches/prototype-v0/zoo-project/zoo-kernel/service.h

@@ -139 +139 @@
  * The memory size to create an elements
  */
-#define ELEMENTS_SIZE (sizeof(char*)+(((2*sizeof(char*))+sizeof(maps*))*2)+sizeof(char*)+(((2*sizeof(char*))+sizeof(iotype*))*2)+(2*sizeof(elements*)))
+#define ELEMENTS_SIZE (sizeof(char*)+(((2*sizeof(char*))+sizeof(maps*))*3)+sizeof(char*)+(((2*sizeof(char*))+sizeof(iotype*))*2)+(2*sizeof(elements*)))
 /**
  * The memory size to create a map
@@ -159 +159 @@
  */
 //#define SERVICE_SIZE (ELEMENTS_SIZE*2)+(MAP_SIZE*2)+sizeof(char*)
-#define SERVICE_SIZE sizeof(char*) + 2*sizeof(map*) + 2*sizeof(elements*)
+#define SERVICE_SIZE sizeof(char*) + 3*sizeof(map*) + 2*sizeof(elements*)
 /**
  * The memory size to create a services
@@ -228 +228 @@
     struct map* content; //!< the content map
     struct map* metadata; //!< the metadata map
+    struct map* additional_parameters; //!< the additional parameters map
     char* format; //!< the format: LiteralData or ComplexData or BoundingBoxData
     struct iotype* defaults; //!< the default iotype 
@@ -242 +243 @@
     struct map* content; //!< the content map
     struct map* metadata; //!< the metadata map
+    struct map* additional_parameters; //!< the additional parameters map
     struct elements* inputs; //!< the inputs elements
     struct elements* outputs; //!< the outputs elements
@@ -278 +280 @@
   ZOO_DLL_EXPORT void freeMap(map**);
   ZOO_DLL_EXPORT void freeMaps(maps** mo);
-  
-
+  ZOO_DLL_EXPORT iotype* createIoType();
   ZOO_DLL_EXPORT elements* createEmptyElements();
   ZOO_DLL_EXPORT elements* createElements(const char*);

branches/prototype-v0/zoo-project/zoo-kernel/service_conf.y

@@ -33 +33 @@
 static bool wait_maincontent=true;
 static bool wait_mainmetadata=false;
+static bool wait_mainap=false;
 static bool wait_metadata=false;
+static bool wait_ap=false;
 static bool wait_nested=false;
 static bool wait_inputs=false;
@@ -156 +158 @@
     current_content=NULL;
     my_service->metadata=NULL;
+    my_service->additional_parameters=NULL;
     wait_maincontent=false;
   }
   if(strncasecmp($2,"EndNested",9)==0){
 #ifdef DEBUG_SERVICE_CONF
-      fprintf(stderr,"(ENDNESTED - %d) \n",__LINE__);
-      fflush(stderr);
-#endif
-      nested_level-=1;
-      if(nested_level==0){
-        wait_nested=false;
-      }
+    fprintf(stderr,"(ENDNESTED - %d) \n",__LINE__);
+    fflush(stderr);
+#endif
+    nested_level-=1;
+    if(nested_level==0){
+      wait_nested=false;
+    }
   }
 
@@ -229 +232 @@
     }
     else
-      if(strncasecmp($2,"MetaData",8)==0){
-        previous_data=current_data;
-        current_data=3;
-        if(current_element!=NULL){
-#ifdef DEBUG_SERVICE_CONF
-          fprintf(stderr,"add current_content to current_element->content\n");
-          fprintf(stderr,"LINE %d",__LINE__);
-#endif
-          addMapToMap(&current_element->content,current_content);
-          freeMap(&current_content);
-          free(current_content);
-          if(previous_data==1 || previous_data==2)
-            wait_metadata=true;
-          else
-            wait_mainmetadata=true;
-        }
-        else{
-          if(previous_data==1 || previous_data==2)
-            wait_metadata=true;
-          else
-            wait_mainmetadata=true;
+      if(strncasecmp($2,"MetaData",8)==0 ||
+         strncasecmp($2,"AdditionalParameters",8)==0){
+        if(strncasecmp($2,"AdditionalParameters",8)==0){
+          previous_data=current_data;
+          current_data=4;
+          if(current_element!=NULL){
+#ifdef DEBUG_SERVICE_CONF
+            fprintf(stderr,"add current_content to current_element->content\n");
+            fprintf(stderr,"LINE %d",__LINE__);
+#endif
+            if(wait_mainmetadata)
+              addMapToMap(&my_service->metadata,current_content);
+            else
+              if(wait_metadata)
+                addMapToMap(&current_element->metadata,current_content);
+              else
+                addMapToMap(&current_element->content,current_content);         
+            freeMap(&current_content);
+            free(current_content);
+            if(previous_data==1 || previous_data==2)
+              wait_ap=true;
+            else
+              wait_mainap=true;
+          }
+          else{
+            if(previous_data==1 || previous_data==2)
+              wait_ap=true;
+            else
+              wait_mainap=true;
+          }
+        }else{
+          previous_data=current_data;
+          current_data=3;
+          if(current_element!=NULL){
+#ifdef DEBUG_SERVICE_CONF
+            fprintf(stderr,"add current_content to current_element->content\n");
+            fprintf(stderr,"LINE %d",__LINE__);
+#endif
+            addMapToMap(&current_element->content,current_content);
+            freeMap(&current_content);
+            free(current_content);
+            if(previous_data==1 || previous_data==2)
+              wait_metadata=true;
+            else
+              wait_mainmetadata=true;
+          }
+          else{
+            if(previous_data==1 || previous_data==2)
+              wait_metadata=true;
+            else
+              wait_mainmetadata=true;
+          }
         }
         current_content=NULL;
@@ -425 +459 @@
   if(strcmp($3,"DataOutputs")==0){
     current_data=2;
+  }  
+  if(strcmp($3,"AdditionalParameters")==0){
+    if(current_content!=NULL){
+#ifdef DEBUG_SERVICE_CONF
+      fprintf(stderr,"add current_content to current_element->content\n");
+      fprintf(stderr,"LINE %d",__LINE__);
+#endif
+      if(wait_ap){
+        current_element->additional_parameters=NULL;
+        addMapToMap(&current_element->additional_parameters,current_content);
+        current_element->next=NULL;
+        current_element->defaults=NULL;
+        current_element->supported=NULL;
+        current_element->child=NULL;
+      }else{
+        if(wait_mainap){
+          addMapToMap(&my_service->additional_parameters,current_content);
+        }
+      }
+
+      freeMap(&current_content);
+      free(current_content);
+      current_content=NULL;
+    }
+    current_data=previous_data;
+    wait_mainap=false;
+    wait_ap=false;
   }
   if(strcmp($3,"MetaData")==0){
@@ -866 +927 @@
   wait_mainmetadata=false;
   wait_metadata=false;
+  wait_mainap=false;
+  wait_ap=false;
   wait_inputs=false;
   wait_defaults=false;

branches/prototype-v0/zoo-project/zoo-kernel/service_internal.c

@@ -148 +148 @@
 
     //FILE* f0 = fopen (fileName, "r");
-        // knut: open file in binary mode to avoid conversion of line endings (yielding extra bytes) on Windows platforms
-        FILE* f0 = fopen(fileName, "rb"); 
+    // knut: open file in binary mode to avoid conversion of line endings (yielding extra bytes) on Windows platforms
+    FILE* f0 = fopen(fileName, "rb"); 
     if(f0!=NULL){
       fseek (f0, 0, SEEK_END);
@@ -162 +162 @@
         free(stat);
       }
-
       return tmps1;
     }

branches/prototype-v0/zoo-project/zoo-kernel/service_internal_hpc.c

@@ -2 +2 @@
  * Author : Gérald FENOY
  *
- * Copyright (c) 2015 GeoLabs SARL
+ * Copyright (c) 2017 GeoLabs SARL
+ *
+ * This work was supported by public funds received in the framework of GEOSUD,
+ * a project (ANR-10-EQPX-20) of the program "Investissements d'Avenir" managed 
+ * by the French National Research Agency
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
@@ -22 +26 @@
  * THE SOFTWARE.
  *
- * See Ref: http://hg.orfeo-toolbox.org/OTB/ Copyright
- * Some parts of this code are derived from ITK. See ITKCopyright.txt for 
- * details.
  */
 
@@ -30 +31 @@
 #include "response_print.h"
 #include "server_internal.h"
+#include "service_callback.h"
+#include "mimetypes.h"
 #include <sys/un.h>
 
-void appendOutputParameters(maps* input,char** parameters,int* cnt,service* s,map* uuid,map* targetPathMap){
-  while(input!=NULL){
-    if(input->child==NULL){
-      *cnt+=1;
-      if(*cnt==1)
-        parameters=(char**)malloc((*cnt)*sizeof(char*));
-      else
-        parameters=(char**)realloc(parameters,(*cnt)*sizeof(char*));
-      // Name every files that should be produced by the service execution
-      char* targetName=(char*)malloc((strlen(s->name)+strlen(input->name)+strlen(uuid->value)+10)*sizeof(char));
-      sprintf(targetName,"output_%s_%s_%s",s->name,input->name,uuid->value);
-      // TODO: We should verify if any optional tag for output is required (i.e. -out output.tiff int8)
-      char *targetPath=(char*)malloc((strlen(targetPathMap->value)+strlen(targetName)+2)*sizeof(char));
-      sprintf(targetPath,"%s/%s",targetPathMap->value,targetName);
-      parameters[*cnt-1]=(char*)malloc((strlen(input->name)+strlen(targetPath)+3)*sizeof(char));
-      sprintf(parameters[*cnt-1],"-%s %s",input->name,targetPath);
-    }else
-      appendOutputParameters(input->child,parameters,cnt,s,uuid,targetPathMap);
-    input=input->next;
+typedef struct {
+  maps* conf;
+  char* local_file;
+  char* target_file;
+} local_params;
+
+#ifdef PTHREADS
+#endif
+
+void addNestedOutputs(service** s){
+  if((*s)==NULL){
+    return;
+  }    
+  if(*s==NULL || (*s)->outputs==NULL){
+    return;
+  }
+  elements *out=(*s)->outputs;
+  elements* cur=out;
+  map* serviceType=getMap((*s)->content,"ServiceType");
+  if(strncmp(serviceType->value,"HPC",3)!=0)
+    return;
+  while(cur!=NULL && cur->defaults!=NULL){
+    map* mimeType=getMap(cur->defaults->content,"mimeType");
+    if(mimeType!=NULL){
+      int geo=isGeographic(mimeType->value);
+      if(geo>0){
+        elements *tmp[3]={
+          dupElements(cur),
+          dupElements(cur),
+          dupElements(cur)
+        };
+        char *geoLink="wcs_link";
+        if(geo==2){
+          geoLink="wfs_link";
+        }
+        int i=0;
+        for(;i<3;i++){
+          if(tmp[i]->next!=NULL){
+            freeElements(&tmp[i]->next);
+            free(tmp[i]->next);
+            tmp[i]->next=NULL;
+          }
+          free(tmp[i]->name);
+          tmp[i]->format=zStrdup("ComplexData");
+          freeMap(&tmp[i]->content);
+          free(tmp[i]->content);
+          tmp[i]->content=NULL;
+          switch(i){
+          case 0:
+            tmp[i]->name=zStrdup("download_link");
+            tmp[i]->content=createMap("Title",_("Download link"));
+            addToMap(tmp[i]->content,"Abstract",_("The download link"));
+            addToMap(tmp[i]->defaults->content,"useMapserver","false");
+            if(tmp[i]->supported!=NULL){
+              freeIOType(&tmp[i]->supported);
+              free(tmp[i]->supported);
+              tmp[i]->supported=NULL;
+            }
+            break;
+          case 1:
+            tmp[i]->name=zStrdup("wms_link");
+            tmp[i]->content=createMap("Title",_("WMS link"));
+            addToMap(tmp[i]->content,"Abstract",_("The WMS link"));
+            if(tmp[i]->supported!=NULL && tmp[i]->supported->next!=NULL){
+              freeIOType(&tmp[i]->supported->next);
+              free(tmp[i]->supported->next);
+              tmp[i]->supported->next=NULL;
+            }else{
+              if(tmp[i]->supported!=NULL)
+                addToMap(tmp[i]->supported->content,"useMapserver","true");
+              addToMap(tmp[i]->defaults->content,"useMapserver","true");
+            }
+            break;
+          case 2:
+            if(geo==2){
+              tmp[i]->name=zStrdup("wfs_link");
+              tmp[i]->content=createMap("Title",_("WFS link"));
+              addToMap(tmp[i]->content,"Abstract",_("The WFS link"));
+            }else{
+              tmp[i]->name=zStrdup("wcs_link");
+              tmp[i]->content=createMap("Title",_("WCS link"));
+              addToMap(tmp[i]->content,"Abstract",_("The WCS link"));
+            }
+            if(tmp[i]->supported!=NULL && tmp[i]->supported->next!=NULL &&
+               tmp[i]->supported->next->content!=NULL){
+              freeIOType(&tmp[i]->supported);
+              free(tmp[i]->supported);
+              tmp[i]->supported=NULL;
+              tmp[i]->supported=createIoType();
+              iotype* cnext=cur->supported->next;
+              tmp[i]->supported->content=createMap(cnext->content->name,cnext->content->value);
+              addMapToMap(&tmp[i]->supported->content,cnext->content->next);
+              addToMap(tmp[i]->supported->content,"useMapserver","true");
+            }else
+              addToMap(tmp[i]->defaults->content,"useMapserver","true");
+            break;
+          }
+        }
+        
+        addToElements(&cur->child,tmp[0]);
+        addToElements(&cur->child,tmp[1]);
+        addToElements(&cur->child,tmp[2]);
+        free(cur->format);
+        cur->format=NULL;
+        if(cur->defaults!=NULL){
+          freeIOType(&cur->defaults);
+          cur->defaults=NULL;
+        }
+        if(cur->supported!=NULL){
+          freeIOType(&cur->supported);
+          cur->supported=NULL;
+        }
+        freeElements(&tmp[2]);
+        free(tmp[2]);
+        freeElements(&tmp[1]);
+        free(tmp[1]);
+        freeElements(&tmp[0]);
+        free(tmp[0]);
+        //addToMap(cur->content,"internal","true");
+      }
+    }
+    cur=cur->next;
   }
 }
@@ -71 +177 @@
   map* tmp=NULL;
   int res=-1;
-  map* targetPathMap=getMapFromMaps(*main_conf,"HPC","storagePath");
+  char *serviceType;
+  map* mServiceType=getMap(s->content,"serviceType");
+  if(mServiceType!=NULL)
+    serviceType=mServiceType->value;
+  else
+    serviceType="HPC";
+  map* targetPathMap=getMapFromMaps(*main_conf,serviceType,"storagePath");
   map* tmpPath=getMapFromMaps(*main_conf,"main","tmpPath");
   map* uuid=getMapFromMaps(*main_conf,"lenv","usid");
-
-  sleep(5);
+  pthread_t threads_pool[50];
+  // Force the HPC services to be called asynchronously
+  map* isAsync=getMapFromMaps(*main_conf,"lenv","async");
+  if(isAsync==NULL){
+    errorException(*main_conf,_("The synchronous mode is not supported by this type of service"),"NoSuchMode",s->name);
+    return -1;
+  }
 
   maps* input=*real_inputs;
   char **parameters=NULL;
   int parameters_cnt=0;
-  while(input!=NULL){
-    parameters_cnt+=1;
-    if(parameters_cnt==1)
-      parameters=(char**)malloc(parameters_cnt*sizeof(char*));
-    else
-      parameters=(char**)realloc(parameters,parameters_cnt*sizeof(char*));
-    if(getMap(input->content,"mimeType")!=NULL){
-      // Input is ComplexData
-      SSHCON *test=ssh_connect(*main_conf);
-      dumpMaps(getMaps(*main_conf,"lenv"));
-      if(test==NULL){   
-        sleep(3600);
-        return -1;
-      }
-      if(getMap(input->content,"cache_file")==NULL){
-        // Input data has been passed by value
-        // TODO: store data remotely
-        // TODO: publish input through MapServer / use output publication
-        dumpMapsValuesToFiles(main_conf,&input);
-      }
-      if(getMap(input->content,"cache_file")!=NULL){
-        // Input data passed by reference or by value
-        map* tmp=getMap(input->content,"cache_file");
-        char* targetName=strrchr(tmp->value,'/');
-        char *targetPath=(char*)malloc((strlen(targetPathMap->value)+strlen(targetName)+2)*sizeof(char));
-        sprintf(targetPath,"%s/%s",targetPathMap->value,targetName);
-        ssh_copy(*main_conf,tmp->value,targetPath);
-        parameters[parameters_cnt-1]=(char*)malloc((strlen(input->name)+strlen(targetPath)+3)*sizeof(char));
-        sprintf(parameters[parameters_cnt-1],"-%s %s",input->name,targetPath);
-        free(targetPath);
+  while(input!=NULL && input->content!=NULL){
+    if(getMaps(*real_outputs,input->name)==NULL){
+      parameters_cnt+=1;
+      if(parameters_cnt==1)
+        parameters=(char**)malloc(parameters_cnt*sizeof(char*));
+      else
+        parameters=(char**)realloc(parameters,parameters_cnt*sizeof(char*));
+      if(getMap(input->content,"mimeType")!=NULL){
+        // Input is ComplexData
+        if(getMap(input->content,"cache_file")==NULL){
+          // Input data has been passed by value
+          // TODO: publish input through MapServer / use output publication
+          dumpMapsValuesToFiles(main_conf,&input);
+          addToMap(input->content,"toPublish","true");
+        }
+        if(getMap(input->content,"cache_file")!=NULL){
+          map* length=getMap(input->content,"length");
+          if(length==NULL){
+            addToMap(input->content,"length","1");
+            length=getMap(input->content,"length");
+          }
+          int len=atoi(length->value);
+          int i=0;
+          for(i=0;i<len;i++){
+            map* tmp=getMapArray(input->content,"cache_file",i);
+            char* targetName=strrchr(tmp->value,'/');
+            char *targetPath=(char*)malloc((strlen(targetPathMap->value)+strlen(targetName)+2)*sizeof(char));
+            sprintf(targetPath,"%s/%s",targetPathMap->value,targetName);
+            setMapArray(input->content,"targetPath",i,targetPath);
+            setMapArray(input->content,"localPath",i,tmp->value);
+            addToUploadQueue(main_conf,input);
+            if(i==0){
+              parameters[parameters_cnt-1]=(char*)malloc((strlen(input->name)+strlen(targetPath)+3)*sizeof(char));
+              sprintf(parameters[parameters_cnt-1],"-%s %s",input->name,targetPath);
+            }else{
+              char *tmpStr=zStrdup(parameters[parameters_cnt-1]);
+              parameters[parameters_cnt-1]=(char*)realloc(parameters[parameters_cnt-1],(strlen(tmpStr)+strlen(targetPath)+2)*sizeof(char));
+              sprintf(parameters[parameters_cnt-1],"%s %s",tmpStr,targetPath);
+              free(tmpStr);
+            }
+            free(targetPath);
+          }
+        }else{
+          // ???
+          fprintf(stderr,"%s %d\n",__FILE__,__LINE__);
+          fflush(stderr);
+        }
       }else{
-        // ???
-        fprintf(stderr,"%s %d\n",__FILE__,__LINE__);
-        fflush(stderr);
-      }
-    }else{
-      // LitteralData and BboxData 
-      if(getMap(input->content,"dataType")!=NULL){
-        // For LitteralData, simply pass the value
-        map* val=getMap(input->content,"value");
-        sprintf(parameters[parameters_cnt-1],"-%s %s",input->name,val->value);
-      }
-      
+        // LitteralData and BboxData 
+        if(getMap(input->content,"dataType")!=NULL){
+          // For LitteralData, simply pass the value
+          map* val=getMap(input->content,"value");
+          parameters[parameters_cnt-1]=(char*)malloc((strlen(input->name)+strlen(val->value)+3)*sizeof(char));
+          sprintf(parameters[parameters_cnt-1],"-%s %s",input->name,val->value);
+        }
+      }
     }
     input=input->next;
   }
+
+  fprintf(stderr,"************************* %s %d \n\n",__FILE__,__LINE__);
+  invokeCallback(m,inputs,NULL,2,0);
+  fprintf(stderr,"************************* %s %d \n\n",__FILE__,__LINE__);
+
+  // Upload data on HPC
+  runUpload(main_conf);
+  
+  fprintf(stderr,"************************* %s %d \n\n",__FILE__,__LINE__);
+  invokeCallback(m,inputs,NULL,2,1);
+  fprintf(stderr,"************************* %s %d \n\n",__FILE__,__LINE__);
 
   // Add the filename to generate for every output to the parameters
@@ -140 +281 @@
         parameters=(char**)realloc(parameters,parameters_cnt*sizeof(char*));
       // Name every files that should be produced by the service execution
-      char* targetName=(char*)malloc((strlen(s->name)+strlen(input->name)+strlen(uuid->value)+10)*sizeof(char));
-      sprintf(targetName,"output_%s_%s_%s",s->name,input->name,uuid->value);
-      // TODO: We should verify if any optional tag for output is required (i.e. -out output.tiff *int8*)
-      // TODO: Add support for Array values
+      map* mime=getMap(input->content,"mimeType");
+      char* targetName;
+      if(mime!=NULL){
+        bool hasExt=false;
+        map* fileExt=getFileExtensionMap(mime->value,&hasExt);
+        targetName=(char*)malloc((strlen(s->name)+strlen(input->name)+strlen(uuid->value)+strlen(fileExt->value)+11)*sizeof(char));
+        sprintf(targetName,"output_%s_%s_%s.%s",s->name,input->name,uuid->value,fileExt->value);
+        freeMap(&fileExt);
+        free(fileExt);
+      }else{
+        targetName=(char*)malloc((strlen(s->name)+strlen(input->name)+strlen(uuid->value)+14)*sizeof(char));
+        sprintf(targetName,"output_%s_%s_%s.tif",s->name,input->name,uuid->value);
+      }
       char *targetPath=(char*)malloc((strlen(targetPathMap->value)+strlen(targetName)+2)*sizeof(char));
       sprintf(targetPath,"%s/%s",targetPathMap->value,targetName);
       setMapInMaps(*real_outputs,input->name,"generated_file",targetPath);
-      parameters[parameters_cnt-1]=(char*)malloc((strlen(input->name)+strlen(targetPath)+3)*sizeof(char));
-      sprintf(parameters[parameters_cnt-1],"-%s %s",input->name,targetPath);
+      // We should verify if any optional tag for output is required
+      // (i.e. -out output.tiff *int8*), meaning that we should search
+      // for a corresponding inputs name.
+      map* inValue=getMapFromMaps(*real_inputs,input->name,"value");
+      if(inValue!=NULL){
+        parameters[parameters_cnt-1]=(char*)malloc((strlen(input->name)+strlen(targetPath)+strlen(inValue->value)+4)*sizeof(char));
+        sprintf(parameters[parameters_cnt-1],"-%s %s %s",input->name,targetPath,inValue->value);
+      }else{
+        parameters[parameters_cnt-1]=(char*)malloc((strlen(input->name)+strlen(targetPath)+3)*sizeof(char));
+        sprintf(parameters[parameters_cnt-1],"-%s %s",input->name,targetPath);
+      }
+      free(targetPath);
+    }// In other case it means we need to return the cache_file as generated_file
+    else{
+      parameters_cnt+=1;
+      if(parameters_cnt==1)
+        parameters=(char**)malloc(parameters_cnt*sizeof(char*));
+      else
+        parameters=(char**)realloc(parameters,parameters_cnt*sizeof(char*));
+      // Name every files that should be produced by the service execution
+      map* mime=getMap(input->child->content,"mimeType");
+      char* targetName;
+      if(mime!=NULL){
+        bool hasExt=false;
+        map* fileExt=getFileExtensionMap(mime->value,&hasExt);
+        targetName=(char*)malloc((strlen(s->name)+strlen(input->name)+strlen(uuid->value)+strlen(fileExt->value)+11)*sizeof(char));
+        sprintf(targetName,"output_%s_%s_%s.%s",s->name,input->name,uuid->value,fileExt->value);
+        freeMap(&fileExt);
+        free(fileExt);
+      }else{
+        targetName=(char*)malloc((strlen(s->name)+strlen(input->name)+strlen(uuid->value)+14)*sizeof(char));
+        sprintf(targetName,"output_%s_%s_%s.tif",s->name,input->name,uuid->value);
+      }
+      char *targetPath=(char*)malloc((strlen(targetPathMap->value)+strlen(targetName)+2)*sizeof(char));
+      sprintf(targetPath,"%s/%s",targetPathMap->value,targetName);
+      addToMap(input->content,"generated_file",targetPath);
+      // We should verify if any optional tag for output is required
+      // (i.e. -out output.tiff *int8*), meaning that we should search
+      // for a corresponding inputs name.
+      map* inValue=getMapFromMaps(*real_inputs,input->name,"value");
+      if(inValue!=NULL){
+        parameters[parameters_cnt-1]=(char*)malloc((strlen(input->name)+strlen(targetPath)+strlen(inValue->value)+4)*sizeof(char));
+        sprintf(parameters[parameters_cnt-1],"-%s %s %s",input->name,targetPath,inValue->value);
+      }else{
+        parameters[parameters_cnt-1]=(char*)malloc((strlen(input->name)+strlen(targetPath)+3)*sizeof(char));
+        sprintf(parameters[parameters_cnt-1],"-%s %s",input->name,targetPath);
+      }
+      free(targetPath);
     }
     input=input->next;
   }
   
+  fprintf(stderr,"************************* %s %d \n\n",__FILE__,__LINE__);
+  fflush(stderr);
+  invokeCallback(m,inputs,NULL,3,0);
+  fprintf(stderr,"************************* %s %d \n\n",__FILE__,__LINE__);
+  fflush(stderr);
+
   // Produce the SBATCH File locally
-  char *scriptPath=(char*)malloc((strlen(s->name)+strlen(tmpPath->value)+strlen(uuid->value)+9)*sizeof(char));
+  char *scriptPath=(char*)malloc((strlen(s->name)+strlen(tmpPath->value)+strlen(uuid->value)+10)*sizeof(char));
   sprintf(scriptPath,"%s/zoo_%s_%s.sh",tmpPath->value,s->name,uuid->value);
+  setMapInMaps(*main_conf,"lenv","local_script",scriptPath);
+  fprintf(stderr,"************************* %s %d \n\n",__FILE__,__LINE__);
+  fflush(stderr);
+  invokeCallback(m,inputs,NULL,3,0);
+  fprintf(stderr,"************************* %s %d \n\n",__FILE__,__LINE__);
+  fflush(stderr);
   FILE* scriptFile=fopen(scriptPath,"w+");
-  maps* hpc_opts=getMaps(*main_conf,"sbatch_options");
-  map* hpc_opts_content=hpc_opts->content;
-  map* headerMap=getMapFromMaps(*main_conf,"HPC","header");
+  map* headerMap=getMapFromMaps(*main_conf,serviceType,"header");
   if(headerMap!=NULL){
     // Use the header file if defined in the HPC section of the main.cfg file
@@ -171 +377 @@
       fcontent[fsize]=0;
       fclose(f);
-      fprintf(scriptFile,"%s\n### --- ZOO-Service HEADER end --- ###",fcontent);
+      fprintf(scriptFile,"%s\n### --- ZOO-Service HEADER end --- ###\n\n",fcontent);
       free(fcontent);
     }else
@@ -177 +383 @@
   }else
     fprintf(scriptFile,"#!/bin/bash\n\n### *** Default ZOO-Service HEADER *** ###\n\n");
-  
-  while(hpc_opts_content!=NULL){
-    fprintf(scriptFile,"#SBATCH --%s=%s\n",hpc_opts_content->name,hpc_opts_content->value);
-    hpc_opts_content=hpc_opts_content->next;
+  maps* hpc_opts=getMaps(*main_conf,"sbatch_options");
+  if(hpc_opts!=NULL){
+    map* hpc_opts_content=hpc_opts->content;
+    while(hpc_opts_content!=NULL){
+      fprintf(scriptFile,"#SBATCH --%s=%s\n",hpc_opts_content->name,hpc_opts_content->value);
+      hpc_opts_content=hpc_opts_content->next;
+    }
   }
   fprintf(scriptFile,"#SBATCH --job-name=ZOO-Project_%s_%s\n\n",uuid->value,s->name);
@@ -186 +395 @@
   if(mods!=NULL)
     fprintf(scriptFile,"#SBATCH --export=MODULES=%s\n",mods->value);
-  else
-    fprintf(scriptFile,"#SBATCH --export=MODULES=\n");
+
+  map* bodyMap=getMapFromMaps(*main_conf,serviceType,"body");
+  if(bodyMap!=NULL){
+    // Use the header file if defined in the HPC section of the main.cfg file
+    struct stat f_status;
+    int s=stat(bodyMap->value, &f_status);
+    if(s==0){
+      char* fcontent=(char*)malloc(sizeof(char)*(f_status.st_size+1));
+      FILE* f=fopen(bodyMap->value,"rb");
+      fread(fcontent,f_status.st_size,1,f);
+      int fsize=f_status.st_size;
+      fcontent[fsize]=0;
+      fclose(f);
+      fprintf(scriptFile,"%s\n### --- ZOO-Service BODY end --- ###\n\n",fcontent);
+      free(fcontent);
+    }else
+      fprintf(scriptFile,"#!/bin/bash\n\n### *** Default ZOO-Service BODY (no body found) *** ###\n\n");
+  }else
+    fprintf(scriptFile,"#!/bin/bash\n\n### *** Default ZOO-Service BODY *** ###\n\n");
+
+  
   map* sp=getMap(s->content,"serviceProvider");
+  
   // Require to produce the command line to be executed
   fprintf(scriptFile,"\n\necho \"Job started at: $(date)\"\n");
@@ -195 +424 @@
   for(int i=0;i<parameters_cnt;i++){
     fprintf(scriptFile," %s",parameters[i]);
-    //free(parameters[i]);
+  }
+  for(int i=parameters_cnt-1;i>=0;i--){
+    free(parameters[i]);
   }
   free(parameters);
   fprintf(scriptFile,"\n");
   fprintf(scriptFile,"echo \"Job finished at: $(date)\"\n");
-  
   fflush(scriptFile);
   fclose(scriptFile);
+  
+  fprintf(stderr,"************************* %s %d \n\n",__FILE__,__LINE__);
+  invokeCallback(m,inputs,NULL,3,1);
+  fprintf(stderr,"************************* %s %d \n\n",__FILE__,__LINE__);
 
   // Upload the SBATCH File to the remote host
-  targetPathMap=getMapFromMaps(*main_conf,"HPC","executePath");
+  fprintf(stderr,"************************* %s %d \n\n",__FILE__,__LINE__);
+  invokeCallback(m,inputs,NULL,4,0);
+  fprintf(stderr,"************************* %s %d \n\n",__FILE__,__LINE__);
+  targetPathMap=getMapFromMaps(*main_conf,serviceType,"executePath");
   if(targetPathMap==NULL){
     setMapInMaps(*main_conf,"lenv","message",_("There is no executePath defined in you HPC section!"));
@@ -213 +450 @@
   char *targetPath=(char*)malloc((strlen(targetPathMap->value)+strlen(targetName)+2)*sizeof(char));
   sprintf(targetPath,"%s/%s",targetPathMap->value,targetName);
+  setMapInMaps(*main_conf,"lenv","remote_script",targetPath);
   SSHCON *test=ssh_connect(*main_conf);
-  ssh_copy(*main_conf,scriptPath,targetPath);
+  ssh_copy(*main_conf,scriptPath,targetPath,ssh_get_cnt(*main_conf));
   
   // Execute the SBATCH script remotely
   map* subStr=getMapFromMaps(*main_conf,"HPC","subStr");
-  //char *command=(char*)malloc((strlen(targetPath)+strlen(targetPathMap->value)+strlen(subStr->value)+strlen(uuid->value)+37)*sizeof(char));
   char *command=(char*)malloc((strlen(targetPath)+strlen(targetPathMap->value)+strlen(subStr->value)+strlen(uuid->value)+137)*sizeof(char));
-  //sprintf(command,"ls # %s 2> %s/error_%s.log | sed \"s:%s::g\"",targetPath,targetPathMap->value,uuid->value,subStr->value);
   sprintf(command,"sbatch %s 2> %s/error_%s.log | sed \"s:%s::g\"",targetPath,targetPathMap->value,uuid->value,subStr->value);
-  if(ssh_exec(*main_conf,command)==0){
+  if(ssh_exec(*main_conf,command,ssh_get_cnt(m))==0){
     // The sbatch command has failed!
     // Download the error log file from the HPC server
     char tmpS[1024];
     free(command);
-    command=(char*)malloc((strlen(targetPathMap->value)+strlen(uuid->value)+22)*sizeof(char));
+    command=(char*)malloc((strlen(targetPathMap->value)+strlen(uuid->value)+11)*sizeof(char));
     sprintf(command,"%s/error_%s.log",targetPathMap->value,uuid->value);
     targetName=strrchr(command,'/');
@@ -233 +469 @@
     targetPath=(char*)malloc((strlen(tmpPath->value)+strlen(targetName)+2)*sizeof(char));
     sprintf(targetPath,"%s/%s",tmpPath->value,targetName);
-    if(ssh_fetch(*main_conf,targetPath,command)==0){
+    if(ssh_fetch(*main_conf,targetPath,command,ssh_get_cnt(m))==0){
       struct stat f_status;
       int ts=stat(targetPath, &f_status);
@@ -251 +487 @@
       setMapInMaps(*main_conf,"lenv","message",_("Unable to fetch the remote error log file"));
     tmpPath=getMapFromMaps(*main_conf,"lenv","message");
+    invokeCallback(m,NULL,NULL,7,1);
     sprintf(tmpS, "Cannot execute the HPC ZOO-Service %s: %s", s->name, tmpPath->value);
     errorException(m,tmpS,"NoApplicableCode",NULL);
@@ -259 +496 @@
     return -1;
   }
+  fprintf(stderr,"************************* %s %d \n\n",__FILE__,__LINE__);
+  fflush(stderr);
+  invokeCallback(m,NULL,NULL,4,1);
+  fprintf(stderr,"************************* %s %d \n\n",__FILE__,__LINE__);
+  fflush(stderr);
+  free(command);
 
   struct sockaddr_un addr;
@@ -264 +507 @@
   addr.sun_family = AF_UNIX;
   int rc, cl, fd = socket(AF_UNIX, SOCK_STREAM, 0);
-  char buf[100];
-  char *sname=(char*)malloc((strlen(tmpPath->value)+strlen(uuid->value)+19));
+  char *sname=(char*)malloc((strlen(tmpPath->value)+strlen(uuid->value)+20));
   sprintf(sname,"%s/.wait_socket_%s.sock",tmpPath->value,uuid->value);
   strncpy(addr.sun_path, sname, sizeof(addr.sun_path)-1);
+  
   if (bind(fd, (struct sockaddr*)&addr, sizeof(addr)) == -1) {
     perror("bind error");
@@ -274 +517 @@
   }
   if (listen(fd, 5) == -1) {
-    perror("listen error");
-    sleep(120);
+    setMapInMaps(*main_conf,"lenv","message",_("Listen error"));
     return -1;
   }
-  /*fd_set master, read_fds;
-  int fdmax;
-  FD_ZERO(&master);
-  FD_ZERO(&read_fds);
-  FD_SET(fd, &master);
-  if (select(fd+1, &master, NULL, NULL, NULL) == -1) {
-    perror("select");
-    sleep(120);
+  if ( (cl = accept(fd, NULL, NULL)) == -1) {
+    setMapInMaps(*main_conf,"lenv","message",_("Accept error"));
     return -1;
-  }
-  if (FD_ISSET(fd, &master)) {*/
-    if ( (cl = accept(fd, NULL, NULL)) == -1) {
-      perror("accept error");
+  }else{
+    int hasPassed=-1;
+    char buf[11];
+    memset(&buf,0,11);
+    while ( (rc=read(cl,buf,10)) ) {      
+      if(rc==0){
+        sleep(1);
+        setMapInMaps(*main_conf,"lenv","message",_("Read closed"));
+        return -1;
+      }else{
+        if(rc<0){
+          setMapInMaps(*main_conf,"lenv","message",_("Read error"));
+          return -1;
+        }
+      }
+      hasPassed=1;
+      res=atoi(buf);
+      unlink(sname);
+      //free(sname);  
+
+      if(res==3){
+        fprintf(stderr,"************************* %s %d \n\n",__FILE__,__LINE__);
+        fflush(stderr);
+        invokeCallback(m,NULL,outputs,5,0);
+        fprintf(stderr,"************************* %s %d \n\n",__FILE__,__LINE__);
+        fflush(stderr);
+        input=*real_outputs;
+        while(input!=NULL){
+          if(input->child==NULL){
+            map* generatedFile=getMap(input->content,"generated_file");
+            if(generatedFile!=NULL){
+              char* filename=strrchr(generatedFile->value,'/');
+              char* targetPath=(char*)malloc((strlen(tmpPath->value)+strlen(filename)+2)*sizeof(char));
+              sprintf(targetPath,"%s/%s",tmpPath->value,filename);
+              test=ssh_connect(*main_conf);
+              if(ssh_fetch(*main_conf,targetPath,generatedFile->value,ssh_get_cnt(m))==0){
+                setMapInMaps(*real_outputs,input->name,"generated_file",targetPath);
+                free(targetPath);
+              }else{
+                char *tmpStr=(char*)malloc((strlen(filename)+strlen(_("Unable to fetch the remote file for %s"))+1)*sizeof(char));
+                sprintf(tmpStr,_("Unable to fetch the remote file for %s"),filename);
+                setMapInMaps(*main_conf,"lenv","message",tmpStr);
+                free(tmpStr);
+                return SERVICE_FAILED;
+              }
+            }       
+          }else{
+            fprintf(stderr,"%s %d\n",__FILE__,__LINE__);
+            fflush(stderr);
+            map* generatedFile=getMap(input->content,"generated_file");
+            if(generatedFile!=NULL){
+              char* filename=strrchr(generatedFile->value,'/');
+              char* targetPath=(char*)malloc((strlen(tmpPath->value)+strlen(filename)+2)*sizeof(char));
+              sprintf(targetPath,"%s/%s",tmpPath->value,filename);
+              test=ssh_connect(*main_conf);
+              if(ssh_fetch(*main_conf,targetPath,generatedFile->value,ssh_get_cnt(m))==0){
+                maps* tmp=getMaps(*real_outputs,input->name);
+                freeMap(&tmp->content);
+                free(tmp->content);
+                tmp->content=NULL;
+                maps* output=getMaps(*real_outputs,input->name);
+                setMapInMaps(output->child,"download_link","generated_file",targetPath);
+                setMapInMaps(output->child,"download_link","useMapserver","false");
+                setMapInMaps(output->child,"WMS_LINK","generated_file",targetPath);
+                setMapInMaps(output->child,"WMS_LINK","useMapserver","true");
+                setMapInMaps(output->child,"WCS_LINK","generated_file",targetPath);
+                setMapInMaps(output->child,"WCS_LINK","useMapserver","true");
+              }
+            }
+          }
+          input=input->next;
+        }
+      }
+      //free(buf);
+    }
+    if(hasPassed<0){
+      perror("Failed to read");
+      setMapInMaps(*main_conf,"lenv","message",_("Unable to parse the value returned by remote execution"));
       sleep(120);
-      return -1;
-    }else{
-      int hasPassed=-1;
-      /*FD_SET(cl,&read_fds);
-      if (select(cl+1, &read_fds, NULL, NULL, NULL) == -1) {
-        perror("select");
-        sleep(120);
-        return -1;
-        }*/
-      while ( (rc=read(cl,buf,10)) ) {    
-        if(rc==0){
-          sleep(120);
-          return -1;
-        }else{
-          if(rc<0){
-            perror("read");
-            sleep(120);
-            return -1;
-          }
-        }
-        hasPassed=1;
-        res=atoi(buf);
-        unlink(sname);
-        if(res==3){
-          input=*real_outputs;
-          while(input!=NULL){
-            // TODO: parse all outputs including inner outputs if required.
-            if(input->child==NULL){
-              //map* dataPath=getMapFromMaps(*main_conf,"main","dataPath");
-              map* generatedFile=getMap(input->content,"generated_file");
-              if(generatedFile!=NULL){
-                char* filename=strrchr(generatedFile->value,'/');
-                char* targetPath=(char*)malloc((strlen(tmpPath->value)+strlen(filename)+2)*sizeof(char));
-                sprintf(targetPath,"%s/%s",tmpPath->value,filename);
-                test=ssh_connect(*main_conf);
-                if(ssh_fetch(*main_conf,targetPath,generatedFile->value)==0){
-                  setMapInMaps(*real_outputs,input->name,"generated_file",targetPath);
-                }else{
-                  char *tmpStr=(char*)malloc((strlen(filename)+strlen(_("Unable to fetch the remote file for %s"))+1)*sizeof(char));
-                  sprintf(tmpStr,_("Unable to fetch the remote file for %s"),filename);
-                  setMapInMaps(*main_conf,"lenv","message",tmpStr);
-                  free(tmpStr);
-                  return SERVICE_FAILED;
-                }
-              }
-            }/*else{
-             // Generate the nested outputs based on each input value
-             if(getMaps(*real_inputs,input->name)!=NULL && getMapFromMaps(*real_inputs,input->name,"mimeType")!=NULL){
-             // Input was ComplexeData
-             maps* output=getMaps(*real_outputs,input->name);
-             map* cache=getMapFromMaps(*real_inputs,input->name,"cache_file");
-             setMapInMaps(output->child,"download","generated_file",cache->value);
-             setMapInMaps(output->child,"WCS_LINK","generated_file",cache->value);
-             setMapInMaps(output->child,"WCS_LINK","useMs","true");
-             setMapInMaps(output->child,"WMS_LINK","generated_file",cache->value);
-             setMapInMaps(output->child,"WMS_LINK","useMs","true");
-             }
-             }*/
-            input=input->next;
-          }
-        }
-      }
-      if(hasPassed<0){
-        perror("Failed to read");
-        setMapInMaps(*main_conf,"lenv","message",_("Unable to parse the value returned by remote execution"));
-        sleep(120);
-        return SERVICE_FAILED;
-      }
+      return SERVICE_FAILED;
     }
-    //}
+  }
   ssh_close(*main_conf);
-  //sleep(120);
   return res;
 }

branches/prototype-v0/zoo-project/zoo-kernel/service_internal_hpc.h

@@ -2 +2 @@
  * Author : Gérald FENOY
  *
- * Copyright (c) 2015 GeoLabs SARL
+ * Copyright (c) 2017 GeoLabs SARL
+ *
+ * This work was supported by public funds received in the framework of GEOSUD,
+ * a project (ANR-10-EQPX-20) of the program "Investissements d'Avenir" managed 
+ * by the French National Research Agency
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
@@ -37 +41 @@
 #include "sshapi.h"
 
+void addNestedOutputs(service**);
 int zoo_hpc_support(maps**,map*,service*,maps**,maps**);
 

branches/prototype-v0/zoo-project/zoo-kernel/service_internal_js.c

@@ -934 +934 @@
   }else{
     if(argc==3){
-      char *body=JSValToChar(cx,&argv[2]);
-      InternetOpenUrl(&hInternet,hInternet.waitingRequests[hInternet.nb],body,strlen(body),
-                      INTERNET_FLAG_NO_CACHE_WRITE,0);
-      processDownloads(&hInternet);
-      free(body);
+      if(strncasecmp(method,"GET",3)==0){
+        header=JSVAL_TO_OBJECT(argv[2]);
+        if(JS_IsArrayObject(cx,header)){
+          setHeader(&hInternet,cx,header);
+        }
+        InternetOpenUrl(&hInternet,hInternet.waitingRequests[hInternet.nb],NULL,0,
+                        INTERNET_FLAG_NO_CACHE_WRITE,0);
+        processDownloads(&hInternet);
+      }else{
+        char *body=JSValToChar(cx,&argv[2]);
+        InternetOpenUrl(&hInternet,hInternet.waitingRequests[hInternet.nb],body,strlen(body),
+                        INTERNET_FLAG_NO_CACHE_WRITE,0);
+        processDownloads(&hInternet);
+        free(body);
+      }
     }else{
       InternetOpenUrl(&hInternet,hInternet.waitingRequests[hInternet.nb],NULL,0,

branches/prototype-v0/zoo-project/zoo-kernel/service_internal_ms.c

@@ -131 +131 @@
  */
 void setReferenceUrl(maps* m,maps* tmpI){
-  fprintf(stderr,"%s %D \n",__FILE__,__LINE__);
-  fflush(stderr);
-  dumpMaps(tmpI);
-  fprintf(stderr,"%s %D \n",__FILE__,__LINE__);
-  fflush(stderr);
   outputMapfile(m,tmpI);
-  fprintf(stderr,"%s %D \n",__FILE__,__LINE__);
-  fflush(stderr);
-  dumpMaps(tmpI);
-  fprintf(stderr,"%s %D \n",__FILE__,__LINE__);
-  fflush(stderr);
   map *msUrl=getMapFromMaps(m,"main","mapserverAddress");
   if(msUrl==NULL){
@@ -169 +159 @@
   if(strncasecmp(rformat->value,"text/xml",8)==0)
     proto=1;
-  if(strncasecmp(rformat->value,"image/tiff",10)==0)
+  if(strncasecmp(rformat->value,"image/tiff",10)==0 ||
+     strncasecmp(rformat->value,"image/geotiff",10)==0)
     proto=2;
   if(protoMap!=NULL){
@@ -478 +469 @@
     fprintf(stderr,"Unable to access the DataSource as ZIP File\n");
     setMapInMaps(conf,"lenv","message","Unable to open datasource in read only mode");
-    OGR_DS_Destroy(poDS1);
+    //OGR_DS_Destroy(poDS1);
   }else{
 #ifdef DEBUGMS
@@ -549 +540 @@
 #endif
     setMapInMaps(conf,"lenv","message","Unable to open datasource in read only mode");
-    OGR_DS_Destroy(poDS);
-    OGRCleanupAll();
+    //OGR_DS_Destroy(poDS);
+    //OGRCleanupAll();
 #ifdef DEBUGMS
     fprintf(stderr,"Unable to access the DataSource, exit! \n"); 
@@ -652 +643 @@
     if (OGR_L_GetExtent(poLayer,&oExt, TRUE) == OGRERR_NONE){
       setMsExtent(output,m,myLayer,oExt.MinX, oExt.MinY, oExt.MaxX, oExt.MaxY);
+      char extent[1024];
+      memset(&extent,0,1024);
+      sprintf(extent,"%d,%d,%d,%d",oExt.MinX, oExt.MinY, oExt.MaxX, oExt.MaxY);
+      addToMap(output->content,"boundingbox",extent);
     }
   
@@ -724 +719 @@
   }
 
-  OGR_DS_Destroy(poDS);
-  OGRCleanupAll();
+  //OGR_DS_Destroy(poDS);
+  //OGRCleanupAll();
 
   return 1;
@@ -819 +814 @@
   }
 
-
   /**
    * Set extent
@@ -836 +830 @@
         + adfGeoTransform[4] * GDALGetRasterXSize(hDataset);
 
-       setMsExtent(output,m,myLayer,minX,minY,maxX,maxY);
-
+      setMsExtent(output,m,myLayer,minX,minY,maxX,maxY);
+      char extent[1024];
+      memset(&extent,0,1024);
+      sprintf(extent,"%d,%d,%d,%d",minX,minY,maxX,maxY);
+      addToMap(output->content,"boundingbox",extent);
     }
   }
@@ -846 +843 @@
    */
   char nBands[3];
+  memset(&nBands,0,3);
   int nBandsI=GDALGetRasterCount( hDataset );
-  sprintf(nBands,"%d",GDALGetRasterCount( hDataset ));
-  msInsertHashTable(&(myLayer->metadata), "ows_bandcount", nBands);
+  if(nBandsI<100){
+    sprintf(nBands,"%d",GDALGetRasterCount( hDataset ));
+    msInsertHashTable(&(myLayer->metadata), "ows_bandcount", nBands);
+  }
   if(nBandsI>=3)
     msLayerAddProcessing(myLayer,"BANDS=1,2,3");
@@ -860 +860 @@
    */
   char lBands[7];
+  memset(&nBands,0,7);
   char *nameBands=NULL;
   for( iBand = 0; iBand < nBandsI; iBand++ ){
-    sprintf(lBands,"Band%d",iBand+1);
+    sprintf(lBands,"Band%d",iBand+1);    
     if(nameBands==NULL){
       nameBands=(char*)malloc((strlen(lBands)+1)*sizeof(char));
@@ -869 +870 @@
       if(iBand<4){
         char *tmpS=zStrdup(nameBands);
-        nameBands=(char*)realloc(nameBands,(strlen(nameBands)+strlen(lBands)+1)*sizeof(char));
+        nameBands=(char*)realloc(nameBands,(strlen(tmpS)+strlen(lBands)+2)*sizeof(char));
         sprintf(nameBands,"%s %s",tmpS,lBands);
         free(tmpS);
@@ -875 +876 @@
     }
   }
-  msInsertHashTable(&(myLayer->metadata), "ows_bandnames", nameBands);
-  
+  if(nameBands!=NULL){
+    msInsertHashTable(&(myLayer->metadata), "ows_bandnames", nameBands);
+    free(nameBands);
+  }
+
   /**
    * Loops over metadata information to setup specific information
@@ -894 +898 @@
       char tmpMm[100];
       sprintf(tmpMm,"%.3f %.3f",adfCMinMax[0],adfCMinMax[1]);
-      char tmpI[21];
+      char tmpI[31];      
       sprintf(tmpI,"%s_interval",tmpN);
       msInsertHashTable(&(myLayer->metadata), tmpI, tmpMm);
@@ -977 +981 @@
     }
     if( strlen(GDALGetRasterUnitType(hBand)) > 0 ){
-      char tmpU[21];
+      char tmpU[31];
       sprintf(tmpU,"%s_band_uom",tmpN);
       msInsertHashTable(&(myLayer->metadata), tmpU, GDALGetRasterUnitType(hBand));
@@ -988 +992 @@
   GDALClose( hDataset );
   GDALDestroyDriverManager();
+
   CPLCleanupTLS();
   return 1;
@@ -999 +1004 @@
  */
 void outputMapfile(maps* conf,maps* outputs){
-  fprintf(stderr,"%s %D \n",__FILE__,__LINE__);
-  fflush(stderr);
-  dumpMaps(outputs);
-  fprintf(stderr,"%s %D \n",__FILE__,__LINE__);
-  fflush(stderr);
   /**
    * First store the value on disk
@@ -1013 +1013 @@
       ext="json";
 
-  fprintf(stderr,"%s %D \n",__FILE__,__LINE__);
-  fflush(stderr);
   map* tmpMap=getMapFromMaps(conf,"main","dataPath");
   map* sidMap=getMapFromMaps(conf,"lenv","usid");
   char *pszDataSource=(char*)malloc((strlen(tmpMap->value)+strlen(sidMap->value)+strlen(outputs->name)+17)*sizeof(char));
-  sprintf(pszDataSource,"%s/ZOO_DATA_%s_%s.%s",tmpMap->value,outputs->name,sidMap->value,ext); 
+  sprintf(pszDataSource,"%s/ZOO_DATA_%s_%s.%s",tmpMap->value,outputs->name,sidMap->value,ext);
   int f=zOpen(pszDataSource,O_WRONLY|O_CREAT,S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH);
   map *gfile=getMap(outputs->content,"generated_file");
@@ -1026 +1024 @@
   map* sizeMap=getMap(outputs->content,"size");
   map* vData=getMap(outputs->content,"value");
-  fprintf(stderr,"%s %D \n",__FILE__,__LINE__);
-  fflush(stderr);
   if(sizeMap!=NULL){
     zWrite(f,vData->value,atoi(sizeMap->value)*sizeof(char));
@@ -1034 +1030 @@
     zWrite(f,vData->value,(strlen(vData->value)+1)*sizeof(char));
   }
-  fprintf(stderr,"%s %D \n",__FILE__,__LINE__);
-  fflush(stderr);
   close(f);
-  fprintf(stderr,"%s %D \n",__FILE__,__LINE__);
-  fflush(stderr);
   addToMap(outputs->content,"storage",pszDataSource);
   free(pszDataSource);
-  fprintf(stderr,"%s %D \n",__FILE__,__LINE__);
-  fflush(stderr);
 
   /*
@@ -1049 +1039 @@
   mapObj *myMap=msNewMapObj();
   free(myMap->name);
-  fprintf(stderr,"%s %D \n",__FILE__,__LINE__);
-  fflush(stderr);
   myMap->name=zStrdup("ZOO-Project_WXS_Server");
-  fprintf(stderr,"%s %D \n",__FILE__,__LINE__);
-  fflush(stderr);
   msMapSetSize(myMap,2048,2048);
-  fprintf(stderr,"%s %D \n",__FILE__,__LINE__);
-  fflush(stderr);
   msMapSetExtent(myMap,-1,-1,1,1);
-  fprintf(stderr,"%s %D \n",__FILE__,__LINE__);
-  fflush(stderr);
   
   /*
@@ -1068 +1050 @@
   tmp1=getMapFromMaps(conf,"main","tmpUrl");
   myMap->web.imageurl=zStrdup(tmp1->value);
-  fprintf(stderr,"%s %D \n",__FILE__,__LINE__);
-  fflush(stderr);
   
   /*
@@ -1080 +1060 @@
   msAppendOutputFormat(myMap,msCloneOutputFormat(o1));
   msFreeOutputFormat(o1);
-  fprintf(stderr,"%s %D \n",__FILE__,__LINE__);
-  fflush(stderr);
 
 #ifdef USE_KML
@@ -1094 +1072 @@
   }
 #endif
-  fprintf(stderr,"%s %D \n",__FILE__,__LINE__);
-  fflush(stderr);
 
   outputFormatObj *o3=msCreateDefaultOutputFormat(NULL,"GDAL/GTiff","tiff");
@@ -1106 +1082 @@
     msFreeOutputFormat(o3);
   }
-  fprintf(stderr,"%s %D \n",__FILE__,__LINE__);
-  fflush(stderr);
 
   outputFormatObj *o4=msCreateDefaultOutputFormat(NULL,"GDAL/AAIGRID","grd");
@@ -1118 +1092 @@
     msFreeOutputFormat(o4);
   }
-  fprintf(stderr,"%s %D \n",__FILE__,__LINE__);
-  fflush(stderr);
 
 #ifdef USE_CAIRO
@@ -1133 +1105 @@
   }
 #endif
-  fprintf(stderr,"%s %D \n",__FILE__,__LINE__);
-  fflush(stderr);
 
   /*
@@ -1141 +1111 @@
   msLoadProjectionStringEPSG(&myMap->projection,"EPSG:4326");
   myMap->transparent=1;
-  fprintf(stderr,"%s %D \n",__FILE__,__LINE__);
-  fflush(stderr);
 
   /**

branches/prototype-v0/zoo-project/zoo-kernel/sql/schema.sql

@@ -45 +45 @@
        creation_time timestamp with time zone default now(),
        end_time timestamp with time zone default NULL,
+       -- queue_duration ,
+       -- run_duration ,
        progress int,
-       message TEXT
+       message TEXT,
+       -- data_lifetime timestamp with time zone default now() + interval '48 hours',
+       rps_step int4 default 0
 );
 --------------------------------------------------------------------------------
@@ -52 +56 @@
 -- Used to store the response provided by a services running asynchronously
 create table responses (
-       uuid text references services(uuid) ON DELETE CASCADE,
+       uuid text references process(uuid) ON DELETE CASCADE,
        content text,
        creation_time timestamp with time zone default now()

branches/prototype-v0/zoo-project/zoo-kernel/sqlapi.c

@@ -43 +43 @@
 OGRDataSource 
 #endif
- *zoo_DS = NULL;
+ **zoo_DS = NULL;
 
 /**
@@ -70 +70 @@
   int i=0;
   maps* cconf=getMaps(conf,key);
+  if(cconf==NULL)
+    return "-1";
   int len=0;
   for(i=0;i<6;i++){
     map* tmp=getMap(cconf->content,keywords[i]);
-    fprintf(stderr,"%s %d \n",__FILE__,__LINE__);
-    fflush(stderr);
     if(tmp!=NULL){
-      fprintf(stderr,"%s %d \n",__FILE__,__LINE__);
-      fflush(stderr);
       if(res==NULL){
         res=(char*)malloc((strlen(keywords[i])+strlen(tmp->value)+4)*sizeof(char));
@@ -89 +87 @@
         len+=strlen(res1);
         res[len]=0;
-        fprintf(stderr,"%s %d \n",__FILE__,__LINE__);
-        fflush(stderr);
         free(res1);
       }
     }
-    fprintf(stderr,"%s %d \n",__FILE__,__LINE__);
-    fflush(stderr);
-  }
-  fprintf(stderr,"%s %d \n",__FILE__,__LINE__);
-  fflush(stderr);
+  }
   map* tmp=getMap(cconf->content,"type");
   if(tmp!=NULL){
@@ -125 +117 @@
  * @see createInitString
  */
-void _init_sql(maps* conf,const char* key){
+int _init_sql(maps* conf,const char* key){
   char* sqlInitString=_createInitString(conf,key);
+  if(strncmp(sqlInitString,"-1",2)==0)
+    return -1;
   OGRSFDriver *poDriver = NULL;
   OGRRegisterAll();
-
+  int zoo_ds_nb=0;
+  map* dsNb=getMapFromMaps(conf,"lenv","ds_nb");
+  if(dsNb==NULL){
+    setMapInMaps(conf,"lenv","ds_nb","1");
+  }else{
+    zoo_ds_nb=atoi(dsNb->value);
+    char* tmp=(char*)malloc(11*sizeof(char));
+    sprintf(tmp,"%d",zoo_ds_nb+1);
+    setMapInMaps(conf,"lenv","ds_nb",(const char*)tmp);
+    free(tmp);
+  }
+  if(zoo_DS==NULL)
+    zoo_DS=
 #if GDAL_VERSION_MAJOR >= 2
-  zoo_DS = (GDALDataset*) GDALOpenEx( sqlInitString,
+      (GDALDataset**) malloc(sizeof(GDALDataset*))
+#else
+      (OGRDataSource**) malloc(sizeof(OGRDataSource*))
+#endif
+      ;
+  else
+    zoo_DS=      
+#if GDAL_VERSION_MAJOR >= 2
+      (GDALDataset**)realloc(zoo_DS,(zoo_ds_nb+1)*sizeof(GDALDataset*))
+#else
+      (OGRDataSource**)realloc(zoo_DS,(zoo_ds_nb+1)*sizeof(OGRDataSource*))
+#endif
+      ;
+  
+#if GDAL_VERSION_MAJOR >= 2
+  zoo_DS[zoo_ds_nb] = (GDALDataset*) GDALOpenEx( sqlInitString,
                                       GDAL_OF_UPDATE | GDAL_OF_VECTOR,
                                       NULL, NULL, NULL );
 #else
-  zoo_DS = OGRSFDriverRegistrar::Open(sqlInitString,false,&poDriver);
-#endif
-  if( zoo_DS == NULL ){
+  zoo_DS[zoo_ds_nb] = OGRSFDriverRegistrar::Open(sqlInitString,false,&poDriver);
+#endif
+  if( zoo_DS[zoo_ds_nb] == NULL ){
 #ifdef DEBUG
     fprintf(stderr,"sqlInitString: %s FAILED !\n",sqlInitString);
@@ -143 +164 @@
 #endif
     free(sqlInitString);
-    setMapInMaps(conf,"lenv","message","Failed to connect to the database backend");
-    return;
+    setMapInMaps(conf,"lenv","dbIssue","1");
+    setMapInMaps(conf,"lenv","message",_("Failed to connect to the database backend"));
+    return -2;
   }
 #ifdef DEBUG
@@ -150 +172 @@
   fflush(stderr);
 #endif
+  fprintf(stderr,"sqlInitString: %s SUCEED %d !\n",sqlInitString,zoo_ds_nb);
+  fflush(stderr);  
   free(sqlInitString);
+  zoo_ds_nb++;
+  return zoo_ds_nb;
 }
 
@@ -159 +185 @@
  * @see createInitString
  */
-void init_sql(maps* conf){
+int init_sql(maps* conf){
   return _init_sql(conf,"database");
 }
@@ -168 +194 @@
  * @param conf the maps containing the setting of the main.cfg file
  */
-void close_sql(maps* conf){
+void close_sql(maps* conf,int cid){
   if( zoo_ResultSet != NULL )
-    zoo_DS->ReleaseResultSet( zoo_ResultSet );
+    zoo_DS[cid]->ReleaseResultSet( zoo_ResultSet );
   if(zoo_DS!=NULL){
 #if GDAL_VERSION_MAJOR >= 2
-    GDALClose(zoo_DS);
-#else
-    OGRDataSource::DestroyDataSource( zoo_DS );
-#endif
-    zoo_DS=NULL;
+    GDALClose(zoo_DS[cid]);
+#else
+    OGRDataSource::DestroyDataSource( zoo_DS[cid] );
+#endif
+    zoo_DS[cid]=NULL;
   }
 }
@@ -196 +222 @@
  * @return NULL in case of failure or an OGRLayer pointer if the query succeed.
  */
-OGRLayer *fetchSql(maps* conf,const char* sqlQuery){
+OGRLayer *fetchSql(maps* conf,int cid,const char* sqlQuery){
+  if(zoo_DS[cid]==NULL)
+    return NULL;
   OGRLayer *res=NULL;
-  res = zoo_DS->ExecuteSQL( sqlQuery, NULL, NULL);
+#ifdef DEBUG
+  fprintf(stderr,"************************* %s %s %d\n\n",sqlQuery,__FILE__,__LINE__);
+  fflush(stderr);
+#endif
+  res = zoo_DS[cid]->ExecuteSQL( sqlQuery, NULL, NULL);
   return res;
 }
 
-void cleanFetchSql(maps* conf,OGRLayer *objects){
+void cleanFetchSql(maps* conf,int cid,OGRLayer *objects){
   if( objects != NULL ){
-    zoo_DS->ReleaseResultSet( objects );
+    zoo_DS[cid]->ReleaseResultSet( objects );
     objects=NULL;
   }
@@ -216 +248 @@
  * @return -1 in case of failure and 1 if the query succeed.
  */
-int execSql(maps* conf,const char* sqlQuery){
+int execSql(maps* conf,int cid,const char* sqlQuery){
   int res=-1;
-  zoo_ResultSet = zoo_DS->ExecuteSQL( sqlQuery, NULL, NULL);
+  zoo_ResultSet = zoo_DS[cid]->ExecuteSQL( sqlQuery, NULL, NULL);
   if( zoo_ResultSet != NULL ){
     res=1;
   }
-  zoo_DS->ReleaseResultSet( zoo_ResultSet );
   return res;
 }
@@ -233 +264 @@
  * @return -1 in case of failure and 1 if the query succeed.
  */
-void cleanUpResultSet(const maps* conf){
+void cleanUpResultSet(const maps* conf,int cid){
   if( zoo_ResultSet != NULL ){
-    zoo_DS->ReleaseResultSet( zoo_ResultSet );
+    zoo_DS[cid]->ReleaseResultSet( zoo_ResultSet );
     zoo_ResultSet=NULL;
   }
+}
+
+#ifdef RELY_ON_DB
+int getCurrentId(maps* conf){
+  int res=0;
+  map* dsNb=getMapFromMaps(conf,"lenv","ds_nb");
+  if(dsNb!=NULL)
+    res=atoi(dsNb->value);
+  return res;
 }
 
@@ -249 +289 @@
  */
 void recordStoredFile(maps* conf,const char* filename,const char* type,const char* name){
+  int zoo_ds_nb=getCurrentId(conf);
   map *uusid=getMapFromMaps(conf,"lenv","usid");
   map *schema=getMapFromMaps(conf,"database","schema");
@@ -256 +297 @@
   else
     sprintf(sqlQuery,"INSERT INTO %s.files (uuid,filename,nature,name) VALUES ('%s','%s','%s',NULL);",schema->value,uusid->value,filename,type);
-  execSql(conf,sqlQuery);
-  free(sqlQuery);
-  cleanUpResultSet(conf);
+  execSql(conf,zoo_ds_nb-1,sqlQuery);
+  free(sqlQuery);
+  cleanUpResultSet(conf,zoo_ds_nb-1);
 }
 
@@ -267 +308 @@
  */
 void recordServiceStatus(maps* conf){
+  int zoo_ds_nb=getCurrentId(conf);
   map *sid=getMapFromMaps(conf,"lenv","sid");
   map *osid=getMapFromMaps(conf,"lenv","osid");
@@ -284 +326 @@
           osid->value,
           wpsStatus[2]);
-  execSql(conf,sqlQuery);
-  free(sqlQuery);
-  cleanUpResultSet(conf);
+  execSql(conf,zoo_ds_nb-1,sqlQuery);
+  free(sqlQuery);
+  cleanUpResultSet(conf,zoo_ds_nb-1);
 }
 
@@ -296 +338 @@
  */
 void recordResponse(maps* conf,char* filename){
+  int zoo_ds_nb=getCurrentId(conf);
   FILE *file = fopen (filename, "rb");
   fseek (file, 0, SEEK_END);
@@ -308 +351 @@
   char *sqlQuery=(char*)malloc((strlen(schema->value)+flen+strlen(sid->value)+57+1)*sizeof(char));
   sprintf(sqlQuery,"INSERT INTO %s.responses (content,uuid) VALUES ($$%s$$,$$%s$$);",schema->value,tmps,sid->value);
-  execSql(conf,sqlQuery);
+  execSql(conf,zoo_ds_nb-1,sqlQuery);
   free(sqlQuery);
   free(tmps);
-  cleanUpResultSet(conf);
-}
-
-#ifdef RELY_ON_DB
+  cleanUpResultSet(conf,zoo_ds_nb-1);
+}
+
 /**
  * Update the current status of the running service.
@@ -322 +364 @@
  */
 int _updateStatus(maps* conf){
+  int zoo_ds_nb=getCurrentId(conf);
   map *sid=getMapFromMaps(conf,"lenv","usid");
   map *p=getMapFromMaps(conf,"lenv","status");
@@ -328 +371 @@
   char *sqlQuery=(char*)malloc((strlen(schema->value)+strlen(msg->value)+strlen(p->value)+strlen(sid->value)+64+1)*sizeof(char));
   sprintf(sqlQuery,"UPDATE %s.services set status=$$%s$$,message=$$%s$$ where uuid=$$%s$$;",schema->value,p->value,msg->value,sid->value);
-  fflush(stderr);
-  if( zoo_DS == NULL )
+  if( zoo_ds_nb==
+#ifdef META_DB
+      1
+#else
+      0
+#endif
+      ){
     init_sql(conf);
-  execSql(conf,sqlQuery);
-  cleanUpResultSet(conf);
+    zoo_ds_nb++;
+  }
+  execSql(conf,zoo_ds_nb-1,sqlQuery);
+  cleanUpResultSet(conf,zoo_ds_nb-1);
   free(sqlQuery);
   return 0;
@@ -345 +395 @@
  */
 char* _getStatus(maps* conf,char* pid){
+  int zoo_ds_nb=getCurrentId(conf);
   map *schema=getMapFromMaps(conf,"database","schema");
   char *sqlQuery=(char*)malloc((strlen(schema->value)+strlen(pid)+58+1)*sizeof(char));
   sprintf(sqlQuery,"select status||'|'||message from %s.services where uuid=$$%s$$;",schema->value,pid);
-  if( zoo_DS == NULL )
+  if( zoo_ds_nb==
+#ifdef META_DB
+      1
+#else
+      0
+#endif
+      ){
     init_sql(conf);
-  execSql(conf,sqlQuery);
+    zoo_ds_nb++;
+  }
+  execSql(conf,zoo_ds_nb-1,sqlQuery);
   OGRFeature  *poFeature = NULL;
   const char *tmp1;
@@ -363 +422 @@
     OGRFeature::DestroyFeature( poFeature );
   }
-  cleanUpResultSet(conf);
+  cleanUpResultSet(conf,zoo_ds_nb-1);
   free(sqlQuery);
   return (char*)tmp1;
@@ -376 +435 @@
  */
 char* _getStatusFile(maps* conf,char* pid){
+  int zoo_ds_nb=getCurrentId(conf);
   map *schema=getMapFromMaps(conf,"database","schema");
   char *sqlQuery=(char*)malloc((strlen(schema->value)+strlen(pid)+82+1)*sizeof(char));
@@ -381 +441 @@
           "select content from %s.responses where uuid=$$%s$$"
           " order by creation_time desc limit 1",schema->value,pid);
-  if( zoo_DS == NULL )
+  if( zoo_ds_nb==
+#ifdef META_DB
+      1
+#else
+      0
+#endif
+      ){
     init_sql(conf);
-  execSql(conf,sqlQuery);
+    zoo_ds_nb++;
+  }
+  execSql(conf,zoo_ds_nb-1,sqlQuery);
   OGRFeature  *poFeature = NULL;
   const char *tmp1;
   int hasRes=-1;
-  while( (poFeature = zoo_ResultSet->GetNextFeature()) != NULL ){
-    for( int iField = 0; iField < poFeature->GetFieldCount(); iField++ ){
-      if( poFeature->IsFieldSet( iField ) ){
-        tmp1=strdup(poFeature->GetFieldAsString( iField ));
-        hasRes=1;
+  if(zoo_ResultSet!=NULL){
+      while( (poFeature = zoo_ResultSet->GetNextFeature()) != NULL ){
+        for( int iField = 0; iField < poFeature->GetFieldCount(); iField++ ){
+          if( poFeature->IsFieldSet( iField ) ){
+            tmp1=strdup(poFeature->GetFieldAsString( iField ));
+            hasRes=1;
+          }
+          else
+            tmp1=NULL;
+        }
+        OGRFeature::DestroyFeature( poFeature );
       }
-      else
-        tmp1=NULL;
-    }
-    OGRFeature::DestroyFeature( poFeature );
   }
   if(hasRes<0)
     tmp1=NULL;
-  cleanUpResultSet(conf);
+  else
+    cleanUpResultSet(conf,zoo_ds_nb-1);
   free(sqlQuery);
   return (char*)tmp1;
@@ -412 +483 @@
  */
 void removeService(maps* conf,char* pid){
+  int zoo_ds_nb=getCurrentId(conf);
   map *schema=getMapFromMaps(conf,"database","schema");
   char *sqlQuery=(char*)
     malloc((strlen(pid)+strlen(schema->value)+38+1)
            *sizeof(char));
-  if( zoo_DS == NULL )
+  if( zoo_ds_nb==
+#ifdef META_DB
+      1
+#else
+      0
+#endif
+      ){
     init_sql(conf);
+    zoo_ds_nb++;
+  }
   sprintf(sqlQuery,
           "DELETE FROM %s.services where uuid=$$%s$$;",
           schema->value,pid);
-  execSql(conf,sqlQuery);
-  cleanUpResultSet(conf);
-  close_sql(conf);
+  execSql(conf,zoo_ds_nb-1,sqlQuery);
+  cleanUpResultSet(conf,zoo_ds_nb-1);
+  close_sql(conf,zoo_ds_nb-1);
   free(sqlQuery);
   end_sql();
@@ -434 +514 @@
  */
 void unhandleStatus(maps* conf){
+  int zoo_ds_nb=getCurrentId(conf);
   map *schema=getMapFromMaps(conf,"database","schema");
   map *sid=getMapFromMaps(conf,"lenv","usid");
@@ -447 +528 @@
           " where uuid=$$%s$$;",
           schema->value,(fstate!=NULL?fstate->value:"Failed"),sid->value);
-  execSql(conf,sqlQuery);
-  cleanUpResultSet(conf);
-  close_sql(conf);
+  execSql(conf,zoo_ds_nb-1,sqlQuery);
+  cleanUpResultSet(conf,zoo_ds_nb-1);
+  close_sql(conf,zoo_ds_nb-1);
   free(sqlQuery);
   end_sql();
@@ -462 +543 @@
  */
 char* getStatusId(maps* conf,char* pid){
+  int zoo_ds_nb=getCurrentId(conf);
   map *schema=getMapFromMaps(conf,"database","schema");
   char *sqlQuery=(char*)malloc((strlen(schema->value)+strlen(pid)+58+1)*sizeof(char));
@@ -467 +549 @@
           "select osid from %s.services where uuid=$$%s$$",
           schema->value,pid);
-  if( zoo_DS == NULL )
+  if( zoo_ds_nb==0 ){
     init_sql(conf);
-  execSql(conf,sqlQuery);
+    zoo_ds_nb++;
+  }
+  execSql(conf,zoo_ds_nb-1,sqlQuery);
   OGRFeature  *poFeature = NULL;
   const char *tmp1;
@@ -486 +570 @@
     tmp1=NULL;
   free(sqlQuery);
+  cleanUpResultSet(conf,zoo_ds_nb-1);
   return (char*)tmp1;
 }
@@ -496 +581 @@
  */
 void readFinalRes(maps* conf,char* pid,map* statusInfo){
+  int zoo_ds_nb=getCurrentId(conf);
   map *schema=getMapFromMaps(conf,"database","schema");
   char *sqlQuery=(char*)malloc((strlen(schema->value)+strlen(pid)+58+1)*sizeof(char));
@@ -503 +589 @@
   if( zoo_DS == NULL )
     init_sql(conf);
-  execSql(conf,sqlQuery);
+  execSql(conf,zoo_ds_nb-1,sqlQuery);
   OGRFeature  *poFeature = NULL;
   int hasRes=-1;
@@ -531 +617 @@
 int isRunning(maps* conf,char* pid){
   int res=0;
+  int zoo_ds_nb=getCurrentId(conf);
   map *schema=getMapFromMaps(conf,"database","schema");
   char *sqlQuery=(char*)malloc((strlen(schema->value)+strlen(pid)+73+1)*sizeof(char));
   sprintf(sqlQuery,"select count(*) as t from %s.services where uuid=$$%s$$ and end_time is null;",schema->value,pid);
-  if( zoo_DS == NULL )
+  if( zoo_ds_nb == 0 ){
     init_sql(conf);
-  execSql(conf,sqlQuery);
+    zoo_ds_nb++;
+  }
+  execSql(conf,zoo_ds_nb-1,sqlQuery);
   OGRFeature  *poFeature = NULL;
   const char *tmp1;
@@ -549 +638 @@
     OGRFeature::DestroyFeature( poFeature );
   }
-  cleanUpResultSet(conf);
+  cleanUpResultSet(conf,zoo_ds_nb-1);
   free(sqlQuery);
   return res;

branches/prototype-v0/zoo-project/zoo-kernel/sqlapi.h

@@ -42 +42 @@
 #ifdef META_DB
   ZOO_DLL_EXPORT char* _createInitString(maps*,const char*);
-  ZOO_DLL_EXPORT void _init_sql(maps*,const char*);
-  ZOO_DLL_EXPORT OGRLayer *fetchSql(maps*,const char*);
+  ZOO_DLL_EXPORT int _init_sql(maps*,const char*);
+  ZOO_DLL_EXPORT OGRLayer *fetchSql(maps*,int,const char*);
+  ZOO_DLL_EXPORT void cleanFetchSql(maps*,int,OGRLayer*);
 #endif
 #ifdef RELY_ON_DB
-  ZOO_DLL_EXPORT void init_sql(maps*);
-  ZOO_DLL_EXPORT void close_sql(maps*);
-  ZOO_DLL_EXPORT int execSql(maps*,const char*);
+  ZOO_DLL_EXPORT int init_sql(maps*);
+  ZOO_DLL_EXPORT void close_sql(maps*,int);
+  ZOO_DLL_EXPORT int execSql(maps*,int,const char*);
   ZOO_DLL_EXPORT void recordStoredFile(maps*,const char*,const char*,const char*);
   ZOO_DLL_EXPORT void recordServiceStatus(maps*);
@@ -56 +57 @@
   ZOO_DLL_EXPORT char* getStatusId(maps*,char*);
   ZOO_DLL_EXPORT void removeService(maps*,char*);
+  ZOO_DLL_EXPORT void end_sql();
 #endif
 

branches/prototype-v0/zoo-project/zoo-kernel/sshapi.c

@@ -9 +9 @@
  * by the French National Research Agency
  *
- * permission is hereby granted, free of charge, to any person obtaining a copy
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
  * in the Software without restriction, including without limitation the rights
@@ -249 +249 @@
  * @return true in case of success, false if failure occured
  */
-size_t ssh_file_exists(maps* conf,const char* targetPath){
+size_t ssh_file_exists(maps* conf,const char* targetPath,int cnt){
   size_t result=-1;
-  int cnt=ssh_get_cnt(conf);
   if(cnt>0)
     cnt-=1;
@@ -303 +302 @@
  * @return true in case of success, false if failure occured
  */
-bool ssh_copy(maps* conf,const char* localPath,const char* targetPath){
+bool ssh_copy(maps* conf,const char* localPath,const char* targetPath,int cnt){
   char mem[1024 * 1000];
   size_t nread;
@@ -310 +309 @@
   long total = 0;
   int duration;
-  int cnt=ssh_get_cnt(conf);
   int rc;
   LIBSSH2_SFTP_HANDLE *sftp_handle;
@@ -323 +321 @@
   if (!local) {
     fprintf(stderr, "Can't open local file %s\n", localPath);
-    return -1;
+    return false;
   }
 
@@ -382 +380 @@
   duration = (int)(time(NULL)-start);
   fclose(local);
-  libssh2_sftp_close(sftp_handle);
+  libssh2_sftp_close_handle(sftp_handle);
 
   libssh2_sftp_shutdown(sessions[cnt]->sftp_session);
@@ -396 +394 @@
  * @return true in case of success, false if failure occured
  */
-int ssh_fetch(maps* conf,const char* localPath,const char* targetPath){
+int ssh_fetch(maps* conf,const char* localPath,const char* targetPath,int cnt){
   char mem[1024];
   size_t nread;
@@ -403 +401 @@
   long total = 0;
   int duration;
-  int cnt=ssh_get_cnt(conf);
   int rc;
   LIBSSH2_SFTP_HANDLE *sftp_handle;
@@ -428 +425 @@
         if (!sftp_handle) {
             if (libssh2_session_last_errno(sessions[cnt]->session) != LIBSSH2_ERROR_EAGAIN) {
-
                 fprintf(stderr, "Unable to open file with SFTP\n");
                 return -1;
@@ -443 +439 @@
         do {
             rc = libssh2_sftp_read(sftp_handle, mem, sizeof(mem));
-            fprintf(stderr, "libssh2_sftp_read returned %d\n",
-                    rc);
- 
+            /*fprintf(stderr, "libssh2_sftp_read returned %d\n",
+              rc);*/
             if(rc > 0) {
-                write(2, mem, rc);
+              //write(2, mem, rc);
                 fwrite(mem, rc, 1, local);
             }
@@ -479 +474 @@
   duration = (int)(time(NULL)-start);
   fclose(local);
-  libssh2_sftp_close(sftp_handle);
+  libssh2_sftp_close_handle(sftp_handle);
 
   libssh2_sftp_shutdown(sessions[cnt]->sftp_session);
@@ -491 +486 @@
  * @return bytecount resulting from the execution of the command
  */
-int ssh_exec(maps* conf,const char* command){
-  int cnt=ssh_get_cnt(conf);
+int ssh_exec(maps* conf,const char* command,int cnt){
   LIBSSH2_CHANNEL *channel;
   int rc;
@@ -571 +565 @@
   while (libssh2_session_disconnect(con->session, "Normal Shutdown, Thank you for using the ZOO-Project sshapi")
          == LIBSSH2_ERROR_EAGAIN);
-  libssh2_session_free(con->session);
 #ifdef WIN32
   closesocket(con->sock_id);
@@ -577 +570 @@
   close(con->sock_id);
 #endif
+  libssh2_session_free(con->session);
   return true;
 }
@@ -596 +590 @@
   return true;
 }
+
+bool addToUploadQueue(maps** conf,maps* input){
+  map* queueMap=getMapFromMaps(*conf,"uploadQueue","length");
+  if(queueMap==NULL){
+    maps* queueMaps=createMaps("uploadQueue");
+    queueMaps->content=createMap("length","0");
+    addMapsToMaps(conf,queueMaps);
+    freeMaps(&queueMaps);
+    free(queueMaps);
+    queueMap=getMapFromMaps(*conf,"uploadQueue","length");
+  }
+  maps* queueMaps=getMaps(*conf,"uploadQueue");
+  int queueIndex=atoi(queueMap->value);
+  if(input!=NULL){
+    if(getMap(input->content,"cache_file")!=NULL){
+      map* length=getMap(input->content,"length");
+      if(length==NULL){
+        addToMap(input->content,"length","1");
+        length=getMap(input->content,"length");
+      }
+      int len=atoi(length->value);
+      int i=0;
+      for(i=0;i<len;i++){
+        
+        map* tmp[2]={getMapArray(input->content,"localPath",i),
+                     getMapArray(input->content,"targetPath",i)};
+
+        setMapArray(queueMaps->content,"input",queueIndex,input->name);
+        setMapArray(queueMaps->content,"localPath",queueIndex,tmp[0]->value);
+        setMapArray(queueMaps->content,"targetPath",queueIndex,tmp[1]->value);
+        queueIndex+=1;
+      }
+    }
+  }
+#ifdef DEBUG  
+  fprintf(stderr,"%s %d\n",__FILE__,__LINE__);
+  fflush(stderr);
+  dumpMaps(queueMaps);
+  fprintf(stderr,"%s %d\n",__FILE__,__LINE__);
+  fflush(stderr);
+  dumpMaps(*conf);
+  fprintf(stderr,"%s %d\n",__FILE__,__LINE__);
+  fflush(stderr);
+#endif
+  return true;
+}
+
+bool runUpload(maps** conf){
+  SSHCON *test=ssh_connect(*conf);
+  if(test==NULL){
+    return false;
+  }
+#ifdef DEBUG
+  fprintf(stderr,"%s %d\n",__FILE__,__LINE__);
+  fflush(stderr);
+  dumpMaps(getMaps(*conf,"uploadQueue"));
+  fprintf(stderr,"%s %d\n",__FILE__,__LINE__);
+  fflush(stderr);
+#endif
+  map* queueLengthMap=getMapFromMaps(*conf,"uploadQueue","length");
+  maps* queueMaps=getMaps(*conf,"uploadQueue");
+  if(queueLengthMap!=NULL){
+    int cnt=atoi(queueLengthMap->value);
+    int i=0;
+    for(i=0;i<cnt;i++){
+      map* argv[3]={
+        getMapArray(queueMaps->content,"input",i),
+        getMapArray(queueMaps->content,"localPath",i),
+        getMapArray(queueMaps->content,"targetPath",i)
+      };
+      fprintf(stderr,"%s %d %s %s\n",__FILE__,__LINE__,argv[1]->value,argv[2]->value);
+      ssh_copy(*conf,argv[1]->value,argv[2]->value,ssh_get_cnt(*conf));
+    }    
+  }
+  return true; 
+}

branches/prototype-v0/zoo-project/zoo-kernel/sshapi.h

@@ -85 +85 @@
   
   ZOO_DLL_EXPORT SSHCON *ssh_connect(maps*);
-  ZOO_DLL_EXPORT bool ssh_copy(maps*,const char*,const char*);
-  ZOO_DLL_EXPORT int ssh_fetch(maps*,const char*,const char*);
-  ZOO_DLL_EXPORT int ssh_exec(maps*,const char*);
+  ZOO_DLL_EXPORT bool ssh_copy(maps*,const char*,const char*,int);
+  ZOO_DLL_EXPORT int ssh_get_cnt(maps*);
+  ZOO_DLL_EXPORT int ssh_fetch(maps*,const char*,const char*,int);
+  ZOO_DLL_EXPORT int ssh_exec(maps*,const char*,int);
   ZOO_DLL_EXPORT bool ssh_close_session(maps*,SSHCON*);
   ZOO_DLL_EXPORT bool ssh_close(maps*);
+  ZOO_DLL_EXPORT bool addToUploadQueue(maps**,maps*);
+  ZOO_DLL_EXPORT bool runUpload(maps**);
   
 #ifdef __cplusplus

branches/prototype-v0/zoo-project/zoo-kernel/ulinet.c

@@ -70 +70 @@
 /**
  * In case of presence of "Set-Cookie" in the headers red, store the cookie
- * identifier in CCookie
+ * identifier in cookie
  *
  * @param buffer the buffer to read
@@ -77 +77 @@
  * @param data the _HINTERNET structure to write in
  * @return the size red, -1 if buffer is NULL
- * @see CCookie
+ * @see cookie
  */
 size_t header_write_data(void *buffer, size_t size, size_t nmemb, void *data){
   if(strncmp("Set-Cookie: ",(char*)buffer,12)==0){
     int i;
-    char env[256];
-    char path[256];
-    char domain[256];
     char* tmp;
     for(i=0;i<12;i++)
@@ -92 +89 @@
         ;
 #endif
-    sscanf((char*)buffer,"%s; path=%s; domain=%s",env,path,domain);
+    tmp=strtok(buffer,";");
+    int cnt=0;
     _HINTERNET *psInternet=(_HINTERNET *)data;
-    tmp=strcat(env,CCookie[psInternet->id][0]);
-#ifdef MSG_LAF_OUT
-    printf("\n**Cookie env : [%s] , path : [%s], domain : [%s]**\n",env,path,domain);
-    printf("buffer : %d (%s) (%s) (%s)\n",(buffer==NULL),buffer,tmp,CCookie);
-#endif
-    strcpy(CCookie[psInternet->id][0],tmp);
+    if(tmp!=NULL && psInternet!=NULL){
+      psInternet->cookie=(char*)malloc(sizeof(char)*(strlen(tmp)+1));
+      sprintf(psInternet->cookie,"%s",tmp);
+    }
   }
   return size * nmemb;//write_data_into(buffer,size,nmemb,data,HEADER);
@@ -340 +336 @@
     if(handle.url!=NULL)
       free(handle.url);
-    free(handle.mimeType);
-    handle.mimeType = NULL;
+    if(handle.mimeType!=NULL)
+      free(handle.mimeType);
+    if(handle.cookie!=NULL)
+      free(handle.cookie);
   }
   if(handle0->handle)
@@ -371 +369 @@
   hInternet->ihandle[hInternet->nb].url = NULL;
   hInternet->ihandle[hInternet->nb].mimeType = NULL;
+  hInternet->ihandle[hInternet->nb].cookie = NULL;
   hInternet->ihandle[hInternet->nb].nDataLen = 0;
   hInternet->ihandle[hInternet->nb].id = hInternet->nb;
@@ -376 +375 @@
   hInternet->ihandle[hInternet->nb].pabyData = NULL;
   hInternet->ihandle[hInternet->nb].post = NULL;
-
+  
   curl_easy_setopt(hInternet->ihandle[hInternet->nb].handle, CURLOPT_COOKIEFILE, "ALL");
 #ifndef TIGER
@@ -475 +474 @@
     curl_multi_remove_handle(hInternet->handle, hInternet->ihandle[i].handle);
     curl_easy_cleanup(hInternet->ihandle[i].handle);
+    //fprintf(stderr,"%s %d %s \n",__FILE__,__LINE__,hInternet->ihandle[i].mimeType);
+    //fprintf(stderr,"%s %d %s \n",__FILE__,__LINE__,hInternet->ihandle[i].pabyData);
   }
   return 0;
@@ -480 +481 @@
 
 /**
- * Initialize the CCookie for a specific index (hInternet.nb)
- *
- * @param hInternet the HINTERNET structure to know the CCookie index to reset
+ * Initialize the cookie for a specific index (hInternet.nb)
+ *
+ * @param hInternet the HINTERNET structure to know the cookie index to reset
  * @return 1
  * @see HINTERNET
  */
 int freeCookieList(HINTERNET hInternet){
-  memset(&CCookie[hInternet.nb][0],0,1024);
+  hInternet.ihandle[hInternet.nb].cookie=strdup("");
 #ifndef TIGER
   curl_easy_setopt(hInternet.ihandle[hInternet.nb].handle, CURLOPT_COOKIELIST, "ALL");
@@ -536 +537 @@
   }
 
-  CCookie[hInternet.id][0]=0;
-
   if( *lpdwNumberOfBytesRead < dwDataSize )
       return 0;

branches/prototype-v0/zoo-project/zoo-kernel/ulinet.h

@@ -54 +54 @@
 #define MAX_REQ 50
 
-#ifdef _ULINET
-static char CCookie[MAX_REQ][1024];
-#else
-/**
- * The cookies found
- */
-extern char CCookie[MAX_REQ][1024];
-#endif
-
 #ifdef __cplusplus
 extern "C" {
@@ -88 +79 @@
     char *mimeType; //!< the mimeType returned by the server
     char *post; //!< the potential POST XML content
+    char* cookie; //!< The potential Cookie returned by the server
     int hasCacheFile; //!< 1 if we used a cache file
     int nDataLen; //!< the length of the downloaded content

branches/prototype-v0/zoo-project/zoo-kernel/zoo_service_loader.c

@@ -102 +102 @@
 #endif
 
+#include "service_json.h"
+#include "service_callback.h"
+
 #include <dirent.h>
 #include <signal.h>
@@ -158 +161 @@
 
 #ifdef WIN32
-  #ifndef PROGRAMNAME
-    #define PROGRAMNAME "zoo_loader.cgi"
-  #endif
+#ifndef PROGRAMNAME
+#define PROGRAMNAME "zoo_loader.cgi"
+#endif
 #endif
 
@@ -213 +216 @@
   fclose (f2);
   fclose (f3);
+  free(tmps1);
   return 1;
 }
@@ -233 +237 @@
  */
 int
-recursReaddirF ( maps * m, registry *r, xmlNodePtr n, char *conf_dir, 
+recursReaddirF ( maps * m, registry *r, xmlDocPtr doc, xmlNodePtr n, char *conf_dir, 
                  char *prefix, int saved_stdout, int level, 
-                 void (func) (registry *, maps *, xmlNodePtr, service *) )
+                 void (func) (registry *, maps *, xmlDocPtr, xmlNodePtr, service *) )
 {
   struct dirent *dp;
@@ -282 +286 @@
             setMapInMaps (m, "lenv", "level", levels1);
             res =
-              recursReaddirF (m, r, n, tmp, prefix, saved_stdout, level + 1,
+              recursReaddirF (m, r, doc, n, tmp, prefix, saved_stdout, level + 1,
                               func);
             sprintf (levels1, "%d", level);
@@ -320 +324 @@
                   return -1;
                 }
-  #ifndef DEBUG
+  #ifdef DEBUG
               fprintf (stderr, "#################\n%s\n#################\n",
                        tmps1);
@@ -346 +350 @@
   #endif
               inheritance(r,&s1);
-              func (r, m, n, s1);
+              func (r, m, doc, n, s1);
               freeService (&s1);
               free (s1);
@@ -949 +953 @@
 #endif
 
+  
   map *r_inputs = NULL;
   map *request_inputs = *inputs;
+  //fprintf(stderr,"%s \n",json_object_to_json_string_ext(mapToJson(request_inputs),JSON_C_TO_STRING_PLAIN));
+  
 #ifdef IGNORE_METAPATH
   addToMap(request_inputs, "metapath", "");
@@ -1305 +1312 @@
             }
             inheritance(zooRegistry, &svc);
-            printGetCapabilitiesForProcess(zooRegistry, m, n, svc);
+            printGetCapabilitiesForProcess(zooRegistry, m, doc, n, svc);
             freeService(&svc);
             free(svc);                             
@@ -1314 +1321 @@
 
       if (int res =               
-          recursReaddirF (m, zooRegistry, n, conf_dir, NULL, saved_stdout, 0,
+          recursReaddirF (m, zooRegistry, doc, n, conf_dir, NULL, saved_stdout, 0,
                           printGetCapabilitiesForProcess) < 0)
         {
@@ -1331 +1338 @@
       dup2 (saved_stdout, fileno (stdout));
 #ifdef META_DB
-      fetchServicesFromDb(zooRegistry,m,n,printGetCapabilitiesForProcess);
+      fetchServicesFromDb(zooRegistry,m,doc,n,printGetCapabilitiesForProcess,1);
+      fprintf(stderr,"************************* %s %d\n\n",__FILE__,__LINE__);
+      close_sql(m,0);
 #endif      
       printDocument (m, doc, getpid ());
@@ -1353 +1362 @@
           runGetStatus(m,r_inputs->value,REQUEST);
           freeMaps (&m);
-          free (m);
+          free(m);
           if(zooRegistry!=NULL){
             freeRegistry(&zooRegistry);
@@ -1429 +1438 @@
                       }
                       inheritance(zooRegistry, &svc);
-                      printDescribeProcessForProcess(zooRegistry, m, n, svc);
+#ifdef USE_HPC
+                      addNestedOutputs(&svc);
+#endif
+
+                      printDescribeProcessForProcess(zooRegistry, m, doc, n, svc);
                       freeService(&svc);
                       free(svc);                             
@@ -1438 +1451 @@
   
                 if (int res =
-                    recursReaddirF (m, zooRegistry, n, conf_dir, NULL, saved_stdout, 0,
+                    recursReaddirF (m, zooRegistry, doc, n, conf_dir, NULL, saved_stdout, 0,
                                     printDescribeProcessForProcess) < 0)
                   return res;
 #ifdef META_DB
-                fetchServicesFromDb(zooRegistry,m,n,printDescribeProcessForProcess);
+                fetchServicesFromDb(zooRegistry,m,doc,n,printDescribeProcessForProcess,0);
+                close_sql(m,0);
 #endif      
 
@@ -1461 +1475 @@
                       {
 #ifdef META_DB                  
-                        service* s2=extractServiceFromDb(m,import->name);
-                        fprintf(stderr,"%s %d \n",__FILE__,__LINE__);
-                        fflush(stderr);
+                        service* s2=extractServiceFromDb(m,import->name,0);
                         if(s2==NULL){
 #endif
@@ -1500 +1512 @@
                           dumpService (s1);
 #endif
-
                           inheritance(zooRegistry,&s1);
-                          printDescribeProcessForProcess (zooRegistry,m, n, s1);
+#ifdef USE_HPC
+                          addNestedOutputs(&s1);
+#endif
+                          printDescribeProcessForProcess (zooRegistry, m, doc, n, s1);
                           freeService (&s1);
                           free (s1);
@@ -1520 +1534 @@
                           addToMap (request_inputs, "metapath", tmpMap->value);
                         map *tmpMapI = getMapFromMaps (m, "lenv", "Identifier");
-
 #ifdef META_DB
-                        service* s2=extractServiceFromDb(m,tmpMapI->name);
-                        fprintf(stderr,"%s %d \n",__FILE__,__LINE__);
-                        fflush(stderr);
+                        service* s2=extractServiceFromDb(m,tmpMapI->name,0);
                         if(s2==NULL){
 #endif
@@ -1567 +1578 @@
 #endif
                           inheritance(zooRegistry,&s1);
-                          printDescribeProcessForProcess (zooRegistry,m, n, s1);
+#ifdef USE_HPC
+                          addNestedOutputs(&s1);
+#endif
+                          printDescribeProcessForProcess (zooRegistry, m, doc, n, s1);
                           freeService (&s1);
                           free (s1);
@@ -1580 +1594 @@
                     else
                       {
-                        fprintf(stderr,"%s %d \n",__FILE__,__LINE__);
-                        fflush(stderr);
 #ifdef META_DB
                         _init_sql(m,"metadb");
-                        service* s2=extractServiceFromDb(m,corig);
+                        //FAILED CONNECTING DB
+                        if(getMapFromMaps(m,"lenv","dbIssue")!=NULL){
+                          fprintf(stderr,"ERROR CONNECTING METADB");
+                        }
+                        service* s2=extractServiceFromDb(m,corig,0);
                         if(s2!=NULL){
-                          fprintf(stderr,"%s %d \n",__FILE__,__LINE__);
-                          fflush(stderr);
                           inheritance(zooRegistry,&s2);
-                          printDescribeProcessForProcess (zooRegistry,m, n, s2);
+#ifdef USE_HPC
+                          addNestedOutputs(&s2);
+#endif
+                          printDescribeProcessForProcess (zooRegistry,m, doc, n, s2);
                           freeService (&s2);
                           free (s2);
@@ -1664 +1681 @@
 #endif
                                   inheritance(zooRegistry,&s1);
-                                  printDescribeProcessForProcess (zooRegistry,m, n, s1);
+#ifdef USE_HPC
+                                  addNestedOutputs(&s1);
+#endif
+                                  printDescribeProcessForProcess (zooRegistry,m, doc, n, s1);
                                   freeService (&s1);
                                   free (s1);
@@ -1725 +1745 @@
             free (SERVICE_URL);
             fflush (stdout);
+#ifdef META_DB
+            close_sql(m,0);
+      //end_sql();
+#endif
             return 0;
           }
@@ -1803 +1827 @@
   }
   s1 = NULL;
-  s1 = (service *) malloc (SERVICE_SIZE);
-  if (s1 == NULL)
-    {
-      freeMaps (&m);
-      free (m);
-      if(zooRegistry!=NULL){
-        freeRegistry(&zooRegistry);
-        free(zooRegistry);
-      }
-      free (REQUEST);
-      free (SERVICE_URL);
-      return errorException (m, _("Unable to allocate memory"),
-                             "InternalError", NULL);
-    }
-
+  if(postRequest!=NULL)
+    setMapInMaps (m, "lenv", "xrequest", postRequest->value);
+  
   r_inputs = getMap (request_inputs, "Identifier");
-
   map* import = getMapFromMaps (m, IMPORTSERVICE, r_inputs->value); 
   if (import != NULL && import->value != NULL) { 
@@ -1848 +1859 @@
 
   r_inputs = getMapFromMaps (m, "lenv", "Identifier");
+  
+#ifdef META_DB
+  int metadb_id=_init_sql(m,"metadb");
+  fprintf(stderr,"CONNECTING METADB!\n");
+  //FAILED CONNECTING DB
+  if(getMapFromMaps(m,"lenv","dbIssue")!=NULL){
+    fprintf(stderr,"ERROR CONNECTING METADB\n");
+  }
+  s1=extractServiceFromDb(m,r_inputs->value,0);
+  //close_sql(m,0);
+  if(s1!=NULL){
+    inheritance(zooRegistry,&s1);
+#ifdef USE_HPC
+    addNestedOutputs(&s1);
+#endif
+    if(zooRegistry!=NULL){
+      freeRegistry(&zooRegistry);
+      free(zooRegistry);
+    }
+  }else /* Not found in MetaDB */{
+#endif
+  s1 = (service *) malloc (SERVICE_SIZE);
+  if (s1 == NULL)
+    {
+      freeMaps (&m);
+      free (m);
+      if(zooRegistry!=NULL){
+        freeRegistry(&zooRegistry);
+        free(zooRegistry);
+      }
+      free (REQUEST);
+      free (SERVICE_URL);
+      return errorException (m, _("Unable to allocate memory"),
+                             "InternalError", NULL);
+    }
+
   int saved_stdout = dup (fileno (stdout));
   dup2 (fileno (stderr), fileno (stdout));
   t = readServiceFile (m, tmps1, &s1, r_inputs->value);
   inheritance(zooRegistry,&s1);
+#ifdef USE_HPC
+  addNestedOutputs(&s1);
+#endif
   if(zooRegistry!=NULL){
     freeRegistry(&zooRegistry);
@@ -1875 +1925 @@
     }
   close (saved_stdout);
-
+#ifdef META_DB
+  }
+#endif
+  
 #ifdef DEBUG
   dumpService (s1);
@@ -1912 +1965 @@
     return 0;
   }
-
+  //InternetCloseHandle (&hInternet);
+  
   // Define each env variable in runing environment
   maps *curs = getMaps (m, "env");
@@ -2052 +2106 @@
   int cpid = getpid ();
 
+  // Create a map containing a copy of the request map
+  maps *_tmpMaps = createMaps("request");
+  addMapToMap(&_tmpMaps->content,request_inputs);
+  addMapsToMaps (&m, _tmpMaps);
+  freeMaps (&_tmpMaps);
+  free (_tmpMaps);
   /**
    * Initialize the specific [lenv] section which contains runtime variables:
@@ -2072 +2132 @@
    *
    */
-  maps *_tmpMaps = createMaps("lenv");
+  _tmpMaps = createMaps("lenv");
   char tmpBuff[100];
   struct ztimeval tp;
@@ -2182 +2242 @@
 #endif
   int ei = 1;
-  char *s = 
+  char **orig = 
 #ifdef WIN32
-    GetEnvironmentStrings();
+    GetEnvironmentStrings()
 #else
-    *environ;
-#endif
+    environ
+#endif
+    ;
+  char *s=*orig;
   _tmpMaps = createMaps("renv");
   for (; s; ei++) {
     char* tmpName=zStrdup(s);
     char* tmpValue=strstr(s,"=")+1;
-    tmpName[strlen(tmpName)-strlen(tmpValue)-1]=0;
+    char* tmpName1=(char*)malloc((1+(strlen(tmpName)-strlen(tmpValue)))*sizeof(char));
+    snprintf(tmpName1,(strlen(tmpName)-strlen(tmpValue)),"%s",tmpName);
     if(_tmpMaps->content == NULL)
-      _tmpMaps->content = createMap (tmpName,tmpValue);
+      _tmpMaps->content = createMap (tmpName1,tmpValue);
     else
-      addToMap (_tmpMaps->content,tmpName,tmpValue);
+      addToMap (_tmpMaps->content,tmpName1,tmpValue);
     free(tmpName);
-    s = *(environ+ei);
+    free(tmpName1);
+    s = *(orig+ei);
   }
   addMapsToMaps (&m, _tmpMaps);
@@ -2228 +2292 @@
   }
 #endif
+  fprintf(stderr,"************************* %s %d \n\n",__FILE__,__LINE__);
+  invokeCallback(m,NULL,NULL,0,0);
+  fprintf(stderr,"************************* %s %d \n\n",__FILE__,__LINE__);
 
   char *fbkp, *fbkpid, *fbkpres, *fbkp1, *flog;
@@ -2236 +2303 @@
   if (status == NULLMAP)
     {
+      /*        hInternet = InternetOpen (
+#ifndef WIN32
+                                  (LPCTSTR)
+#endif
+                                  "ZooWPSClient\0",
+                                  INTERNET_OPEN_TYPE_PRECONFIG, NULL, NULL, 0);*/
+
       if(validateRequest(&m,s1,request_inputs, &request_input_real_format,&request_output_real_format,&hInternet)<0){
         freeService (&s1);
@@ -2251 +2325 @@
         return -1;
       }
+      fprintf(stderr,"*************************\n\n");
+      //fprintf(stderr,"%s \n",json_object_to_json_string_ext(mapsToJson(request_input_real_format),JSON_C_TO_STRING_PLAIN));
+      fprintf(stderr,"*************************\n\n");
       loadServiceAndRun (&m, s1, request_inputs, &request_input_real_format,
                          &request_output_real_format, &eres);
@@ -2300 +2377 @@
           int cpid = atoi (tmpm->value);
           r_inputs = getMapFromMaps (m, "main", "tmpPath");
+          setMapInMaps (m, "lenv", "async","true");
           map* r_inputs1 = createMap("ServiceName", s1->name);
 
@@ -2396 +2474 @@
           f1 = freopen (fbkp1, "w+", stdout);
 
+          map* serviceTypeMap=getMap(s1->content,"serviceType");
+          if(serviceTypeMap!=NULL)
+            setMapInMaps (m, "lenv", "serviceType", serviceTypeMap->value);
+
+          char *flenv =
+            (char *)
+            malloc ((strlen (r_inputs->value) + 
+                     strlen (usid->value) + 12) * sizeof (char));
+          sprintf (flenv, "%s/%s_lenv.cfg", r_inputs->value, usid->value);
+          maps* lenvMaps=getMaps(m,"lenv");
+          dumpMapsToFile(lenvMaps,flenv,0);
+          free(flenv);
+
+          fprintf(stderr,"************************* %s %d \n\n",__FILE__,__LINE__);
+          invokeCallback(m,request_input_real_format,NULL,1,0);
+          fprintf(stderr,"************************* %s %d \n\n",__FILE__,__LINE__);
           if(validateRequest(&m,s1,request_inputs, &request_input_real_format,&request_output_real_format,&hInternet)<0){
             freeService (&s1);
@@ -2419 +2513 @@
             return -1;
           }
+          setMapInMaps(m,"lenv","ds_nb","1");
           loadServiceAndRun (&m, s1, request_inputs,
                              &request_input_real_format,
@@ -2435 +2530 @@
     }
 
-  //#ifdef DEBUG
+#ifdef DEBUG
+  fprintf (stderr, "RUN IN BACKGROUND MODE %s %d \n",__FILE__,__LINE__);
   dumpMaps (request_output_real_format);
-  //#endif
-  //sleep(120);
+  fprintf (stderr, "RUN IN BACKGROUND MODE %s %d \n",__FILE__,__LINE__);
+#endif
   if (eres != -1)
     outputResponse (s1, request_input_real_format,
@@ -2462 +2558 @@
     {
       fclose (stdout);
-      fclose (stderr);
 
       fclose (f0);
@@ -2486 +2581 @@
 #else
       recordResponse(m,fbkp1);
+      fprintf(stderr,"************************* %s %d \n\n",__FILE__,__LINE__);
+      invokeCallback(m,NULL,request_output_real_format,5,1);
+      fprintf(stderr,"************************* %s %d \n\n",__FILE__,__LINE__);
 #endif
       freeMaps(&bmap);
@@ -2492 +2590 @@
       unlink (flog);
       unhandleStatus (m);
+#ifdef META_DB
+      close_sql(m,0);
+      //end_sql();
+#endif
       free(fbkpid);
       free(fbkpres); 
@@ -2499 +2601 @@
       if(cgiSid!=NULL)
         free(cgiSid);
-    }
-
+      //InternetCloseHandle (&hInternet);  
+      fprintf (stderr, "RUN IN BACKGROUND MODE %s %d \n",__FILE__,__LINE__);
+      fflush(stderr);
+      fclose (stderr);
+    }
+  else{
+    //InternetCloseHandle (&hInternet);  
+#ifdef META_DB
+    //close_sql(m,0);
+#endif
+  }
+  
   freeService (&s1);
   free (s1);