JSOC_Documentation: base/sums/apps/xsum_svc

00001 /* xsum_svc_proc.c: Server side procedures
00002  *
00003  * These are the function that are called by sum_svc when it gets a 
00004  * message from a client. 
00005 */
00006 #include <SUM.h>
00007 #include <sys/time.h>
00008 #include <sys/errno.h>
00009 #include <rpc/rpc.h>
00010 #include <soi_key.h>
00011 #include <keyU.h>
00012 #include <soi_error.h>
00013 #include <sum_rpc.h>
00014 #include "serverdefs.h"
00015 #include "drmssite_info.h"
00016 
00017 extern int errno;
00018 extern int write_log(const char *fmt, ...);
00019 extern void StartTimer(int n);
00020 extern float StopTimer(int n);
00021 extern CLIENT *current_client, *clnttape, *clnttape_old;
00022 extern SVCXPRT *glb_transp;
00023 extern uint32_t rinfo;
00024 extern uint32_t sumprog;
00025 extern uint32_t sumvers;
00026 extern int debugflg;
00027 extern int rrid;
00028 extern float ftmp;
00029 extern char logname[];
00030 extern char jsoc_machine[];
00031 static int NO_OPEN = 0;
00032 static char callername[MAX_STR];
00033 static char nametmp[80];
00034 static int numSUM;
00035 
00036 void write_time();
00037 void logkey();
00038 
00039 /*********************************************************/
00040 /* Return ptr to "mmm dd hh:mm:ss". Uses global datestr[]. 
00041 */
00042 static char *datestring()
00043 {
00044   static char datestr[32];
00045   struct timeval tvalr;
00046   struct tm *t_ptr;
00047 
00048   gettimeofday(&tvalr, NULL);
00049   t_ptr = localtime((const time_t *)&tvalr);
00050   sprintf(datestr, "%s", asctime(t_ptr));
00051   datestr[19] = (char)NULL;
00052   return(&datestr[4]);          /* isolate the mmm dd hh:mm:ss */
00053 }
00054 
00055 static KEY *retlist;        /* must be static for svc dispatch rte */
00056 static SUMOPENED *sumopened_hdr = NULL; /* linked list of active opens*/
00057 
00058 /* These are the PROGNUM called in sum_svc. They're called by 
00059  * sumprog_1() in sum_svc.c
00060 */
00061 
00062 /* Get client handle for return of result and store in glb vrbl current_client.
00063 */
00064 CLIENT *set_client_handle(uint32_t prognum, uint32_t versnum)
00065 {
00066   static CLIENT *client;
00067   struct sockaddr_in *sock_in;
00068   int sock = RPC_ANYSOCK;
00069 
00070     /* set up a client handle for eventual ret of the result with a call
00071      * to the requestor's local daemon. But
00072      * first must translate into caller host info to call the cliens back.
00073     */
00074     sock_in = svc_getcaller(glb_transp);/* get caller socket info */
00075     sock_in->sin_port = 0;  /* makes clnttcp_create consult yp */
00076     client = clnttcp_create(sock_in,prognum,versnum,&sock,0,0);
00077     if(!client) {
00078       clnt_pcreateerror("Can't do a clnttcp_create to send a response");
00079       write_time();
00080       write_log("**** Can't do a clnttcp_create to send a response ****\n");
00081       write_log("**** Did someone remove us from the portmapper? ****\n");
00082       return(0);        /* error ret */
00083     }
00084 /*********************************NOOP out 14Jun2010*****************
00085 //get sending host IP and port#
00086 socklen_t len;
00087 struct sockaddr_storage addr;
00088 char ipstr[INET6_ADDRSTRLEN];
00089 int port;
00090 len = sizeof addr;
00091 getpeername(sock, (struct sockaddr*)&addr, &len);
00092 // deal with both IPv4 and IPv6:
00093 if (addr.ss_family == AF_INET) {
00094     struct sockaddr_in *s = (struct sockaddr_in *)&addr;
00095     port = ntohs(s->sin_port);
00096     inet_ntop(AF_INET, &s->sin_addr, ipstr, sizeof ipstr);
00097 } else { // AF_INET6
00098     struct sockaddr_in6 *s = (struct sockaddr_in6 *)&addr;
00099     port = ntohs(s->sin6_port);
00100     inet_ntop(AF_INET6, &s->sin6_addr, ipstr, sizeof ipstr);
00101 }
00102 write_log("Peer IP/port: %s/%d  Caller:%s\n", ipstr, port, callername);
00103 sprintf(callername, "<none>");  //eventually elim callername everywhere
00104 *********************************NOOP out 14Jun2010*****************/
00105 
00106     /* set glb vrbl for poss use by sum_svc if result != 0 */
00107     current_client = client;
00108     return(client);
00109 }
00110 
00111 /* Send ack to original sum_svc caller. Uses global vrbls glb_transp and
00112  * rinfo which are set up before this call.
00113  * I'm not quite sure what to do on an error here?? I've never seen it and
00114  * will ignore it for now.
00115 */
00116 void send_ack()
00117 {
00118   /* send ack back with the rinfo uint32_t value */
00119   if (!svc_sendreply(glb_transp, (xdrproc_t)xdr_uint32_t, (char *)&rinfo)) {
00120     write_log("***Error on immed ack back to client. FATAL???\n");
00121     svcerr_systemerr(glb_transp);
00122   }
00123 }
00124 
00125 /*************************************************************************/
00126 
00127 /* Called by the SUM API SUM_open() making a clnt_call to sum_svc for the
00128  * OPENDO procedure. Returns an open uid in the ack back to the caller,
00129  * or 0 if error. Called:
00130  * db_name:        KEYTYP_STRING   hmidbX
00131  * USER:           KEYTYP_STRING   production
00132  *NOTE: the db_name is not used yet. The sum_svc is started for a db.
00133 */
00134 KEY *opendo_1(KEY *params)
00135 {
00136   char *user;
00137 
00138   if(findkey(params, "DEBUGFLG")) {
00139     debugflg = getkey_int(params, "DEBUGFLG");
00140     if(debugflg) {
00141       write_log("!!Keylist in opendo_1() is:\n");
00142       keyiterate(logkey, params);
00143     }
00144   }
00145   user = GETKEY_str(params, "USER");
00146   if(NO_OPEN) {
00147     write_time();
00148     write_log("No SUM_open() for %s allowed during SUM shutdown\n", user);
00149     rinfo = 0;              /* error back to caller */
00150     send_ack();             /* ack original sum_svc caller */
00151     return((KEY *)1);           /* nothing will be sent later */
00152   }
00153   rinfo = SUMLIB_Open();        /* return a SUMID_t else 0 */
00154   if(rinfo) {
00155     write_time();
00156     write_log("Successful SUMLIB_Open id=%d for user=%s uid=%d\n",rrid,user,rinfo);
00157     //Elim setsumopened/getsumopened after 30Aug2010 build
00158     //setsumopened(&sumopened_hdr, rinfo, NULL, user); /*put in list of opens*/
00159 
00160   }
00161   send_ack();               /* ack original sum_svc caller */
00162   return((KEY *)1);         /* nothing will be sent later */
00163 }
00164 
00165 /* Called by the SUM API SUM_open() making a clnt_call to sum_svc for the
00166  * CONFIGDO procedure. Returns the number of sum servers in the ack back to the 
00167  * caller, or 0 if error. Called:
00168  * db_name:        KEYTYP_STRING   hmidbX
00169  * USER:           KEYTYP_STRING   production
00170  *NOTE: the db_name is not used yet.
00171 */
00172 KEY *configdo_1(KEY *params)
00173 {
00174   char *user;
00175 
00176   if(findkey(params, "DEBUGFLG")) {
00177     debugflg = getkey_int(params, "DEBUGFLG");
00178     if(debugflg) {
00179       write_log("!!Keylist in configdo_1() is:\n");
00180       keyiterate(logkey, params);
00181     }
00182   }
00183   user = GETKEY_str(params, "USER");
00184   if(NO_OPEN) {
00185     write_time();
00186     write_log("No SUM_open() for %s allowed during SUM shutdown\n", user);
00187     rinfo = 0;              /* error back to caller */
00188     send_ack();             /* ack original sum_svc caller */
00189     return((KEY *)1);           /* nothing will be sent later */
00190   } 
00191   numSUM = SUM_NUMSUM;          //in base/drms/apps/serverdefs.h;
00192 
00193   //numSUM = 1;         //!!TEMP force to 1
00194   //write_log("This is the xsum_svc with numSUM forced to 1\n");
00195 
00196   rinfo = (uint32_t)numSUM;
00197   if(rinfo) {
00198     write_time();
00199     write_log("Successful CONFIGDO id=%d for user=%s numSUM=%d\n",rrid,user,rinfo);
00200   }
00201   send_ack();               /* ack original sum_svc caller */
00202   return((KEY *)1);         /* nothing will be sent later */
00203 }
00204 
00205 /* Called by the SUM API SUM_repartn() in order to get this sums process
00206  * to reread the sum_partn_avail DB table. (Used after a change to the
00207  * sum_partn_avail DB table.)
00208  * Returns 0 if error. Called:
00209  * USER:           KEYTYP_STRING   production
00210  * DEBUGFLG:       KEYTYPE_INT     0
00211  * uid:        KEYTYP_UINT64   574
00212 */
00213 KEY *repartndo_1(KEY *params)
00214 {
00215   int stat;
00216 
00217   stat = DS_PavailRequest2();
00218   if(!stat) {
00219     write_time();
00220     write_log("Successful reread of sum_partn_avail DB table\n");
00221     rinfo = 0;
00222   }
00223   else {
00224     write_log("Unsuccessful reread of sum_partn_avail DB table\n");
00225     rinfo = 1;
00226   }
00227   send_ack();               /* ack original sum_svc caller */
00228   return((KEY *)1);         /* nothing will be sent later */
00229 }
00230 
00231 
00232 /* Called by the SUM API SUM_shutdown() making a clnt_call to sum_svc for the
00233  * SHUTDO procedure. First sets the NO_OPEN flag to prevent further 
00234  * SUM_open's by a user if QUERY = 0. NOTE: QUERY =1 will clear NO_OPEN. 
00235  * Return 1 if no user is currently open and it is safe to shutdown.
00236  * Else returns 0 if you must wait for a user to SUM_close() before it is
00237  * safe to shutdown SUMS. Also prints to log all open user names.
00238  * Here is a typical keylist:
00239  * USER:           KEYTYP_STRING   production
00240  * QUERY:      KEYTYP_INT      0
00241  * 
00242 */
00243 KEY *shutdo_1(KEY *params)
00244 {
00245   SUMOPENED *walk = sumopened_hdr;
00246   int query;
00247 
00248   query = getkey_int(params, "QUERY");
00249   if(!query)
00250     NO_OPEN = 1;            /* no more SUM_open() allowed */
00251   else
00252     NO_OPEN = 0;
00253   if(walk == NULL) {            /* nothing opened, ok to shutdown */
00254     if(NO_OPEN)
00255       write_log("SUM_shutdown() call with no opened SUM users. New opens not allowed\n");
00256     else
00257       write_log("SUM_shutdown() call with no opened SUM users. New opens still allowed\n");
00258     rinfo = 1;
00259   }
00260   else {
00261     write_log("SUM_shutdown() call with opened users & uid:\n");
00262     rinfo = 0;              /* tell user can't shutdown yet */
00263     while(walk) {
00264       write_log("  %s %lu\n", walk->user, walk->uid);
00265       walk = walk->next;
00266     } 
00267     if(NO_OPEN)
00268       write_log("New opens not allowed\n");
00269     else
00270       write_log("New opens still allowed\n");
00271   }
00272   send_ack();               /* ack original sum_svc caller */
00273   return((KEY *)1);         /* nothing to be sent */
00274 }
00275 
00276 /* Called by the SUM API SUM_get() making a clnt_call to sum_svc for the
00277  * GETDO procedure. Return 1 if nothing to be sent or RESULT_PEND if one
00278  * or more storage units are offline and need to be retrieved from tape
00279  * (rinfo has status back to caller), else returns retlist of queried values.
00280  * Here is a typical keylist:
00281  * dsix_1: KEYTYP_UINT64    285
00282  * dsix_0: KEYTYP_UINT64    282
00283  * username:       KEYTYP_STRING   production
00284  * REQCODE:        KEYTYP_INT      4
00285  * DEBUGFLG:       KEYTYP_INT      1
00286  * reqcnt: KEYTYP_INT      2
00287  * tdays:  KEYTYP_INT      5
00288  * mode:   KEYTYP_INT      16
00289  * uid:    KEYTYP_UINT64    574
00290 */
00291 KEY *getdo_1(KEY *params)
00292 {
00293   //static struct timeval TIMEOUT = { 180, 0 }; 
00294   //static struct timeval TIMEOUT = { 8, 0 }; 
00295   //must be >40 used for tape_svc response to sum_svc
00296   static struct timeval TIMEOUT = { 50, 0 }; 
00297   static CLIENT *clresp;
00298   uint32_t tapeback;
00299   uint64_t uid, sunum;
00300   enum clnt_stat status;
00301   int reqcnt, i, offline, storeset, offcnt;
00302   char *call_err, *cptr, *wd;
00303   char scmd[96], errstr[80];
00304   double bytes;
00305 
00306   sprintf(callername, "getdo_1");   
00307   if(findkey(params, "DEBUGFLG")) {
00308   debugflg = getkey_int(params, "DEBUGFLG");
00309   if(debugflg) {
00310     write_log("!!Keylist in getdo_1() in xsum_svc_proc.c is:\n");
00311     keyiterate(logkey, params);
00312   }
00313   }
00314   reqcnt = getkey_int(params, "reqcnt");
00315   sunum = getkey_uint64(params, "dsix_0");
00316   //write_log("SUM_get() id=%d for user=%s sunum=%lu cnt=%d\n", 
00317   //        rrid, GETKEY_str(params, "username"), sunum, reqcnt);
00318   retlist=newkeylist();
00319   uid = getkey_uint64(params, "uid");
00320 //  if(!getsumopened(sumopened_hdr, (uint32_t)uid)) {
00321 //    write_log("**Error: getdo_1() called with unopened uid=%lu\n", uid);
00322 //    rinfo = 1;    /* give err status back to original caller */
00323 //    send_ack();   /* ack original sum_svc caller */
00324 //    return((KEY *)1); /* error. nothing to be sent */ 
00325 //  }
00326   add_keys(params, &retlist);
00327   /* set up for response. sets current_client */
00328   if(!(clresp = set_client_handle(RESPPROG, (uint32_t)uid))) {
00329     write_log("SUM_get() id=%d for user=%s sunum=%lu cnt=%d uid=%lu\n**Error: getdo_1() can't set_client_handle for response\n",
00330                 rrid, GETKEY_str(params, "username"), sunum, reqcnt, uid);
00331     freekeylist(&retlist);
00332     rinfo = 1;  /* give err status back to original caller */
00333     send_ack(); /* ack original sum_svc caller */
00334     return((KEY *)1);   /* error. nothing to be sent */ 
00335   }
00336     /* in case call tape_svc pass on who to eventually respond to */
00337     setkey_fileptr(&retlist, "current_client", (FILE *)clresp);
00338     if(DS_DataRequest(params, &retlist)) { /*get SU info & do any TOUCH */
00339       write_log("SUM_get() id=%d for user=%s sunum=%lu cnt=%d uid=%lu\n**Error: DS_DataRequest() returns error\n",
00340                 rrid, GETKEY_str(params, "username"), sunum, reqcnt, uid);
00341       freekeylist(&retlist);
00342       rinfo = 1;    /* give err status back to original caller */
00343       send_ack();   /* ack original sum_svc caller */
00344       clnt_destroy(clresp);
00345       return((KEY *)1); /* nothing more to be sent */
00346     }
00347     offline = getkey_int(retlist, "offline");
00348     write_log("SUM_get() id=%d for user=%s sunum=%lu cnt=%d uid=%lu rtrv=%d\n",
00349         rrid, GETKEY_str(params, "username"), sunum, reqcnt, uid, offline);
00350     /* param says if one or more are offline and need to be retrieved */
00351     if(offline) {  
00352       //ck if old code that has bug with tape rds (e.g. show_info)
00353       if(!findkey(params, "newflg")) {  //this is old code
00354         rinfo = 0;        /* indicate error through STATUS below */
00355         send_ack();       /* ack original sum_svc caller */
00356         setkey_int(&retlist, "STATUS", 1);   /* give error back to caller */
00357         sprintf(errstr, "Caller is old DRMS version. No tape read allowed. Remake your code\n");
00358         setkey_str(&retlist, "ERRSTR", errstr);
00359         write_log("No tape read for old DRMS version. id=%d for user=%s sunum=%lu cnt=%d uid=%lu\n",
00360         rrid, GETKEY_str(params, "username"), sunum, reqcnt, uid);
00361         return(retlist);    /* send ans now */
00362       }
00363       offcnt = 0;
00364       for(i=0; i < reqcnt; i++) {
00365         sprintf(nametmp, "online_status_%d", i);
00366         cptr = GETKEY_str(retlist, nametmp);
00367         //proceed if this su is offline and archived
00368         if(strcmp(cptr, "N") == 0) {
00369           sprintf(nametmp, "archive_status_%d", i);
00370           cptr = GETKEY_str(retlist, nametmp);
00371           if(strcmp(cptr, "Y") == 0) {
00372             offcnt++;
00373             sprintf(nametmp, "bytes_%d", i);
00374             bytes = getkey_double(retlist, nametmp);
00375             storeset = JSOC;         /* always use JSOC set for now */
00376             if((status=SUMLIB_PavailGet(bytes,storeset,uid,0,&retlist))) {
00377               write_log("***Can't alloc storage for retrieve uid = %lu\n", uid);
00378               freekeylist(&retlist);
00379               rinfo = 1;  /* give err status back to original caller */
00380               send_ack();   /* ack original sum_svc caller */
00381               clnt_destroy(clresp);
00382               return((KEY *)1);  /* error. nothing to be sent */
00383             }
00384             wd = GETKEY_str(retlist, "partn_name");
00385             //elim sticky bit so don't need to do sum_chmown() after read
00386             sprintf(scmd, "chmod g-s %s", wd);
00387             if(system(scmd)) {
00388                 write_log("**Warning: Error on: %s. errno=%d\n", scmd,errno);
00389             }
00390             sprintf(nametmp, "rootwd_%d", i);
00391             setkey_str(&retlist, nametmp, wd);
00392             write_log("\nAlloc for retrieve wd = %s for sumid = %lu\n", wd, uid);
00393           }
00394         }
00395       }
00396       setkey_int(&retlist, "offcnt", offcnt);
00397       /* call tape_svc and tell our caller to wait */
00398       if(debugflg) {
00399         write_log("Calling tape_svc to bring data unit online\n");
00400       }
00401       //check if sum_svc was disconnected from tape_svc. see tapereconnectdo_1()
00402       if(clnttape == 0) {
00403         rinfo = 2;      //tell drms tape unit was taken offline
00404         send_ack();
00405         freekeylist(&retlist);
00406         write_log("**Error in READDO to tape_svc. sum_svc has been disconnected\n");
00407         return((KEY *)1);
00408       }
00409       rinfo = RESULT_PEND;  /* now tell caller to wait for results */
00410       tapeback = 0;
00411       //tell tape_svc which sums process to respond to
00412       write_log("SUM_get() id=%d for SPROG=%u SVERS=%u uid=%lu rtrv=%d\n",
00413         rrid, sumprog, sumvers, uid, offline);
00414       setkey_uint32(&retlist, "SPROG", sumprog);
00415       setkey_uint32(&retlist, "SVERS", sumvers);
00416       status = clnt_call(clnttape,READDO, (xdrproc_t)xdr_Rkey, (char *)retlist, 
00417             (xdrproc_t)xdr_uint32_t, (char *)&tapeback, TIMEOUT);
00418       if(status != RPC_SUCCESS) {
00419           if(status != RPC_TIMEDOUT) {
00420             //rinfo = 1;
00421             rinfo = 5;      //tell drms that tape_svc is dead
00422             send_ack();
00423             call_err = clnt_sperror(clnttape, "Error clnt_call for READDO");
00424             write_log("%s %d %s\n", datestring(), status, call_err);
00425             freekeylist(&retlist);
00426             return((KEY *)1);
00427           } else {
00428             write_log("%s timeout ignored in getdo_1()\n", datestring());
00429           }
00430       }
00431       if(tapeback == 1) {
00432         rinfo = 1;
00433         send_ack();
00434         freekeylist(&retlist);
00435         write_log("**Error in READDO call to tape_svc in sum_svc_proc.c\n");
00436         return((KEY *)1);
00437       }
00438       send_ack();
00439     }
00440     else {
00441       rinfo = 0;    /* eveything is ok and here are the results */
00442       send_ack();       /* ack original sum_svc caller */
00443     }
00444     if(offline) {
00445       freekeylist(&retlist);
00446       return((KEY *)1); /* let tape_svc answer. dont destroy current_client */
00447     }
00448     setkey_int(&retlist, "STATUS", 0);   /* give success back to caller */
00449     return(retlist);    /* send ans now */
00450 }
00451 
00452 /* Called when a client does a SUM_alloc() or SUM_alloc2() call to get storage. 
00453  * A typical keylist is:
00454  * USER:       KEYTYP_STRING   production
00455  * REQCODE:        KEYTYP_INT      6
00456  * DEBUGFLG:       KEYTYP_INT      1
00457  * group:          KEYTYP_INT      10000
00458  * SUNUM:      KEYTYP_UINT64   6260386 (unique to SUM_alloc2() call)
00459  * uid:    KEYTYP_UINT64    574
00460  * reqcnt: KEYTYP_INT      1
00461  * storeset:       KEYTYP_INT      0
00462  * bytes:  KEYTYP_DOUBLE           1.200000e+08
00463 */
00464 KEY *allocdo_1(KEY *params)
00465 {
00466   int status, reqcnt, group;
00467   int storeset = 0;
00468   uint64_t uid;
00469   uint64_t sunum = 0;
00470   double bytes;
00471   char *wd;
00472 
00473   sprintf(callername, "allocdo_1"); 
00474   if(findkey(params, "DEBUGFLG")) {
00475     debugflg = getkey_int(params, "DEBUGFLG");
00476     if(debugflg) {
00477       write_log("!!Keylist in allocdo_1() is:\n");
00478       keyiterate(logkey, params);
00479     }
00480   }
00481   if(findkey(params, "SUNUM")) {    //this is a SUM_alloc2() call
00482     sunum = getkey_uint64(params, "SUNUM");
00483   }
00484 #if defined(SUMS_MULTIPLE_PARTNSETS) && SUMS_MULTIPLE_PARTNSETS
00485   /* This def is defined in serverdefs.h (all Stanford-specific settings are in this header). 
00486    * It is NOT part of the localization files/codes/scripts (i.e., config.local knows nothing
00487    * about it). Therefore, no localization site will be able to take advantage of this
00488    * multiple-sums-sets. If in the future a remote sites wants this feature, we will need 
00489    * to modify config.local (add SUMS_MULTIPLE_PARTNSETS), gen_init.csh, create_sums_tables.sql
00490    * (the block of code requires a new sums db table) and possibly other files/code/scripts. 
00491    *
00492    * ART 2011-5-17
00493    */
00494   if(!findkey(params, "group")) {   //use storeset 0 if no group
00495     storeset = 0;
00496   }
00497   else {                //query sum_arch_group db table
00498     group = getkey_int(params, "group");
00499     status = SUMLIB_SumsetGet(group, &storeset); //default storeset is 0
00500   }
00501 #endif
00502   uid = getkey_uint64(params, "uid");
00503 //  if(!getsumopened(sumopened_hdr, (uint32_t)uid)) {
00504 //    write_log("**Error: allocdo_1() called with unopened uid=%lu\n", uid);
00505 //    rinfo = 1;    /* give err status back to original caller */
00506 //    send_ack();   /* ack original sum_svc caller */
00507 //    return((KEY *)1); /* error. nothing to be sent */ 
00508 //  }
00509   retlist = newkeylist();
00510   add_keys(params, &retlist);       /* NOTE:does not do fileptr */
00511   reqcnt = getkey_int(params, "reqcnt"); /* will always be 1 */
00512   bytes = getkey_double(params, "bytes");
00513   //storeset = getkey_int(params, "storeset"); //obsolete
00514   if(!(status=SUMLIB_PavailGet(bytes, storeset, uid, sunum, &retlist))) {
00515     wd = getkey_str(retlist, "partn_name");
00516     write_log("Alloc bytes=%e id=%d wd=%s for user=%s sumid=%lu\n", bytes, rrid, wd,
00517         GETKEY_str(retlist, "USER"), uid);
00518     if(!(set_client_handle(RESPPROG, (uint32_t)uid))) { /*set up for response*/
00519       write_log("Alloc Error Can't set client handle id=%d user=%s sumid=%lu\n", rrid, GETKEY_str(retlist, "USER"), uid);
00520       free(wd);
00521       freekeylist(&retlist);
00522       rinfo = 1;  /* give err status back to original caller */
00523       send_ack();
00524       return((KEY *)1);  /* error. nothing to be sent */
00525     }
00526     /* put in sum_partn_alloc as DARW entry with commit */
00527     if(NC_PaUpdate(wd, uid, bytes, DARW, 0, NULL, 0, 0, 0, 1, 1)) { 
00528       write_log("WARN: can't make DARW entry in sum_partn_alloc for\n");
00529       write_log("      allocated storage. Proceed anyway...\n");
00530     }
00531     rinfo = 0;
00532     send_ack();
00533     setkey_int(&retlist, "STATUS", 0);   /* give success back to caller */
00534     free(wd);
00535     return(retlist);        /* return the ans now */
00536   }
00537   rinfo = status;       /* ret err code back to caller */
00538   send_ack();
00539   freekeylist(&retlist);
00540   return((KEY *)1);     /* nothing will be sent later */
00541 }
00542 
00543 /* Called when a client does a SUM_info() call to get sum_main info. 
00544  * A typical keylist is:
00545  * USER:       KEYTYP_STRING   production
00546  * REQCODE:        KEYTYP_INT      13
00547  * DEBUGFLG:       KEYTYP_INT      1
00548  * SUNUM:      KEYTYP_UINT64   6260386 
00549  * uid:    KEYTYP_UINT64    574
00550 */
00551 KEY *infodo_1(KEY *params)
00552 {
00553   int status;
00554   uint64_t uid;
00555   uint64_t sunum = 0;
00556 
00557   sprintf(callername, "infodo_1");  
00558   if(findkey(params, "DEBUGFLG")) {
00559     debugflg = getkey_int(params, "DEBUGFLG");
00560     if(debugflg) {
00561       write_log("!!Keylist in infodo_1() is:\n");
00562       keyiterate(logkey, params);
00563     }
00564   }
00565   sunum = getkey_uint64(params, "SUNUM");
00566   uid = getkey_uint64(params, "uid");
00567   write_log("SUM_Info() for user=%s sunum=%lu\n", 
00568         GETKEY_str(params, "username"), sunum);
00569 //  if(!getsumopened(sumopened_hdr, (uint32_t)uid)) {
00570 //    write_log("**Error: infodo_1() called with unopened uid=%lu\n", uid);
00571 //    rinfo = 1;    /* give err status back to original caller */
00572 //    send_ack();   /* ack original sum_svc caller */
00573 //    return((KEY *)1); /* error. nothing to be sent */ 
00574 //  }
00575   retlist = newkeylist();
00576   add_keys(params, &retlist);       /* NOTE:does not do fileptr */
00577 
00578   if(!(status=SUMLIB_InfoGet(sunum, &retlist))) {
00579     if(!(set_client_handle(RESPPROG, (uint32_t)uid))) { /*set up for response*/
00580       freekeylist(&retlist);
00581       /*rinfo = 1;  /* give err status back to original caller */
00582       rinfo = SUM_RESPPROG_ERR;
00583       send_ack();
00584       return((KEY *)1);  /* error. nothing to be sent */
00585     }
00586     rinfo = 0;
00587     send_ack();
00588     setkey_int(&retlist, "STATUS", 0);   /* give success back to caller */
00589     return(retlist);        /* return the ans now */
00590   }
00591   rinfo = status;       /* ret err code 1 back to caller */
00592   freekeylist(&retlist);
00593   if(!drmssite_sunum_is_local(sunum))
00594     rinfo = SUM_SUNUM_NOT_LOCAL; // else this error code 
00595   send_ack();
00596   return((KEY *)1);     /* nothing will be sent later */
00597 }
00598 
00599 /* Called when a client does a SUM_infoArray() call to get sum_main info. 
00600  * This uses a Sunumarray arg structure instead of the usual keylist.
00601 */
00602 KEY *infodoArray_1(Sunumarray *params)
00603 {
00604   int reqcnt, i, status, filemode;
00605   double bytes = 10000000.0;
00606   char *partname, *effective_date;
00607   char filename[128];
00608   //char *filename = "/home/production/junk/infoarray.ans"; //!!TEMP
00609 
00610   reqcnt = params->reqcnt;
00611   retlist = newkeylist();
00612   write_log("SUM_infoArray() id=%d for user=%s uid=%lu 1st sunum=%lu cnt=%d\n", 
00613     rrid, params->username, params->uid, *params->sunums, reqcnt);
00614   if((status=SUMLIB_PavailGet(bytes,0,params->uid,0,&retlist))) {
00615     write_log("Can't alloc storage for %s in infodoArray_1()\n", params->username);
00616     freekeylist(&retlist);
00617     rinfo = status;     /* ret err code back to caller */
00618     send_ack();
00619     return((KEY *)1);   /* nothing will be sent later */
00620   } 
00621   partname = getkey_str(retlist, "partn_name");
00622   sprintf(filename, "%s/infoarray.ans", partname);
00623   effective_date = (char *)get_effdate(0);
00624 
00625   //make the alloc dir del pending
00626   NC_PaUpdate(partname, params->uid, bytes, DADP, DAAEDDP, effective_date, 
00627         0, 0, getkey_uint64(retlist, "ds_index"), 1, 0);
00628   free(partname);
00629   free(effective_date);
00630   freekeylist(&retlist);
00631   if(!(status=SUMLIB_InfoGetArray(params, filename, &filemode))) {
00632     if(!(set_client_handle(RESPPROG, (uint32_t)params->uid))) { /*set up for response*/
00633       write_log("**Error: infodoArray_1() can't set_client_handle for response\n");
00634       rinfo = SUM_RESPPROG_ERR;
00635       send_ack();
00636       return((KEY *)1);  /* error. nothing to be sent */
00637     }
00638     rinfo = 0;
00639     send_ack();
00640     retlist = newkeylist();
00641     setkey_int(&retlist, "STATUS", 0);   /* give success back to caller */
00642     setkey_str(&retlist, "FILE", filename);
00643     setkey_int(&retlist, "filemode", filemode);
00644     setkey_uint64(&retlist, "uid", params->uid);
00645     setkey_int(&retlist, "reqcnt", reqcnt);
00646     return(retlist);        /* return the ans now */
00647   }
00648   rinfo = status;       /* ret err code 1 back to caller */
00649   send_ack();
00650   return((KEY *)1); /* nothing will be sent later */
00651 }
00652 
00653 /* Called when a client does a SUM_infoEx() call to get sum_main info. 
00654  * A typical keylist is:
00655  * dsix_1: KEYTYP_UINT64    285
00656  * dsix_0: KEYTYP_UINT64    282
00657  * username:       KEYTYP_STRING   production
00658  * REQCODE:        KEYTYP_INT      4
00659  * DEBUGFLG:       KEYTYP_INT      1
00660  * reqcnt: KEYTYP_INT      2
00661  * uid:    KEYTYP_UINT64    574
00662 */
00663 KEY *infodoX_1(KEY *params)
00664 {
00665   int status, reqcnt;
00666   uint64_t uid;
00667   uint64_t sunum = 0;
00668   sprintf(callername, "infodoX_1"); 
00669   if(findkey(params, "DEBUGFLG")) {
00670     debugflg = getkey_int(params, "DEBUGFLG");
00671     if(debugflg) {
00672       write_log("!!Keylist in infodoX_1() is:\n");
00673       keyiterate(logkey, params);
00674     }
00675   }
00676   sunum = getkey_uint64(params, "dsix_0");
00677   reqcnt = getkey_int(params, "reqcnt"); 
00678   uid = getkey_uint64(params, "uid");
00679 //  if(!getsumopened(sumopened_hdr, (uint32_t)uid)) {
00680 //    write_log("**Error: infodoX_1() called with unopened uid=%lu\n", uid);
00681 //    rinfo = 1;    /* give err status back to original caller */
00682 //    send_ack();   /* ack original sum_svc caller */
00683 //    return((KEY *)1); /* error. nothing to be sent */ 
00684 //  }
00685   write_log("SUM_infoEx() id=%d for user=%s 1st sunum=%lu cnt=%d\n",
00686                 rrid, GETKEY_str(params, "username"), sunum, reqcnt);
00687   retlist = newkeylist();
00688   add_keys(params, &retlist);       /* NOTE:does not do fileptr */
00689   if(!(status=SUMLIB_InfoGetEx(params, &retlist))) {
00690     if(!(set_client_handle(RESPPROG, (uint32_t)uid))) { /*set up for response*/
00691       write_log("**Error: infodoX_1() can't set_client_handle for response\n");
00692       freekeylist(&retlist);
00693       /*rinfo = 1;  /* give err status back to original caller */
00694       rinfo = SUM_RESPPROG_ERR;
00695       send_ack();
00696       return((KEY *)1);  /* error. nothing to be sent */
00697     }
00698     rinfo = 0;
00699     send_ack();
00700     setkey_int(&retlist, "STATUS", 0);   /* give success back to caller */
00701     return(retlist);        /* return the ans now */
00702   }
00703   rinfo = status;       /* ret err code 1 back to caller */
00704   //if(!drmssite_sunum_is_local(sunum))
00705   //  rinfo = SUM_SUNUM_NOT_LOCAL; // else this error code 
00706   send_ack();
00707   freekeylist(&retlist);
00708   return((KEY *)1);     /* nothing will be sent later */
00709 }
00710 
00711 /* Called when a client does a SUM_infoEx() call to get sum_main info. 
00712  * !!This is the version that uses the UTHASH library!!
00713  * A typical keylist is:
00714  * dsix_1: KEYTYP_UINT64    285
00715  * dsix_0: KEYTYP_UINT64    282
00716  * username:       KEYTYP_STRING   production
00717  * REQCODE:        KEYTYP_INT      4
00718  * DEBUGFLG:       KEYTYP_INT      1
00719  * reqcnt: KEYTYP_INT      2
00720  * uid:    KEYTYP_UINT64    574
00721 */
00722 KEY *infodoX_1_U(KEY *params)
00723 {
00724 /********************TEST CODE ONLY*************************************
00725   KEYU *retlistU;
00726   int status, reqcnt;
00727   uint64_t uid;
00728   uint64_t sunum = 0;
00729   sprintf(callername, "infodoX_1_U");   //!!TEMP
00730   if(findkey(params, "DEBUGFLG")) {
00731     debugflg = getkey_int(params, "DEBUGFLG");
00732     if(debugflg) {
00733       write_log("!!Keylist in infodoX_1_U() is:\n");
00734       keyiterate(logkey, params);
00735     }
00736   }
00737   //Convert the KEY list input to a UTHASH list
00738   retlistU = newkeylistU();
00739   add_key2keyU(params, &retlistU);
00740 
00741   sunum = getkey_uint64U(retlistU, "dsix_0");
00742   reqcnt = getkey_intU(retlistU, "reqcnt"); 
00743   uid = getkey_uint64U(retlistU, "uid");
00744   write_log("SUM_infoEx() id=%d for user=%s 1st sunum=%lu cnt=%d\n",
00745                 rrid, GETKEY_strU(retlistU, "username"), sunum, reqcnt);
00746 
00747   if(!(status=SUMLIB_InfoGetEx_U(retlistU, &retlistU))) {
00748     if(!(set_client_handle(RESPPROG, (uint32_t)uid))) { //set up for response
00749       write_log("**Error: infodoX_1_U() can't set_client_handle for response\n");
00750       freekeylistU(&retlistU);
00751       //rinfo = 1;  //give err status back to original caller
00752       rinfo = SUM_RESPPROG_ERR;
00753       send_ack();
00754       return((KEY *)1);  //error. nothing to be sent
00755     }
00756     rinfo = 0;
00757     send_ack();
00758     setkey_intU(&retlistU, "STATUS", 0);   //give success back to caller
00759     //now convert the UTHASH back to our normal keylist
00760     retlist = newkeylist();
00761     add_keyU2key(retlistU, &retlist);
00762     freekeylistU(&retlistU);
00763     return(retlist);        //return the ans now
00764   }
00765   rinfo = status;       //ret err code 1 back to caller
00766   //if(!drmssite_sunum_is_local(sunum))
00767   //  rinfo = SUM_SUNUM_NOT_LOCAL; // else this error code 
00768   send_ack();
00769   freekeylistU(&retlistU);
00770   return((KEY *)1);     //nothing will be sent later
00771 ********************TEST CODE ONLY*************************************/
00772 }
00773 
00774 
00775 /* Called when a client does a SUM_put() to catalog storage units.
00776  * Can put multiple SU at a time. Typical call is:
00777  * wd_0:   KEYTYP_STRING   /SUM1/D1695
00778  * dsix_0: KEYTYP_UINT64    1695
00779  * wd_1:   KEYTYP_STRING   /SUM0/D1696
00780  * dsix_1: KEYTYP_UINT64    1696
00781  * REQCODE:        KEYTYP_INT      7
00782  * DEBUGFLG:       KEYTYP_INT      0
00783  * storage_set:    KEYTYP_INT      0
00784  * group:  KEYTYP_INT      65
00785  * username:       KEYTYP_STRING   production
00786  * history_comment: KEYTYP_STRING   this is a dummy history comment 
00787  * dsname: KEYTYP_STRING   hmi_lev1_fd_V
00788  * reqcnt: KEYTYP_INT      2
00789  * tdays:  KEYTYP_INT      5
00790  * mode:   KEYTYP_INT      1
00791  * uid:    KEYTYP_UINT64    886
00792 */
00793 KEY *putdo_1(KEY *params)
00794 {
00795   int status, i, reqcnt;
00796   uint64_t sunum = 0;
00797   uint64_t uid;
00798   char sysstr[128];
00799   char *cptr, *wd;
00800 
00801   sprintf(callername, "putdo_1");   
00802   if(findkey(params, "DEBUGFLG")) {
00803   debugflg = getkey_int(params, "DEBUGFLG");
00804   if(debugflg) {
00805     write_log("!!Keylist in putdo_1() is:\n");
00806     keyiterate(logkey, params);
00807   }
00808   }
00809   uid = getkey_uint64(params, "uid");
00810   reqcnt = getkey_int(params, "reqcnt");
00811   sunum = getkey_uint64(params, "dsix_0");
00812   write_log("SUM_put() id=%d for user=%s 1st sunum=%lu reqcnt=%d\n", 
00813         rrid, GETKEY_str(params, "username"), sunum, reqcnt);
00814 //  if(!getsumopened(sumopened_hdr, (uint32_t)uid)) {
00815 //    write_log("**Error: putdo_1() called with unopened uid=%lu\n", uid);
00816 //    rinfo = 1;    /* give err status back to original caller */
00817 //    send_ack();   /* ack original sum_svc caller */
00818 //    return((KEY *)1); /* error. nothing to be sent */ 
00819 //  }
00820   retlist = newkeylist();
00821   add_keys(params, &retlist);
00822   //First change to owner production, no group write. This must succeed 
00823   //all or nothing as far as the caller is concerned.
00824     for(i=0; i < reqcnt; i++) { 
00825       sprintf(nametmp, "wd_%d", i);
00826       cptr = GETKEY_str(params, nametmp);
00827       sprintf(nametmp, "%s.chmown",  logname);
00828       sprintf(sysstr, "%s/sum_chmown %s 1>> %s 2>&1",
00829                         SUMBIN_BASEDIR, cptr, nametmp);
00830       write_log("%s\n", sysstr);
00831       //StartTimer(3);          //!!TEMP
00833 //      if(system(sysstr)) {
00834 //          write_log("**Warning: Error on: %s. errno=%d\n", sysstr,errno);
00835 //         rinfo = 1;                    /* error back to caller */
00836 //         send_ack();
00837 //          freekeylist(&retlist);
00838 //          return((KEY *)1);             /* nothing but status back */
00839 //      }
00840       //ftmp = StopTimer(3);
00841       //write_log("#END: sum_chmown() %fsec\n", ftmp);    //!!TEMP for test
00842     }
00843  
00844   //now insert in the sums tables 
00845   if(!(status=SUM_Main_Update(params, &retlist))) {
00846     if(!(set_client_handle(RESPPROG, (uint32_t)uid))) { //set up for response
00847       freekeylist(&retlist);
00848       rinfo = 1;  // give err status back to original caller/
00849       send_ack();
00850       return((KEY *)1);  // error. nothing to be sent
00851     }
00852     rinfo = 0;          // status back to caller
00853     send_ack();
00854     setkey_int(&retlist, "STATUS", 0);   // give success back to caller
00855     return(retlist);
00856   }
00857   rinfo = status;       /* error status back to caller */
00858   send_ack();
00859   freekeylist(&retlist);
00860   return((KEY *)1);     /* nothing but status back */
00861 }
00862 
00863 /* Typical keylist is:
00864  * REQCODE:        KEYTYP_INT      3
00865  * DEBUGFLG:       KEYTYP_INT      1
00866  * TAPERDACTIVE:   KEYTYP_INT      1
00867  * USER:       KEYTYP_STRING   production
00868  * uid:    KEYTYP_UINT64    574
00869 */
00870 KEY *closedo_1(KEY *params)
00871 {
00872   uint64_t uid;
00873   uint32_t tapeback;
00874   enum clnt_stat status;
00875   char *call_err;
00876   static struct timeval TIMEOUT = { 50, 0 };
00877 
00878   if(findkey(params, "DEBUGFLG")) {
00879   debugflg = getkey_int(params, "DEBUGFLG");
00880   if(debugflg) {
00881     write_log("!!Keylist in closedo_1() is:\n");
00882     keyiterate(logkey, params);
00883   }
00884   }
00885   uid = getkey_uint64(params, "uid");
00886   if(findkey(params, "TAPERDACTIVE")) {  //client closed w/a rd active
00887     //tell tape_svc to ignore completion msg to this client
00888     if(clnttape != 0) {  //sum_svc still connected to tape_svc
00889       retlist=newkeylist();
00890       add_keys(params, &retlist);
00891       write_log("Calling CLNTGONE from closedo_1() in sums uid=%lu\n", uid);
00892       status = clnt_call(clnttape,CLNTGONE, (xdrproc_t)xdr_Rkey, (char *)retlist,
00893                         (xdrproc_t)xdr_uint32_t, (char *)&tapeback, TIMEOUT);
00894       if(status != RPC_SUCCESS) {
00895           if(status != RPC_TIMEDOUT) {
00896             call_err = clnt_sperror(clnttape, "Error clnt_call for CLNTGONE");
00897             write_log("%s %d %s\n", datestring(), status, call_err);
00898           } else {
00899             write_log("%s timeout ignored in closedo_1() CLNTGONE\n", datestring());
00900           }
00901       }
00902       if(tapeback == 1) {
00903         write_log("**Error in CLNTGONE call to tape_svc in sum_svc_proc.c\n");
00904       }
00905       freekeylist(&retlist);
00906     }
00907   }
00908 //  if(!getsumopened(sumopened_hdr, (uint32_t)uid)) {
00909 //    write_log("**Error: closedo_1() called with unopened uid=%lu\n", uid);
00910 //    rinfo = 1;    /* give err status back to original caller */
00911 //    send_ack();   /* ack original sum_svc caller */
00912 //    return((KEY *)1); /* error. nothing to be sent */ 
00913 //  }
00914   remsumopened(&sumopened_hdr, (uint32_t)uid); /* rem from linked list */
00915   rinfo = SUMLIB_Close(params);
00916   write_log("SUM_close for user=%s uid=%lu\n",
00917         GETKEY_str(params, "USER"), getkey_uint64(params, "uid"));
00918   send_ack();
00919   return((KEY *)1); /* nothing will be sent later */
00920 }
00921 
00922 /* DRMS typically uses this to see if sum_svc is alive.
00923  * If DRMS gets an ack back, it know that sum_svc is alive.
00924  * Typical keylist is:
00925  * REQCODE:        KEYTYP_INT      16
00926  * DEBUGFLG:       KEYTYP_INT      1
00927  * USER:       KEYTYP_STRING   production
00928  * uid:    KEYTYP_UINT64    574
00929  *
00930  *Returns 0 in rinfo if both sum_svc and tape_svc are ok.
00931  *1 = tape_svc call timeout
00932  *5 = tape_svc not there
00933 */
00934 KEY *nopdo_1(KEY *params)
00935 {
00936   //struct timeval NOPTIMEOUT = { 8, 0 };
00937   struct timeval NOPTIMEOUT = { 15, 0 };
00938   uint64_t uid;
00939   KEY *klist;
00940   char *call_err;
00941   char *usr;
00942   int ans;
00943   enum clnt_stat status;
00944 
00945   //usr = getkey_str(params, "USER");
00946   if(findkey(params, "DEBUGFLG")) {
00947     debugflg = getkey_int(params, "DEBUGFLG");
00948     if(debugflg) {
00949       write_log("!!Keylist in nopdo_1() is:\n");
00950       keyiterate(logkey, params);
00951     }
00952   }
00953   uid = getkey_uint64(params, "uid");
00954   rinfo = 0;
00955 /********************************************************************
00956   //ck if a sum_svc to tape_svc reconnect call was made (done by
00957   //tape_svc_restart to start a new tape_svc). If so then return
00958   //an error 5 for no original tape_svc that was connnected to this sum_svc.
00959   //This will cause drms to make an extra sum_get() after a tape_svc restart,
00960   //but this an unlikely occurence and the price to get resynced.
00961   if(!clnttape_old) {
00962     rinfo = 5;
00963     clnttape_old = clnttape;
00964   }
00965   else {
00966 ***************************************************************/
00967 /***************************************************************
00969     rinfo = 1;
00970     klist = newkeylist();
00971     setkey_uint64(&klist, "uid", uid);
00972     setkey_str(&klist, "USER", GETKEY_str(params, "USER") );
00973     //tell tape_svc which sums process to respond to
00974     setkey_uint32(&klist, "SPROG", sumprog);
00975     setkey_uint32(&klist, "SVERS", sumvers);
00976     status = clnt_call(clnttape, TAPENOPDO, (xdrproc_t)xdr_Rkey, (char *)klist,
00977                         (xdrproc_t)xdr_void, (char *)&ans, NOPTIMEOUT);
00978     rinfo = (int)ans;
00979 
00980     // NOTE: Must honor the timeout here as get the ans back in the ack
00981     if(status != RPC_SUCCESS) {
00982         rinfo = 5;
00983         call_err = clnt_sperror(clnttape, "Err clnt_call for TAPENOPDO");
00984         write_log("%s %s status=%d\n", datestring(), call_err, status);
00985     }
00986   //}
00987 ****************************************************************/
00988   write_log("SUM_nop for user=%s uid=%lu\n",
00989         GETKEY_str(params, "USER"), uid);
00990   send_ack();
00991   return((KEY *)1); /* nothing will be sent later */
00992 }
00993 
00994 /* This is called by the tape_svc_restart program to tell sum_svc
00995  * to reconnect to a new tape_svc that has been started.
00996  * Eventually the stop of the old tape_svc and the start of a new
00997  * one can be done here with ssh calls to d02. But for now,
00998  * we will require that the user stops and starts a tape_svc.
00999  * How to do this will be detailed when tape_svc_restart is run.
01000  * Typical keylist is:
01001  * ACTION:         KEYTYP_STRING   close/reconnect
01002  * USER:       KEYTYP_STRING   production
01003  * HOST:       KEYTYP_STRING   d02
01004 */
01005 KEY *tapereconnectdo_1(KEY *params)
01006 {
01007   uint64_t uid;
01008   char *cptr, *dptr;
01009   char *user;
01010 
01011   rinfo = 0;
01012   user = getkey_str(params, "USER");
01013   write_log("Tape reconnect for user=%s action=%s\n", user, GETKEY_str(params, "ACTION"));
01014   cptr = GETKEY_str(params, "ACTION");
01015   if(!strcmp(cptr, "close")) {
01016     write_log("sum_svc is closing on tape_svc about to be restarted\n");
01017     if(clnttape) clnt_destroy(clnttape);
01018     clnttape = 0;
01019   }
01020   else if(!strcmp(cptr, "reconnect")) {
01021     //connect to tape_svc
01022     clnttape_old = NULL;    //let nopdo_1() know that the old handle is NG
01023     dptr = getkey_str(params, "HOST");
01024     if(!strcmp(dptr, "xim"))   //use xim if request is from xim
01025       clnttape = clnt_create(dptr, TAPEPROG, TAPEVERS, "tcp");
01026     else 
01027       clnttape = clnt_create(TAPEHOST, TAPEPROG, TAPEVERS, "tcp");
01028     if(!clnttape) {       /* server not there */
01029       clnt_pcreateerror("Can't get client handle to tape_svc (from sum_svc)");
01030       write_log("Cannot connect to new tape_svc on d02\n");
01031       rinfo = 1;
01032       //exit(1);
01033     }
01034     write_log("sum_svc has reconnected to restarted tape_svc\n");
01035   }
01036   else {  
01037     write_log("Illegal action = %s sent to tapereconnectdo_1()\n", cptr);
01038     rinfo = -1;
01039   }
01040   send_ack();
01041   free(user);
01042   return((KEY *)1); /* nothing will be sent later */
01043 }
01044 
01045 /* Called by delete_series doing a SUM_delete_series() call with all
01046  * the SUMS storage units (i.e. ds_index) that are associated with
01047  * the series about to be deleted. The sunums are in the given file.
01048  * Typical keylist is:
01049  * DEBUGFLG:       KEYTYP_INT      1
01050  * USER:       KEYTYP_STRING   production
01051  * FILE:        KEYTYP_STRING /SUM1/D99999/filename.sunums
01052  * SERIESNAME:  KEYTYP_STRING su_production.test
01053 */
01054 KEY *delseriesdo_1(KEY *params)
01055 {
01056   char *filename, *seriesname;
01057 
01058   if(findkey(params, "DEBUGFLG")) {
01059     debugflg = getkey_int(params, "DEBUGFLG");
01060     if(debugflg) {
01061       write_log("!!Keylist in delseriesdo_1() is:\n");
01062       keyiterate(logkey, params);
01063     }
01064   }
01065   rinfo = 0;
01066   filename = getkey_str(params, "FILE");
01067   seriesname = getkey_str(params, "SERIESNAME");
01068   write_log("DELSERIESDO for user=%s\n", GETKEY_str(params, "USER"));
01069   send_ack();
01070   /* set DB sum_partn_alloc to DADP/DADPDELSU */
01071   SUMLIB_DelSeriesSU(filename, seriesname);
01072   free(filename); free(seriesname);
01073   return((KEY *)1); /* nothing will be sent later */
01074 }
01075 
01076 
01077 /* This is called from the tape_svc by:
01078  * clnt_call(clntsum,SUMRESPDO,xdr_result,result,xdr_void,0,TIMEOUT);
01079  * where   clntsum = clnt_create(thishost, SUMPROG, SUMVERS, "tcp");
01080  * The tape operation has completed. A typical keylist is:
01081  * filenum: KEYTYP_INT  0
01082  * tapemode:    KEYTYP_INT  1
01083  * cmd1:    KEYTYP_STRING   mtx -f /dev/sg12 load 8 3 1> /tmp/mtx_robot_3.log 2>&1
01084  * snum:    KEYTYP_INT  7
01085  * dnum:    KEYTYP_INT  3
01086  * dsix_2:  KEYTYP_UINT64   2233
01087  * dsix_1:  KEYTYP_UINT64   2232
01088  * dsix_0:  KEYTYP_UINT64   2231
01089  * username:    KEYTYP_STRING   production
01090  * REQCODE: KEYTYP_INT  4
01091  * DEBUGFLG:    KEYTYP_INT  1
01092  * reqcnt:  KEYTYP_INT  3
01093  * tdays:   KEYTYP_INT  5
01094  * mode:    KEYTYP_INT  16
01095  * uid: KEYTYP_UINT64   43043
01096  * current_client:  KEYTYP_FILEP    6455248
01097  * online_status_0: KEYTYP_STRING   Y
01098  * archive_status_0:    KEYTYP_STRING   Y
01099  * bytes_0: KEYTYP_DOUBLE              1.200000e+08
01100  * create_sumid_0:  KEYTYP_UINT64   623
01101  * ds_index_0:  KEYTYP_UINT64   2231
01102  * wd_0:    KEYTYP_STRING   /SUM0/D2917/D2231
01103  * tapeid_0:    KEYTYP_STRING   000001S1
01104  * tapefilenum_0:   KEYTYP_INT  1
01105  * online_status_1: KEYTYP_STRING   Y
01106  * archive_status_1:    KEYTYP_STRING   Y
01107  * bytes_1: KEYTYP_DOUBLE              1.200000e+08
01108  * create_sumid_1:  KEYTYP_UINT64   623
01109  * ds_index_1:  KEYTYP_UINT64   2232
01110  * wd_1:    KEYTYP_STRING   /SUM0/D2918/D2232
01111  * tapeid_1:    KEYTYP_STRING   000002S1
01112  * tapefilenum_1:   KEYTYP_INT  1
01113  * online_status_2: KEYTYP_STRING   N
01114  * archive_status_2:    KEYTYP_STRING   Y
01115  * bytes_2: KEYTYP_DOUBLE              1.200000e+08
01116  * create_sumid_2:  KEYTYP_UINT64   623
01117  * ds_index_2:  KEYTYP_UINT64   2233
01118  * wd_2:    KEYTYP_STRING   /SUM0/D7844/D2233
01119  * tapeid_2:    KEYTYP_STRING   000003S1
01120  * tapefilenum_2:   KEYTYP_INT  1
01121  * offline: KEYTYP_INT  1
01122  * ds_index:    KEYTYP_UINT64   7844
01123  * partn_name:  KEYTYP_STRING   /SUM0/D7844
01124  * rootwd_2:    KEYTYP_STRING   /SUM0/D7844
01125  * offcnt:  KEYTYP_INT  1
01126  * OP:  KEYTYP_STRING   rd
01127  * sim: KEYTYP_INT  0
01128  * STATUS:  KEYTYP_INT  0
01129  * reqofflinenum:   KEYTYP_INT  2
01130 */
01131 KEY *sumrespdo_1(KEY *params)
01132 {
01133   FILE *fin;
01134   uint64_t uid;
01135   int pidcall;
01136   int found = 0;
01137   char idstr[128], string[196], pidstr[80];
01138   char *hostcall, *newstr;
01139 
01140   if(findkey(params, "DEBUGFLG")) {
01141   debugflg = getkey_int(params, "DEBUGFLG");
01142   if(debugflg) {
01143     write_log("!!Keylist in sumrespdo_1() is:\n");
01144     keyiterate(logkey, params);
01145   }
01146   }
01147   retlist = newkeylist();
01148   add_keys(params, &retlist);
01149   current_client = (CLIENT *)getkey_fileptr(params, "current_client");
01150   rinfo = 0;
01151   send_ack();
01152   //If keyword pidcaller is found it means that this is a tape read
01153   //return from tape_svc from an original SUM_get() call by a user.
01154   //Make sure the orig process is  still running, else
01155   //if you try to return info to it this Sget process will go away.
01156   if(findkey(params, "pidcaller")) {
01157     pidcall = getkey_int(params, "pidcaller");
01158     hostcall = getkey_str(params, "hostcaller");
01159     sprintf(idstr, "ssh -o \"StrictHostKeyChecking no\" %s ps -p %d -o pid= -o cmd=", hostcall, pidcall);
01160     if(fin = popen(idstr, "r")) {
01161       sprintf(pidstr, "%d ", pidcall);
01162       while(fgets(string, sizeof string, fin)) {  //get ps line
01163         //newstr = trimwhitespace(string);
01164         if(strstr(string, pidstr)) { found = 1; }
01165       }
01166       pclose(fin);
01167     }
01168     if(!found) {                //the calling process is gone
01169       write_log("**Error: %s process is gone when tape rd completes\n",
01170                 getkey_str(params, "username"));
01171       return((KEY *)1);         // nothing will be sent
01172     }
01173   }
01174 
01175   return(retlist);
01176 }
01177 
01178 
01179 void write_time()
01180 {
01181   struct timeval tvalr;
01182   struct tm *t_ptr;
01183   char datestr[32];
01184 
01185   gettimeofday(&tvalr, NULL);
01186   t_ptr = localtime((const time_t *)&tvalr);
01187   sprintf(datestr, "%s", asctime(t_ptr));
01188   write_log("**** %s", datestr);
01189 }
base/sums/apps/xsum_svc_proc.c
