Ejemplo n.º 1
0
int MNodeVMListToXML(

  mnode_t *N,  /* I */
  mxml_t  *NE) /* I/O (modified,alloc) */

  {
  mln_t  *P;  /* VM list pointer */
  mvm_t  *V;
  mxml_t *VE;

  if ((N == NULL) || (NE == NULL))
    {
    return(FAILURE);
    }

  for (P = N->VMList;P != NULL;P = P->Next)
    {
    V = (mvm_t *)P->Ptr;

    if (V != NULL)
      {
      VE = NULL;

      MXMLCreateE(&VE,(char *)MXO[mxoxVM]);

      MVMToXML(V,VE,NULL);

      MXMLAddE(NE,VE);
      }
    }  /* END for (P) */

  return(SUCCESS);
  }  /* END MNodeVMListToXML() */
Ejemplo n.º 2
0
int MAcctToXML(

    mgcred_t *A, mxml_t **EP, int *SAList)

{
    int DAList[] = {mcaID, -1};

    int aindex;

    int *AList;

    char tmpString[MAX_MLINE];

    if ((A == NULL) || (EP == NULL)) return (FAILURE);

    if (SAList != NULL)
        AList = SAList;
    else
        AList = DAList;

    MXMLCreateE(EP, (char *)MXO[mxoAcct]);

    for (aindex = 0; AList[aindex] != -1; aindex++) {
        if ((MCredAToString((void *)A, mxoAcct, AList[aindex], tmpString, 0) ==
             FAILURE) ||
            (tmpString[0] == '\0')) {
            continue;
        }

        MXMLSetAttr(*EP, (char *)MCredAttr[AList[aindex]], tmpString,
                    mdfString);
    } /* END for (aindex) */

    return (SUCCESS);
} /* END MAcctToXML() */
Ejemplo n.º 3
0
void addxmlnode(

  mxml_t              *DE,
  struct batch_status *pbstat)

  {
  mxml_t *NE;
  mxml_t *AE;

  struct attrl *pat;

  NE = NULL;

  MXMLCreateE(&NE, "Node");

  MXMLAddE(DE, NE);

  /* add nodeid */

  AE = NULL;
  MXMLCreateE(&AE, "name");
  MXMLSetVal(AE, pbstat->name, mdfString);
  MXMLAddE(NE, AE);

  for (pat = pbstat->attribs;pat;pat = pat->next)
    {
    AE = NULL;

    if (pat->value == NULL)
      continue;

    MXMLCreateE(&AE, pat->name);

    MXMLSetVal(AE, pat->value, mdfString);

    MXMLAddE(NE, AE);
    }

  return;
  } /* END addxmlnode() */
Ejemplo n.º 4
0
int MUIRsvCtl(

  msocket_t *S,       /* I */
  mbitmap_t *AFlags,  /* I credential flags (bitmap of enum MRoleEnum) */
  char      *Auth)    /* I */

  {
  char Command[MMAX_NAME];
  char RsvExp[MMAX_LINE];

  char FlagString[MMAX_LINE];
  char ArgString[MMAX_LINE];

  marray_t RsvList;

  char tmpLine[MMAX_LINE << 3];

  char tmpName[MMAX_LINE];
  char tmpVal[MMAX_LINE];

  enum MRsvCtlCmdEnum CIndex;

  enum MRsvAttrEnum AIndex;

  int  rc;

  mrsv_t *R;

  mrm_t  *RM;

  mgcred_t *U = NULL;

  mbool_t IsAdmin;

  mxml_t *RE = NULL;
  mxml_t *WE = NULL;
  mxml_t *DE = NULL;

  int     rindex;

  mbitmap_t  Flags;

  mbool_t UseUIndex = FALSE;
  mbool_t UseGName  = FALSE;
  mbool_t AppendRsvExp = FALSE;

  mgcred_t *RU = NULL;
  mgcred_t *RG = NULL;
  mgcred_t *RA = NULL;
  mqos_t   *RQ = NULL;

  enum MFormatModeEnum DFormat = mfmNONE;

  const char *FName = "MUIRsvCtl";

  MDB(2,fUI) MLog("%s(S,%s)\n",
    FName,
    (Auth != NULL) ? Auth : "NULL");

  if (S == NULL)
    {
    return(FAILURE);
    }

  /* NOTE:  support create, destroy, list, modify */

  /* initialize values */

  S->WireProtocol = mwpS32;

  RsvExp[0] = '\0';

  /* process request */

  switch (S->WireProtocol)
    {
    case mwpXML:
    case mwpS32:

      {
      int WTok;
   
      /* FORMAT:  <Request action="X" object="Y"><Where/></Request> */

      char *ptr;

      if (S->RDE != NULL)
        {
        RE = S->RDE;
        }
      else if ((S->RPtr != NULL) &&
              ((ptr = strchr(S->RPtr,'<')) != NULL) &&
               (MXMLFromString(&RE,ptr,NULL,NULL) == FAILURE))
        {
        MDB(3,fUI) MLog("WARNING:  corrupt command '%100.100s' received\n",
          S->RBuffer);

        MUISAddData(S,"ERROR:    corrupt command received\n");

        return(FAILURE);
        }

      S->RDE = RE;

      if (MXMLGetAttr(RE,MSAN[msanAction],NULL,Command,sizeof(Command)) == FAILURE)
        {
        MDB(3,fUI) MLog("WARNING:  cannot locate command '%100.100s'\n",
          S->RBuffer);

        MUISAddData(S,"ERROR:    cannot locate command\n");

        return(FAILURE);
        }

      WTok = -1;

      while (MS3GetWhere(
          RE,
          &WE,
          &WTok,
          tmpName,          /* O */
          sizeof(tmpName),
          tmpVal,           /* O */
          sizeof(tmpVal)) == SUCCESS)
        {
        /* process 'where' constraints */

        AIndex = (enum MRsvAttrEnum)MUGetIndexCI(tmpName,MRsvAttr,FALSE,mraNONE);

        if ((AIndex == mraName) || (AIndex == mraUIndex) || (AIndex == mraRsvGroup))
          {
          if (AppendRsvExp == TRUE)
            {
            MUStrCat(RsvExp,",",sizeof(RsvExp));
            MUStrCat(RsvExp,tmpVal,sizeof(RsvExp));
            }
          else
            {
            MUStrCpy(RsvExp,tmpVal,sizeof(RsvExp));

            AppendRsvExp = TRUE;
            }

          if (AIndex == mraUIndex)
            UseUIndex = TRUE;
          else if (AIndex == mraRsvGroup)
            UseGName = TRUE;
          } 
        else
          {
          switch (AIndex)
            {
            case mraAAccount:

              if (MAcctFind(tmpVal,&RA) == FAILURE)
                {
                MUISAddData(S,"ERROR:    cannot locate requested account\n");

                return(FAILURE);
                }

              break;

            case mraAGroup:

              if (MGroupFind(tmpVal,&RG) == FAILURE)
                {
                MUISAddData(S,"ERROR:    cannot locate requested group\n");

                return(FAILURE);
                }

              break;

            case mraAQOS:

              if (MQOSFind(tmpVal,&RQ) == FAILURE)
                {
                MUISAddData(S,"ERROR:    cannot locate requested qos\n");

                return(FAILURE);
                }

              break;

            case mraAUser:

              if (MUserFind(tmpVal,&RU) == FAILURE)
                {
                MUISAddData(S,"ERROR:    cannot locate requested user\n");

                return(FAILURE);
                }

              break;

            default:

              MUISAddData(S,"ERROR:   incorrect reservation attribute\n");

              return(FAILURE);

              /* NOTREACHED */

              break;
            }   /* END switch (AIndex) */
          }     /* END else */
        }       /* END while (MXMLGetChild() == SUCCESS) */

      if (MXMLGetAttr(RE,MSAN[msanFlags],NULL,FlagString,sizeof(FlagString)) == SUCCESS)
        {
        bmfromstring(FlagString,MClientMode,&Flags);

        if (bmisset(&Flags,mcmXML))
          {
          DFormat = mfmXML;
          }
        else
          {
          DFormat = mfmNONE;
          }
        }

      MXMLGetAttr(RE,MSAN[msanArgs],NULL,ArgString,sizeof(ArgString));
      }  /* END BLOCK (case mwpXML/mwpS3) */

      break;

    default:

      /* not supported */

      MUISAddData(S,"ERROR:    corrupt command received\n");

      return(FAILURE);

      /*NOTREACHED*/

      break;
    }  /* END switch (S->WireProtocol) */

  /* process data */

  if ((CIndex = (enum MRsvCtlCmdEnum)MUGetIndexCI(
         Command,
         MRsvCtlCmds,
         FALSE,
         mrcmNONE)) == mrcmNONE)
    {
    MDB(3,fUI) MLog("WARNING:  unexpected subcommand '%s' received\n",
      Command);

    sprintf(tmpLine,"ERROR:    unexpected subcommand '%s'\n",
      Command);

    MUISAddData(S,tmpLine);

    return(FAILURE);
    }

  MUserAdd(Auth,&U);

  S->SBuffer[0] = '\0';

  switch (CIndex)
    {
      case mrcmCreate:
        {
        marray_t RList;

        char Buffer[MMAX_BUFFER];
        int  rc;

        Buffer[0] = 0;

        /* check for unauthorized peers exporting rsv */

        if ((Auth != NULL) && 
            (!strncasecmp(Auth,"peer:",strlen("peer:"))))
          {
          if (MRMFind(&Auth[strlen("peer:")],&RM) == FAILURE)
            {
            /* NYI */
            }
          else if (!bmisset(&RM->Flags,mrmfRsvImport))
            {
            MUISAddData(S,"rsv import not enabled for peer");
    
            return(FAILURE);
            }
          }

        MUArrayListCreate(&RList,sizeof(mrsv_t *),50);

        rc = MUIRsvCreate(
              RE,
              Auth,
              Buffer,          /* O */
              sizeof(Buffer),
              TRUE,
              FALSE,
              FALSE,
              &RList);
    
        if (DFormat == mfmXML)
          {
          if (MXMLCreateE(&S->SDE,(char *)MSON[msonData]) == FAILURE)
            {
            rc = FAILURE;
    
            MUISAddData(S,"ERROR:    internal error, cannot create response\n");
            }
          else if (rc == SUCCESS)
            {
            mrsv_t *R;
    
            int rindex;
    
            mxml_t *RE;
    
            DE = S->SDE;
    
            for (rindex = 0;rindex < RList.NumItems;rindex++)
              {
              R = (mrsv_t *)MUArrayListGetPtr(&RList,rindex);

              RE = NULL;

              MXMLCreateE(&RE,(char *)MXO[mxoRsv]);

              MXMLSetVal(RE,R->Name,mdfString);

              MXMLAddE(DE,RE);
              }
            }
          else
            {
            MUISAddData(S,Buffer);
            }
          } /* END if (DFormat == mfmXML) */
        else
          {
          MUISAddData(S,Buffer);
          }

        MUArrayListFree(&RList);

        return(rc);
        }    /* END case mrcmCreate: */

      case mrcmFlush:
        {
        msrsv_t *SR;
    
        if (MSRFind(RsvExp,&SR,NULL) == SUCCESS)
          {
          int sindex;
    
          for (sindex = 0;sindex < MMAX_SRSV_DEPTH;sindex++)
            {
            SR->DisabledTimes[sindex] = 0;
            } 

          snprintf(tmpLine,sizeof(tmpLine),"SR[%s] successfully cleared disabled times\n",
            SR->Name);

          MUISAddData(S,tmpLine);

          return(SUCCESS);
          }
        }

      case mrcmQuery:

        bmset(&S->Flags,msftReadOnlyCommand);

        if (!strcasecmp(ArgString,"profile"))
          {
          mxml_t *DE;

          if ((S->SDE == NULL) && 
              (MXMLCreateE(&S->SDE,(char *)MSON[msonData]) == FAILURE))
            {
            MUISAddData(S,"ERROR:    cannot create response\n");

            return(FAILURE);
            }

          DE = S->SDE;

          return(__MUIRsvProfShow(S,U,RsvExp,&DE,NULL));
          }

      case mrcmList:

        bmset(&S->Flags,msftReadOnlyCommand);

        break;

      default:

        break;

    } /* end switch(CIndex) */

  MUArrayListCreate(&RsvList,sizeof(mrsv_t *),1);

  if (UseUIndex == TRUE)
    {
    char *ptr;
    char *TokPtr;

    /* locate by unique index */

    /* FORMAT:  <ID>[,<ID>]... */

    /* NOTE:  rsv id in format '<NAME>.<UID>' */

    ptr = MUStrTok(RsvExp,", \t\n:",&TokPtr);

    while (ptr != NULL)
      {
      if (MRsvFind(ptr,&R,mraUIndex) == SUCCESS)
        {
        MUArrayListAppendPtr(&RsvList,R);

        MDB(6,fUI) MLog("INFO:     reservation '%s' located by index\n",
          R->Name);
        }
      else
        {
        snprintf(tmpLine,sizeof(tmpLine),"ERROR:    cannot locate reservation %s\n",
          ptr);

        MUISAddData(S,tmpLine);
        }

      ptr = MUStrTok(NULL,", \t\n:",&TokPtr);
      }  /* END while (ptr != NULL) */
    }    /* END if (UseUIndex == TRUE) */
  else if (UseGName == TRUE)
    {
    rsv_iter RTI;

    char *ptr;
    char *TokPtr;

    /* allow multiple group selection */
    /* FORMAT:  <GID>[,<GID>]... */

    ptr = MUStrTok(RsvExp,", \t:",&TokPtr);

    while (ptr != NULL)
      {
      MRsvIterInit(&RTI);

      while (MRsvTableIterate(&RTI,&R) == SUCCESS)
        {
        if (R->RsvGroup == NULL)
          continue;

        if (strcmp(R->RsvGroup,ptr))
          continue;

        MUArrayListAppendPtr(&RsvList,R);

        MDB(6,fUI) MLog("INFO:     reservation '%s' located by group '%s'\n",
          R->Name,
          ptr);
        }  /* END while (MRsvTableIterate()) */

      ptr = MUStrTok(NULL,", \t:",&TokPtr);
      }    /* END while (ptr != NULL) */
    }    /* END if (UseGName == TRUE) */
  else
    {
    if (RsvExp[0] == '\0')
      {
      /* no reservation name received */

      snprintf(tmpLine,sizeof(tmpLine),"ERROR:    no reservation specified\n");

      MUISAddData(S,tmpLine);

      MUArrayListFree(&RsvList);

      return(FAILURE);
      }
    else if ((MUStringIsRE(RsvExp) == TRUE) || (!strcmp(RsvExp,"ALL")))
      {
      /* regular expression or special expression received */

      char tmpBuf[MMAX_BUFFER];
 
      tmpBuf[0] = '\0';

      if (MUREToList(
            RsvExp,
            mxoRsv,
            NULL,
            &RsvList,
            FALSE,
            tmpBuf,
            sizeof(tmpBuf)) == FAILURE)
        {
        snprintf(tmpLine,sizeof(tmpLine),"ERROR:    invalid expression '%s' : %s\n",
          RsvExp,
          tmpBuf);

        MUISAddData(S,tmpLine);

        MUArrayListFree(&RsvList);

        return(FAILURE);
        }
      }
    else
      {
      /* single reservation specified */

      mrsv_t *tmpR = NULL;

      if (MRsvFind(RsvExp,&tmpR,mraNONE) == FAILURE)
        {
        snprintf(tmpLine,sizeof(tmpLine),"ERROR:    invalid reservation specified '%s'\n",
          RsvExp);

        MUISAddData(S,tmpLine);

        MUArrayListFree(&RsvList);

        return(FAILURE);
        }
      else
        {
        MUArrayListAppendPtr(&RsvList,tmpR);
        }
      }   /* END else */

    if (RsvList.NumItems == 0)
      {
      if (!strcmp(RsvExp,"ALL"))
        {
        MUArrayListFree(&RsvList);

        return(SUCCESS);
        }
      else
        {
        char tmpLine[MMAX_LINE];

        snprintf(tmpLine,sizeof(tmpLine),"ERROR:  '%s' does not match any reservations\n",
          RsvExp);

        MUISAddData(S,tmpLine);

        MUArrayListFree(&RsvList);

        return(FAILURE);
        }
      }  /* END if (RsvList.NumItems == 0) */
    }    /* END else (UseUIndex == TRUE) */

  MDB(2,fUI) MLog("INFO:     performing '%s' operation on rsv expression '%s' (%d matches)\n",
    MRsvCtlCmds[CIndex],
    RsvExp,
    RsvList.NumItems);

  if (RsvList.NumItems <= 0)
    {
    /* no reservations found */

    sprintf(tmpLine,"ERROR:  could not locate any matching reservations\n");

    MUISAddData(S,tmpLine);

    MUArrayListFree(&RsvList);

    return(FAILURE);
    }
  
  rc = SUCCESS;

  for (rindex = 0;rindex < RsvList.NumItems;rindex++)
    {
    R = (mrsv_t *)MUArrayListGetPtr(&RsvList,rindex);
     
    /*
    if (((RA != NULL) && (J->Cred.A != RA)) ||
        ((RG != NULL) && (J->Cred.G != RG)) ||
        ((RQ != NULL) && (J->Cred.Q != RQ)) ||
        ((RU != NULL) && (J->Cred.U != RU)))
      {

      continue;
      }
    */
     
    /* get authorization */

    if (MUICheckAuthorization(
          U,
          NULL,
          (void *)R,
          mxoRsv,
          mcsMRsvCtl,
          CIndex,
          &IsAdmin,
          tmpLine,
          sizeof(tmpLine)) == FAILURE)
      {
      /* NOTE:  if rsv list is requested, do not report - 'not authorized' message
                for each rsv. */

      if ((CIndex != mrcmList) && (CIndex != mrcmQuery))
        {
        MUISAddData(S,tmpLine);
        MUISAddData(S,"\n");

        /* allow errno to be set on the command line to indicate error */

        rc = FAILURE;
        }

      /* If the final request failed, return failure otherwise continue
         to the next request */
      if (RsvList.NumItems - 1 == rindex)
        {
        MUArrayListFree(&RsvList);

        /* last request failed */

        if (CIndex == mrcmQuery)
          {
          /* Failed just means no reservations reported */

          return(SUCCESS);
          }

        return(FAILURE);
        }
      else
        {
        /* failure is recorded but entire request hasn't failed */

        continue;
        }
      }

    switch (CIndex)
      {
      case mrcmAlloc:

        {
        char EMsg[MMAX_LINE] = {0};
        char tmpName[MMAX_NAME];
        char tmpVal[MMAX_NAME];

        char GResType[MMAX_NAME];

        int len;

        GResType[0] = '\0';

        /* allocate additional requested resources to specified rsv */

        /* FORMAT:  mrsvctl -A gres.type=dvd vpc.3 */   

        /* parse request */

        if (MS3GetSet(
             RE,
             NULL,
             NULL,
             tmpName,
             sizeof(tmpName),
             tmpVal,
             sizeof(tmpVal)) == FAILURE)
          {
          sprintf(tmpLine,"ERROR:  no allocation resource specified\n");

          MUISAddData(S,tmpLine);

          MUArrayListFree(&RsvList);

          return(FAILURE);
          }
     
        if (!strcasecmp(tmpName,"resource"))
          {
          len = strlen("gres.type=");

          if (!strncasecmp(tmpVal,"gres.type=",len))
            {
            MUStrCpy(GResType,&tmpVal[len],sizeof(GResType));
            }
          }

        if (GResType[0] == '\0')
          {
          sprintf(tmpLine,"ERROR:  no allocation resource specified\n");

          MUISAddData(S,tmpLine);

          MUArrayListFree(&RsvList);

          return(FAILURE);
          }
 
        /* create pseudo job */
        rc = MRsvAllocateGResType(R,GResType,EMsg);

        MUISAddData(S,EMsg);

        MUArrayListFree(&RsvList);

        return(rc);
        }  /* END case mrcmAlloc */

        /*NOTREACHED*/

        break;

      case mrcmCreate:

        {
        /* should not be reached (handled above) */

        rc = FAILURE;

        sprintf(tmpLine,"ERROR:  create failed - internal error\n");

        MUISAddData(S,tmpLine);

        MUArrayListFree(&RsvList);

        return(rc);
        }  /* END case mrcmCreate */

        /*NOTREACHED*/

        break;

      case mrcmDestroy:

        {
        char tmpName[MMAX_NAME];

        if (bmisset(&R->Flags,mrfStatic))
          {
          sprintf(tmpLine,"ERROR:  cannot release 'static' reservation %s\n",
            R->Name);

          MUISAddData(S,tmpLine);

          continue;
          }

        if (bmisset(&R->Flags,mrfParentLock))
          {
          sprintf(tmpLine,"ERROR:  cannot release 'locked' reservation %s - must remove parent object\n",
            R->Name);

          MUISAddData(S,tmpLine);

          continue;
          }

        MUStrCpy(tmpName,R->Name,sizeof(tmpName));

        R->CancelIsPending = TRUE;

        if (bmisset(&R->Flags,mrfStanding))
          {
          int sindex;

          msrsv_t *SR = NULL;

          /* set enabletime to the end of this reservation */

          if (MSRFind(R->RsvParent,&SR,NULL) == SUCCESS)
            {
            for (sindex = 0;sindex < MMAX_SRSV_DEPTH;sindex++)
              {
              if ((SR->DisabledTimes[sindex] == 0) ||
                  (SR->DisabledTimes[sindex] == 1))
                {
                if (R->EndTime == MMAX_TIME - 1)
                  SR->DisabledTimes[sindex] = MMAX_TIME;
                else
                  SR->DisabledTimes[sindex] = R->EndTime;

                break;
                }
              }    /* END for (sindex) */
            }      /* END if (MSRFind(R->RsvGroup,&SR) == SUCCESS) */
          else
            {
            sprintf(tmpLine,"WARNING:  cannot locate rsv parent\n");

            MUISAddData(S,tmpLine);

            MDB(3,fUI) MLog("WARNING:  cannot locate parent '%s' for rsv '%s'\n",
              (R->RsvGroup != NULL) ? R->RsvGroup : "NULL",
              R->Name);
            }
          }        /* END if (bmisset(&R->Flags,mrfStanding)) */

        R->EndTime = MSched.Time - 1;
        R->ExpireTime = 0;

        snprintf(tmpLine,sizeof(tmpLine),"reservation %s destroyed by %s",
          tmpName,
          Auth);
          
        MOWriteEvent(R,mxoRsv,mrelRsvCancel,tmpLine,MStat.eventfp,NULL);

        if ((long)R->StartTime <= MUIDeadLine)
          {
          /* adjust UI phase wake up time */

          if (MSched.AdminEventAggregationTime >= 0)
            MUIDeadLine = MIN(MUIDeadLine,(long)MSched.Time + MSched.AdminEventAggregationTime);
          }

        /* remove reservation */

        if ((R->Type = mrtJob) && (R->J != NULL))
          {
          /* Expiring job reservations are not released in MRsvCheckStatus(), they are extended.
             So to remove the reservation you must do it outside MRsvCheckStatus() */

          MJobReleaseRsv(R->J,TRUE,TRUE);

          R = NULL;
          }
        else
          {
          MRsvCheckStatus(NULL);
          }

        MOSSyslog(LOG_INFO,tmpLine);

        sprintf(tmpLine,"reservation %s successfully released\n",
          tmpName);
        }    /* END case mrcmDestroy */

        MUISAddData(S,tmpLine);

        continue;

        /*NOTREACHED*/

        break;

      case mrcmFlush:

        {
        msrsv_t *SR;

        int sindex;

        if (MSRFind(R->RsvGroup,&SR,NULL) == FAILURE)
          {
          sprintf(tmpLine,"reservation '%s' does not belong to a standing reservation\n",
            R->Name);

          MUISAddData(S,tmpLine);

          rc = FAILURE;

          break;
          }

        for (sindex = 0;sindex < MMAX_SRSV_DEPTH;sindex++)
          {
          SR->DisabledTimes[0] = 0;
          } 

        sprintf(tmpLine,"SR[%s] successfully cleared disabled times\n",
          SR->Name);

        MUISAddData(S,tmpLine);
        }

        break;

      case mrcmJoin:

        {
        char EMsg[MMAX_LINE] = {0};

        mrsv_t *CR = NULL;

        if (MRsvFind(ArgString,&CR,mraNONE) == SUCCESS)
          {
          rc = MRsvJoin(R,CR,EMsg);

          if (rc == FAILURE)
            {
            sprintf(tmpLine,"could not join rsv '%s' to rsv '%s' -- %s\n",
              R->Name,
              ArgString,
              EMsg);

            MUISAddData(S,tmpLine);
            }
          else
            {
            sprintf(tmpLine,"successfully joined rsv '%s' to rsv '%s'\n",
              ArgString,
              R->Name);

            MHistoryAddEvent(R,mxoRsv);

            MUISAddData(S,tmpLine);
            }
          }
        else
          {
          sprintf(tmpLine,"invalid reservation '%s'\n",
            ArgString);

          MUISAddData(S,tmpLine);
          }
        }   /* END case mrcmJoin */

        break;

      case mrcmSignal:

        {
        enum MTrigTypeEnum Signal = (enum MTrigTypeEnum)MUGetIndexCI(ArgString,MTrigType,FALSE,mttNONE);

        if (Signal == mttNONE)
          {
          sprintf(tmpLine,"invalid signal '%s' for rsv '%s'\n",
            ArgString,
            R->Name);

          MUISAddData(S,tmpLine);
          }
        else
          {
          MOReportEvent((void *)R,NULL,mxoRsv,Signal,MSched.Time,TRUE);

          sprintf(tmpLine,"signal '%s' successfully sent to rsv '%s'\n",
            MTrigType[Signal],
            R->Name);

          MUISAddData(S,tmpLine);
          }
        }  /* END BLOCK (case mrcmSignal) */

        break;

      case mrcmList:

        /* NOTE:  only add matching reservations */

        /* NOTE:  global list handled outside of loop */

        MUISAddData(S,R->Name);
        MUISAddData(S," ");

        break;

      case mrcmMigrate:

        {
        char EMsg[MMAX_LINE] = {0};

        mrsv_t *CR = NULL;

        if (MRsvFind(ArgString,&CR,mraNONE) == SUCCESS)
          {
          rc = MRsvMigrate(R,CR,EMsg);

          if (rc == FAILURE)
            {
            sprintf(tmpLine,"could not migrate rsv '%s' to rsv '%s' -- %s\n",
              R->Name,
              ArgString,
              EMsg);

            MUISAddData(S,tmpLine);
            }
          else
            {
            sprintf(tmpLine,"successfully migrated rsv '%s' to rsv '%s'\n",
              ArgString,
              R->Name);

            MHistoryAddEvent(R,mxoRsv);

            MUISAddData(S,tmpLine);
            }
          }
        else
          {
          sprintf(tmpLine,"invalid reservation '%s'\n",
            ArgString);

          MUISAddData(S,tmpLine);
          }
        }   /* END case mrcmJoin */

        break;


        break;

      case mrcmModify:

        {
        char EMsg[MMAX_LINE] = {0};

        rc = MUIRsvCtlModify(R,RE,EMsg);

        MUISAddData(S,EMsg);

        if (rc == FAILURE)
          {
          MUArrayListFree(&RsvList);

          return rc;
          }
        }   /* END BLOCK (case mrcmModify) */

        break;

      case mrcmQuery:

        /* NOTE: "profile" handled above */

        bmset(&S->Flags,msftReadOnlyCommand);

        if (!strcmp(ArgString,"resources"))
          {
          /* list allocated resources */

          if (!MNLIsEmpty(&R->NL))
            {
            MNLToString(
              &R->NL,
              bmisset(&Flags,mcmVerbose),
              ",",
              '\0',
              tmpLine,
              sizeof(tmpLine));

            MUISAddData(S,tmpLine);
            }

          MUArrayListFree(&RsvList);

          return(SUCCESS);
          }  /* END if (!strcmp(ArgString,"resources")) */
        else if (!strcmp(ArgString,"export"))
          {
          mxml_t *DE;

          if ((S->SDE == NULL) && 
              (MXMLCreateE(&S->SDE,(char *)MSON[msonData]) == FAILURE))
            {
            MUISAddData(S,"ERROR:    cannot create response\n");

            MUArrayListFree(&RsvList);

            return(FAILURE);
            }

          DE = S->SDE;
 
          if (MUIExportRsvQuery(
                R,
                NULL,
                Auth,
                DE,
                0) == FAILURE)
            {
            MUArrayListFree(&RsvList);

            return(FAILURE);
            }
          }
        else if (!strcmp(ArgString,"wiki"))
          {
          mstring_t String(MMAX_LINE);

          MRsvToWikiString(R,NULL,&String);

          MUISAddData(S,String.c_str());
          } /* END if (!strcmp(ArgString,"wiki")) */
        else
          {
          /* diagnose/display rsv state/config */

          char    DiagOpt[MMAX_NAME];

          mxml_t *DE = NULL;
          mxml_t *RE = NULL;

          const enum MRsvAttrEnum RAList[] = {
            mraName,
            mraAAccount,
            mraAGroup,
            mraAUser,
            mraAQOS,
            mraAllocNodeCount,
            mraAllocNodeList,
            mraAllocProcCount,
            mraAllocTaskCount,
            mraComment,
            mraEndTime,
            mraExpireTime,
            mraFlags,
            mraGlobalID,
            mraHostExp,
            mraLabel,
            mraLogLevel,
            mraOwner,
            mraPartition,
            mraProfile,
            mraReqArch,
            mraReqFeatureList,
            mraReqMemory,
            mraReqNodeCount,
            mraReqNodeList,
            mraReqOS,
            mraReqTaskCount,
            mraResources,
            mraRsvGroup,
            mraRsvParent,
            mraSID,
            mraStartTime,
            mraStatCAPS,
            mraStatCIPS,
            mraStatTAPS,
            mraStatTIPS,
            mraSubType,
            mraTrigger,
            mraType,
            mraVariables,
            mraVMList,
            mraNONE };

          MUStrCpy(DiagOpt,R->Name,sizeof(DiagOpt));

          /* check to see if the socket's return data xml is initialized */

          if (S->SDE == NULL)
            {
            if (MXMLCreateE(&S->SDE,(char *)MSON[msonData]) == FAILURE)
              {
              MUISAddData(S,"ERROR:    cannot create response\n");

              MUArrayListFree(&RsvList);

              return(FAILURE);
              }
            }

          DE = S->SDE;

          MXMLCreateE(&RE,(char *)MXO[mxoRsv]);

          MXMLAddE(DE,RE);

          MRsvToXML(R,&RE,(enum MRsvAttrEnum *)RAList,NULL,TRUE,mcmNONE);

          /* NOTE:  do not return, append data to buffer and continue */
          }  /* END else() */

        break;

      default:

        /* NO-OP */

        break;
      }        /* END switch (CIndex) */
    }          /* END for (rindex) */

  MUArrayListFree(&RsvList);

  return(rc);
  }  /* END MUIRsvCtl() */
Ejemplo n.º 5
0
int MCPStoreResList(
 
  mckpt_t  *CP,
  mres_t  **RL)
 
  {
  int     rindex;

  mres_t *R;
 
  char   tmpBuf[MAX_MBUFFER];

  mxml_t *E = NULL;
 
  const char *FName = "MCPStoreResList";
 
  DBG(3,fCKPT) DPrint("%s(CP,RL)\n",
    FName);
 
  if ((CP == NULL) || (RL == NULL))
    {
    return(FAILURE);
    }
 
  for (rindex = 0;rindex < MAX_MRES;rindex++)
    {
    R = RL[rindex];
 
    if ((R == NULL) || (R->Name[0] == '\0'))
      break;
 
    if (R->Name[0] == '\1')
      {
      DBG(7,fCKPT) DPrint("INFO:     skipping empty reservation[%02d]\n",
        rindex);
 
      continue;
      } 
 
    /* ignore job and SR based reservations */
 
    if ((R->Type == mrtJob) || (R->Flags & (1 << mrfStandingRes)))
      {
      DBG(6,fCKPT) DPrint("INFO:     ignoring reservation[%02d] '%s'\n",
        rindex,
        R->Name);
 
      continue;
      }
 
    DBG(4,fCKPT) DPrint("INFO:     checkpointing Res[%02d] '%s'\n",
      rindex,
      R->Name);
 
    MXMLCreateE(&E,"res");
 
    MResToXML(R,E,NULL);
 
    MXMLToString(E,tmpBuf,MAX_MBUFFER,NULL,TRUE);
 
    MXMLDestroyE(&E);

    MCPStoreObj(CP->fp,mcpRes,R->Name,tmpBuf); 
    }    /* END for (rindex) */
 
  return(SUCCESS);
  }  /* END MCPStoreResList() */
Ejemplo n.º 6
0
int MVCToXML(
  mvc_t  *VC,
  mxml_t *VE,
  enum MVCAttrEnum *SAList,
  mbool_t FullXML)

  {
  const enum MVCAttrEnum DAList[] = {
    mvcaACL,         /* ACL */
    mvcaCreateTime,  /* time VC was created */
    mvcaCreator,     /* creator */
    mvcaDescription, /* description */
    mvcaFlags,       /* flags (from MVCFlagEnum) */
    mvcaJobs,        /* names of jobs in VC */
    mvcaMessages,    /* VC messages */
    mvcaName,        /* VC name */
    mvcaNodes,       /* names of nodes in VC */
    mvcaOwner,       /* VC owner */
    mvcaParentVCs,   /* names of parent VCs */
    mvcaReqStartTime,/* requested start time for guaranteed start time */
    mvcaRsvs,        /* names of rsvs in VC */
    mvcaVariables,   /* VC vars */
    mvcaVCs,         /* sub-VCs */
    mvcaVMs,         /* names of VMs in VC */
    mvcaThrottlePolicies, /* throttling policies attached to VC via mvcctl */
    mvcaNONE };

  int aindex;

  enum MVCAttrEnum *AList;
  mbool_t PrintACL = FALSE;

  if ((VC == NULL) || (VE == NULL))
    {
    return(FAILURE);
    }

  if (SAList != NULL)
    AList = SAList;
  else
    AList = (enum MVCAttrEnum *)DAList;

  mstring_t tmpBuf(MMAX_LINE);

  for (aindex = 0;AList[aindex] != mvcaNONE;aindex++)
    {
    if (AList[aindex] == mvcaACL)
      {
      PrintACL = TRUE;

      continue;
      }

    if ((FullXML == TRUE) && 
         ((AList[aindex] == mvcaJobs) ||
          (AList[aindex] == mvcaNodes) ||
          (AList[aindex] == mvcaRsvs) ||
          (AList[aindex] == mvcaVMs) ||
          (AList[aindex] == mvcaVCs) ||
          (AList[aindex] == mvcaParentVCs)))
      continue;

    if (AList[aindex] == mvcaVariables)
      {
      MUAddVarsToXML(VE,&VC->Variables);

      continue;
      }
    else if ((AList[aindex] == mvcaMessages) &&
              (VC->MB != NULL))
      {
      /* Use the already existing MMB to XML functionality */

      mxml_t *ME = NULL;

      MXMLCreateE(&ME,(char *)MVCAttr[mvcaMessages]);

      MMBPrintMessages(VC->MB,mfmXML,TRUE,-1,(char *)ME,0);

      MXMLAddE(VE,ME);

      continue;
      }

    MVCAToMString(VC,AList[aindex],&tmpBuf);

    if (!tmpBuf.empty())
      {
      MXMLSetAttr(VE,(char *)MVCAttr[AList[aindex]],tmpBuf.c_str(),mdfString);
      }
    }  /* END for (aindex) */

  if (FullXML)
    {
    /* If you specify FullXML, you get all of the children.  Don't check AList */

    mln_t *tmpL;
    mxml_t *CE;

    if (VC->Jobs != NULL)
      {
      mjob_t *J;

      enum MJobAttrEnum JAList[] = {
        mjaJobID,
        mjaAccount,
        mjaArgs,
        mjaClass,
        mjaCmdFile,
        mjaDescription,
        mjaFlags,
        mjaGroup,
        mjaPAL,
        mjaQOS,
        mjaRCL,
        mjaReqAWDuration,
        mjaReqHostList,    /**< requested hosts */
        mjaReqNodes,
        mjaReqReservation,
        mjaRM,
        mjaStatPSDed,
        mjaSysPrio,
        mjaTemplateFlags,
        mjaTrigger,
        mjaUser,
        mjaVMUsagePolicy,
        mjaNONE };

      for (tmpL = VC->Jobs;tmpL != NULL;tmpL = tmpL->Next)
        {
        CE = NULL;
        J = (mjob_t *)tmpL->Ptr;

        MJobToXML(J,&CE,JAList,NULL,NULL,FALSE,FALSE);

        MXMLAddE(VE,CE);
        }
      }  /* END if (VC->Jobs != NULL) */

    if (VC->Nodes != NULL)
      {
      mnode_t *N;

      enum MNodeAttrEnum NAList[] = {
        mnaNodeID,
        mnaArch,
        mnaAvlGRes,
        mnaCfgGRes,
        mnaAvlTime,      
        mnaFeatures,
        mnaHopCount,
        mnaLoad,
        mnaNodeState,
        mnaOS,
        mnaOSList,
        mnaProcSpeed,
        mnaRADisk,
        mnaRAMem,
        mnaRAProc,
        mnaRASwap,
        mnaRCDisk,
        mnaRCMem,
        mnaRCProc,
        mnaRCSwap,
        mnaSpeed,
        mnaVMOSList,
        mnaNONE };

      for (tmpL = VC->Nodes;tmpL != NULL;tmpL = tmpL->Next)
        {
        CE = NULL;
        N = (mnode_t *)tmpL->Ptr;

        MXMLCreateE(&CE,(char *)MXO[mxoNode]);
        MNodeToXML(N,CE,NAList,0,FALSE,FALSE,NULL,NULL);

        MXMLAddE(VE,CE);
        }
      }  /* END if (VC->Nodes != NULL) */

    if (VC->Rsvs != NULL)
      {
      mrsv_t *R;

      for (tmpL = VC->Rsvs;tmpL != NULL;tmpL = tmpL->Next)
        {
        CE = NULL;
        R = (mrsv_t *)tmpL->Ptr;

        MRsvToXML(R,&CE,NULL,NULL,FALSE,mcmNONE);

        MXMLAddE(VE,CE);
        }
      }  /* END if (VC->Rsvs != NULL) */

    if (VC->VMs != NULL)
      {
      mvm_t *V;

      for (tmpL = VC->VMs;tmpL != NULL;tmpL = tmpL->Next)
        {
        CE = NULL;
        V = (mvm_t *)tmpL->Ptr;

        MXMLCreateE(&CE,(char *)MXO[mxoxVM]);
        MVMToXML(V,CE,NULL);

        MXMLAddE(VE,CE);
        }
      }  /* END if (VC->VMs != NULL) */

    if (VC->VCs != NULL)
      {
      mvc_t *V;

      for (tmpL = VC->VCs;tmpL != NULL;tmpL = tmpL->Next)
        {
        CE = NULL;
        V = (mvc_t *)tmpL->Ptr;

        MXMLCreateE(&CE,(char *)MXO[mxoxVC]);
        MVCToXML(V,CE,SAList,FullXML);

        MXMLAddE(VE,CE);
        }
      }  /* END if (VC->VCs != NULL) */
    }  /* END if (FullXML) */

  if ((PrintACL == TRUE) && (!MACLIsEmpty(VC->ACL)))
    {
    macl_t *tACL;
    mxml_t *AE = NULL;

    for (tACL = VC->ACL;tACL != NULL;tACL = tACL->Next)
      {
      AE = NULL;

      MACLToXML(tACL,&AE,NULL,FALSE);

      MXMLAddE(VE,AE);
      }
    }  /* END if ((PrintACL == TRUE) && (!MACLIsEmpty(VC->ACL))) */

  return(SUCCESS);
  }  /* END MVCToXML() */
Ejemplo n.º 7
0
Archivo: MMB.c Proyecto: dhh1128/cbase
char *MMBPrintMessages(

  mmb_t               *Head,        /* I (optional) */
  enum MFormatModeEnum DFormat,     /* I */
  mbool_t              ShowVerbose, /* I */
  int                  MinPrio,     /* I (only display messages of this priority or higher) */
  char                *Buf,         /* O (optional,char * or mxml_t *) */
  int                  BufSize)     /* I */

  {
  mmb_t *mptr;

  char *BPtr = NULL;
  int   BSpace;

  char *hptr = NULL;

  static char tmpMBuf[MMAX_BUFFER];

  char  tmpLine[MMAX_LINE << 2];
  char  tmpLine2[MMAX_LINE << 2];

  if (Buf != NULL)
    {
    BPtr = Buf;
    BSpace = BufSize;
    }
  else
    {
    BPtr = tmpMBuf;
    BSpace = sizeof(tmpMBuf);
    }

  hptr = BPtr;

  switch (DFormat)
    {
    case mfmXML:
    case mfmAVP:  /* KLUDGE - use AVP to create packed XML data */

      {
      mxml_t *DE;
      mxml_t *CE;
      mxml_t *UE;

      int     count = 0;

      DE = (mxml_t *)Buf;

      if (DE == NULL)
        break;

      if (Head == NULL)
        {
        /* header not required in XML */

        break;
        }  /* END if (Head == NULL) */

      if (DFormat == mfmAVP)
        {
        /* initialize temporary parent XML element */

        UE = NULL;
        }
    
      for (mptr = Head;mptr != NULL;mptr = mptr->Next)
        {
        if (mptr->Priority < MinPrio)
          continue;

        CE = NULL;

        MXMLCreateE(&CE,"message");

        MXMLSetAttr(CE,"index",(void *)&count,mdfInt);
        MXMLSetAttr(CE,(char *)MMBAttr[mmbaCTime],(void *)&mptr->CTime,mdfLong);

        if (mptr->Owner != NULL)
          MXMLSetAttr(CE,(char *)MMBAttr[mmbaOwner],(void *)mptr->Owner,mdfString);

        MXMLSetAttr(CE,(char *)MMBAttr[mmbaPriority],(void *)&mptr->Priority,mdfInt);
        MXMLSetAttr(CE,(char *)MMBAttr[mmbaCount],(void *)&mptr->Count,mdfInt);
        MXMLSetAttr(CE,(char *)MMBAttr[mmbaExpireTime],(void *)&mptr->ExpireTime,mdfLong);
        MXMLSetAttr(CE,(char *)MMBAttr[mmbaType],(void *)MMBType[mptr->Type],mdfString);

        if (mptr->Data != NULL)
          {
          if (strchr(mptr->Data,'\n') != NULL)
            {
            char tmpData[MMAX_BUFFER];

            MUStrCpy(tmpData,mptr->Data,sizeof(tmpData));

            MUStrReplaceChar(tmpData,'\n',' ',FALSE);

            MXMLSetAttr(CE,(char *)MMBAttr[mmbaData],(void *)tmpData,mdfString);
            }
          else
            { 
            MXMLSetAttr(CE,(char *)MMBAttr[mmbaData],(void *)mptr->Data,mdfString);
            }
          }

        if (mptr->Label != NULL)
          MXMLSetAttr(CE,(char *)MMBAttr[mmbaLabel],(void *)mptr->Label,mdfString);

        if (DFormat == mfmAVP)
          {
          /* create/update temporary XML */

          if (UE == NULL)
            MXMLCreateE(&UE,(char*) MSON[msonData]);

          MXMLAddE(UE,CE);
          }
        else
          {
          MXMLAddE(DE,CE);
          }

        count++;
        }  /* END for (mptr) */

      if ((DFormat == mfmAVP) && (UE != NULL))
        {
        /* NOTE:  Buf is mxml_t *, do not populate */

        MUSNInit(&BPtr,&BSpace,tmpMBuf,sizeof(tmpMBuf));

        hptr = BPtr;

        MXMLToString(UE,tmpLine,sizeof(tmpLine),NULL,TRUE);

        MXMLDestroyE(&UE);

        MUStringPack(tmpLine,tmpLine2,sizeof(tmpLine2));

        MUSNCat(&BPtr,&BSpace,tmpLine2);
        }
      }    /* END BLOCK */

      break;

    case mfmHuman:
    default:

      {
      int count = 0;

      char tmpBuf[MMAX_NAME];
      char label[MMAX_NAME];

      if (Buf != NULL)
        MUSNInit(&BPtr,&BSpace,Buf,BufSize);
      else
        MUSNInit(&BPtr,&BSpace,tmpMBuf,sizeof(tmpMBuf));

      hptr = BPtr;

      if (Head == NULL)
        {
        if (ShowVerbose == TRUE)
          {
          MUSNPrintF(&BPtr,&BSpace,"%-7s %10s %10s %8.8s %4.4s %3.3s %s\n",
            "Label",
            "CreateTime",
            "ExpireTime",
            "Owner",
            "Prio",
            "Num",
            "Message");
          }

        break;
        }  /* END if (Head == NULL) */

      for (mptr = Head;mptr != NULL;mptr = mptr->Next)
        {
        if (mptr->Priority < MinPrio)
          continue;

        if (mptr->Label != NULL)
          {
          strncpy(label,mptr->Label,sizeof(label));
          }
        else
          {
          sprintf(label,"%d",
            count);
          }

        count++;

        if (ShowVerbose == TRUE)
          {
          char TString[MMAX_LINE];
          /* display w/relative time */

          MULToTString(mptr->CTime - MSched.Time,TString);

          strcpy(tmpBuf,TString);

          MULToTString(mptr->ExpireTime - MSched.Time,TString);

          MUSNPrintF(&BPtr,&BSpace,"%-8.8s %10s %10s %8.8s %4d %3d %s\n",
            label,
            tmpBuf,
            TString,
            (mptr->Owner != NULL) ? mptr->Owner : "N/A",
            mptr->Priority,
            mptr->Count,
            (mptr->Data != NULL) ? mptr->Data : "-");
          }
        else
          {
          if (mptr->Source != NULL)
            {
            MUSNPrintF(&BPtr,&BSpace,"Message[%.8s] (from %s) %s\n",
              label,
              mptr->Source,
              (mptr->Data != NULL) ? mptr->Data : "-");
            }
          else
            {
            MUSNPrintF(&BPtr,&BSpace,"Message[%.8s] %s\n",
              label,
              (mptr->Data != NULL) ? mptr->Data : "-");
            }
          }
        }  /* END for (mptr) */
      }    /* END BLOCK (case mfmHuman) */

      break;
    }  /* END switch (DFormat) */

  return(hptr);
  }  /* END MMBPrintMessages() */
Ejemplo n.º 8
0
int MUIRsvDiagnose(

  mbitmap_t *AFlagBM,
  char      *Auth,
  mrsv_t    *SR,
  mstring_t *String,
  mpar_t    *P,
  char      *DiagOpt,
  enum MFormatModeEnum DFormat,
  mbitmap_t *Flags,
  enum MRsvTypeEnum ResType)

  {
  rsv_iter RTI;

  int nindex;

  mnode_t *N;
  mjob_t  *J;

  int   TotalRC;
  int   TotalRsvStatePC;
  int   TotalRsvAPC;

  mrsv_t *R;

  mxml_t *DE = NULL;
  mxml_t *RE = NULL;

  mbool_t IsAdmin;

  mgcred_t *U;

  const char *FName = "MUIRsvDiagnose";

  MDB(3,fUI) MLog("%s(Auth,String,%s,%s,%s,%s)\n",
    FName,
    (P != NULL) ? P->Name : "NULL",
    DiagOpt,
    MFormatMode[DFormat],
    MRsvType[ResType]);

  if (String == NULL)
    {
    return(FAILURE);
    }

  /* check all reservations */

  MDB(4,fUI) MLog("INFO:     diagnosing rsv table (%d slots)\n",
    MSched.M[mxoRsv]);

  if (DFormat == mfmXML)
    {
    /* NOTE:  do not wrap specific rsv requests in Data element */

    if (SR == NULL)
      {
      DE = NULL;

      MXMLCreateE(&DE,(char *)MSON[msonData]);
      }
    }
  else
    {
    /* create header */

    MStringAppend(String,"Diagnosing Reservations\n");

    MRsvShowState(
      NULL,
      Flags,
      NULL,
      String,
      DFormat);
    }

  /* initialize statistics */

  TotalRC = 0;

  TotalRsvAPC     = 0;
  TotalRsvStatePC = 0;

  for (nindex = 0;nindex < MSched.M[mxoNode];nindex++)
    {
    N = MNode[nindex];

    if ((N == NULL) || (N->Name[0] == '\0'))
      break;

    if (N->Name[0] == '\1')
      continue;

    if (N->State == mnsReserved)
      TotalRsvStatePC += N->CRes.Procs;
    }  /* END for (nindex) */

  if (bmisset(AFlagBM,mcalAdmin1) ||
      bmisset(AFlagBM,mcalAdmin2) ||
      bmisset(AFlagBM,mcalAdmin3))
    IsAdmin = TRUE;
  else
    IsAdmin = FALSE;

  MUserAdd(Auth,&U);

  MRsvIterInit(&RTI);

  while (MRsvTableIterate(&RTI,&R) == SUCCESS)
    {
    if ((SR != NULL) && (R != SR))
      continue;

    if ((P != NULL) && (P->Index > 0) && (P->Index != R->PtIndex))
      continue;

    if (strcmp(DiagOpt,NONE) && strcmp(DiagOpt,R->Name))
      {
      if ((R->Label == NULL) || strcmp(DiagOpt,R->Label)) 
        continue;
      }

    /* If a ResType is given (-w type=ResType) and it is not equal to this reservation's type, don't print */

    if ((ResType != mrtNONE) && (R->Type != ResType))
      continue;

    if (!bmisset(AFlagBM,mcalOwner) && (IsAdmin == FALSE))
      { 
      if (MUICheckAuthorization(
            U,
            NULL,
            (void *)R,
            mxoRsv,
            mcsDiagnose,
            mrcmQuery,
            NULL,
            NULL,
            0) == FAILURE)
        {
        /* no authority to diagnose reservation */

        continue;
        }
      }

    MDB(6,fUI) MLog("INFO:     evaluating Rsv '%s'\n",
      R->Name);

    if (DFormat == mfmXML)
      {
      RE = NULL;

      MXMLCreateE(&RE,(char *)MXO[mxoRsv]);

      if (SR == NULL)
        MXMLAddE(DE,RE);

      MRsvShowState(
        R,
        Flags,
        RE,  /* O */
        NULL,
        DFormat);
      }
    else
      {
      MRsvShowState(
        R,
        Flags,
        NULL, 
        String,
        DFormat);

      MRsvDiagnoseState(
        R,
        Flags,
        NULL,
        String,
        DFormat);
      }  /* END else (DFormat == mfmXML) */

    TotalRC++;

    if ((R->J != NULL) && ((R->Type == mrtJob) || (R->Type == mrtUser)))
      {
      /* determine allocated jobs associated with system jobs (user rsv) or regular jobs */

      J = R->J;

      if (MJOBISACTIVE(J))
        TotalRsvAPC += R->AllocPC;
      }

    if (SR != NULL)
      break;
    }  /* END while (MRsvTableIterate()) */

  if ((!strcmp(DiagOpt,NONE)) && !bmisset(AFlagBM,mcalOwner))
    {
    /* set global diagnostic messages */

    if (DFormat != mfmXML)
      {
      char *BPtr;
      int   BSpace;

      char MsgBuf[MMAX_BUFFER];

      MUSNInit(&BPtr,&BSpace,MsgBuf,sizeof(MsgBuf));

      MStringAppendF(String,"\nActive Reserved Processors: %d\n",
        TotalRsvAPC);

      if ((TotalRsvAPC + TotalRsvStatePC) != MPar[0].DRes.Procs)
        {
        MStringAppendF(String,"INFO:  active procs reserved does not equal active procs utilized (%d != %d)\n",
          TotalRsvAPC + TotalRsvStatePC,
          MPar[0].DRes.Procs);
        }

      MRsvDiagGrid(BPtr,BSpace,0);

      MStringAppend(String,MsgBuf);
      }  /* END if (DFormat != mfmXML) */
    }    /* END if (!strcmp(DiagOpt,NONE) */

  if (DFormat == mfmXML)
    {
    /* make into XML encoded string */

    if (MXMLToMString(
        (SR == NULL) ? DE : RE,
        String,
        NULL,
        TRUE) == FAILURE)
      {
      MDB(2,fUI) MLog("ALERT:    could not convert XML to string in %s\n",
        FName);
      }

    MXMLDestroyE(
      (SR == NULL) ? &DE : &RE);
    }  /* END if (DFormat == mfmXML) */

  return(SUCCESS);
  }  /* END MUIRsvDiagnose() */
Ejemplo n.º 9
0
int MVMToXML(

  mvm_t            *V,      /* I */
  mxml_t           *VE,     /* I/O (modified,alloc) */
  enum MVMAttrEnum *SAList) /* I (optional,terminated w/mvmaLAST) */

  {
  char tmpString[MMAX_LINE];

  enum MVMAttrEnum *AList;  /**< VM attribute list */

  int aindex;

  mbitmap_t BM;

  const enum MVMAttrEnum DAList[] = {
    mvmaActiveOS,
    mvmaADisk,
    mvmaAlias,
    mvmaAMem,
    mvmaAProcs,
    mvmaCDisk,
    mvmaCMem,
    mvmaCProcs,
    mvmaCPULoad,
    mvmaContainerNode,
    mvmaDDisk,
    mvmaDMem,
    mvmaDProcs,
    mvmaDescription,
    mvmaEffectiveTTL,
    mvmaFlags,
    mvmaGMetric,
    mvmaID,
    mvmaJobID,
    mvmaLastMigrateTime,
    mvmaLastSubState,
    mvmaLastSubStateMTime,
    mvmaLastUpdateTime,
    mvmaMigrateCount,
    mvmaNetAddr,
    mvmaNextOS,
    mvmaOSList,
    mvmaPowerIsEnabled,
    mvmaPowerState,
    mvmaProvData,
    mvmaRackIndex,
    mvmaSlotIndex,
    mvmaSovereign,
    mvmaSpecifiedTTL,
    mvmaStartTime,
    mvmaState,
    mvmaSubState,
    mvmaStorageRsvNames,
    mvmaVariables,
    mvmaLAST };

  if ((V == NULL) || (VE == NULL))
    {
    return(FAILURE);
    }
 
  if (SAList != NULL)
    AList = SAList;
  else
    AList = (enum MVMAttrEnum *)DAList;

  bmset(&BM,mcmXML);

  for (aindex = 0;AList[aindex] != mvmaLAST;aindex++)
    {
    if ((MVMAToString(V,NULL,AList[aindex],tmpString,sizeof(tmpString),&BM) == FAILURE) ||
        (tmpString[0] == '\0'))
      {
      continue;
      }

    if (AList[aindex] == mvmaVariables)
      {
      MUAddVarsToXML(VE,&V->Variables);

      continue;
      }

    MXMLSetAttr(VE,(char *)MVMAttr[AList[aindex]],tmpString,mdfString);
    }  /* END for (aindex) */

  /* Set GEvents */

  MGEventListToXML(VE,&V->GEventsList);

  MVMStorageMountsToXML(VE,V);

  /* Triggers */

  if (V->T != NULL)
    {
    mtrig_t *T;

    int tindex;
    mxml_t *TE = NULL;

    for (tindex = 0;tindex < V->T->NumItems;tindex++)
      {
      T = (mtrig_t *)MUArrayListGetPtr(V->T,tindex);

      if (MTrigIsReal(T) == FALSE)
        continue;

      TE = NULL;

      MXMLCreateE(&TE,(char *)MXO[mxoTrig]);

      MTrigToXML(T,TE,NULL);

      MXMLAddE(VE,TE);
      }
    } /* END if (V->T != NULL) */

  if (V->Action != NULL)
    {
    mln_t  *tmpL = NULL;
    mjob_t *J;

    mxml_t *AE;

    /* report pending actions */

    for (tmpL = V->Action;tmpL != NULL;tmpL = tmpL->Next)
      {
      if ((MJobFind(tmpL->Name,&J,mjsmExtended) == FAILURE) ||
          (J->System == NULL))
        {
        continue;
        }

      AE = NULL;

      MXMLCreateE(&AE,"action");

      MXMLSetAttr(AE,"id",(void **)tmpL->Name,mdfString);

      MXMLSetAttr(AE,"type",(void **)MSysJobType[J->System->JobType],mdfString);

      if (MJOBISACTIVE(J) == TRUE)
        MXMLSetAttr(AE,"starttime",(void **)&J->StartTime,mdfLong);
      else if (J->Rsv != NULL)
        MXMLSetAttr(AE,"starttime",(void **)&J->Rsv->StartTime,mdfLong);

      MXMLSetAttr(AE,"duration",(void **)&J->SpecWCLimit[0],mdfLong);

      switch (J->System->JobType)
        {
        case msjtVMMigrate:

          if (!MNLIsEmpty(&J->Req[0]->NodeList))
            {
            MXMLSetAttr(AE,"destination",(void **)MNLGetNodeName(&J->Req[0]->NodeList,0,NULL),mdfString);
            }
          
          break;

        case msjtOSProvision:

          MXMLSetAttr(AE,"os",(void **)MAList[meOpsys][J->System->ICPVar1],mdfString);

          break;

#if 0
        case msjtVMCreate:

          if (J->System->Action != NULL) 
            {
            char *ptr;

            if ((ptr = strstr(J->System->Action,"create:")) != NULL)
              {
              /* report new VM configuration */

              ptr += strlen("create:");

              MXMLSetAttr(AE,"config",(void **)ptr,mdfString);
              }
            }

          break;
#endif

        default:

          /* NO-OP */

          break;
        }  /* END switch (J->System->JobType) */

      MXMLAddE(VE,AE);
      }  /* END for (tmpL = V->Action) */
    }    /* END if ((V->Action != NULL) && (V->Action[0] != NULL)) */

  /* VMTracking job */

  if (V->TrackingJ != NULL)
    {
    MXMLSetAttr(VE,"TrackingJob",(void **)V->TrackingJ->Name,mdfString);
    }

  return(SUCCESS);
  }  /* END MVMToXML() */
Ejemplo n.º 10
0
int MRMToXML(

  mrm_t             *R,      /* I */
  mxml_t           **RMEP,   /* O */
  enum MRMAttrEnum  *SAList) /* I (optional) */

  {
  enum MRMAttrEnum DAList[] = {
    mrmaAuthType,
    mrmaAuthAList,
    mrmaAuthCList,
    mrmaAuthGList,
    mrmaAuthQList,
    mrmaAuthUList,
    mrmaCheckpointSig,
    mrmaCheckpointTimeout,
    mrmaClusterQueryURL,
    mrmaConfigFile,
    mrmaCredCtlURL,
    mrmaCSAlgo,
    mrmaDataRM,
    mrmaDefDStageInTime,
    mrmaDefHighSpeedAdapter,
    mrmaDataRM,
    mrmaEPort,
    mrmaFlags,
    mrmaHost,
    mrmaJobCount,
    mrmaJobCounter,
    mrmaJobStartCount,
    mrmaLocalDiskFS,
    /* mrmaMessages, - msgs are currently not safe for XML (need to update like job msgs) */
    mrmaMinETime,
    mrmaName,
    mrmaNC,
    mrmaNMPort,
    mrmaNMServer,
    mrmaNodeFailureRsvProfile,
    mrmaNodeList,
    mrmaOMap,
    mrmaPartition,
    mrmaPort,
    mrmaProcs,
    mrmaProfile,
    mrmaResourceType,
    mrmaSocketProtocol,
    mrmaSQLData,
    mrmaState,
    mrmaStats,
    mrmaSubmitCmd,
    mrmaSuspendSig,
    mrmaTargetUsage,
    mrmaTimeout,
    mrmaType,
    mrmaUpdateTime,
    mrmaVersion,
    mrmaVMOwnerRM,
    mrmaWireProtocol,
    mrmaWorkloadQueryURL,
    mrmaNONE };

  int  aindex;
  int  pindex;

  enum MRMAttrEnum *AList;

  char tmpBuffer[MMAX_BUFFER];

  mxml_t *RME;

  if ((R == NULL) || (RMEP == NULL))
    {
    return(FAILURE);
    }

  if ((*RMEP == NULL) && (MXMLCreateE(RMEP,(char *)MXO[mxoRM]) == FAILURE))
    {
    return(FAILURE);
    }

  RME = *RMEP;

  if (SAList != NULL)
    AList = SAList;
  else
    AList = DAList;

  for (aindex = 0;AList[aindex] != mrmaNONE;aindex++)
    {
    if ((MRMAToString(R,AList[aindex],tmpBuffer,sizeof(tmpBuffer),0) == FAILURE) ||
        (tmpBuffer[0] == '\0'))
      {
      continue;
      }

    MXMLSetAttr(
      RME,
      (char *)MRMAttr[AList[aindex]],
      (void *)tmpBuffer,
      mdfString);
    }  /* END for (aindex) */

  /* checkpoint local queue information */

  if (bmisset(&R->IFlags,mrmifLocalQueue) &&
      (MSched.LoadAllJobCP == FALSE) &&
      (MUHTIsInitialized(&R->U.S3.JobListIndex) == SUCCESS))
    {
    char *tmpBuf;
    int   tmpBufLen;

    mhashiter_t JobListIter;
    char *JobName = NULL;

    mjob_t *J;

    mxml_t *QE = NULL;

    MUHTIterInit(&JobListIter);

    MXMLCreateE(&QE,(char *)MXO[mxoQueue]);

    tmpBuf = NULL;
    tmpBufLen = 0;

    while (MUHTIterate(&R->U.S3.JobListIndex,&JobName,NULL,NULL,&JobListIter) == SUCCESS)
      {
      if (MJobFind(JobName,&J,mjsmBasic) == SUCCESS)
        {
        if (MJobShouldCheckpoint(J,R) == FALSE)
          continue;
        }

      MUStrAppend(&tmpBuf,&tmpBufLen,JobName,',');  /* consider using MUSNXPrintF to decrease heap fragmentation */
      }

    MXMLSetAttr(QE,(char *)MXO[mxoJob],tmpBuf,mdfString);

    MXMLAddE(RME,QE);

    MUFree(&tmpBuf);
    }  /* END if ((bmisset(&R->IFlags,mrmifLocalQueue)) && ...) */

  /* create peer interface child */

  for (pindex = 0;pindex < MMAX_RMSUBTYPE;pindex++)
    {
    mxml_t *PE;

    if (bmisset(&R->RTypes,mrmrtLicense) ||
        bmisset(&R->RTypes,mrmrtNetwork) ||
        bmisset(&R->RTypes,mrmrtProvisioning) ||
        bmisset(&R->RTypes,mrmrtStorage))
      {
      /* non-compute RM's may not have interface type specified since they
         may route directly through file or CLI interfaces */

      if (R->P[pindex].RespTotalCount[0] <= 0)
        continue;
      }
    else
      { 
      if (R->P[pindex].Type == mpstNONE)
        continue;
      }

    PE = NULL;

    MXMLCreateE(&PE,"psi");

    MPSIToXML(&R->P[pindex],PE);

    MXMLAddE(RME,PE);
    }  /* END for (pindex) */

  if (bmisset(&R->RTypes,mrmrtLicense))
    {
    int rindex;
    int IC;

    double tmpD;

    double totalCfg;
    double totalDed;

    mxml_t *GRE;

    IC = MAX(1,R->U.Nat.ICount);

    totalCfg = 0.0;
    totalDed = 0.0;

    for (rindex = 0;rindex < MSched.M[mxoxGRes];rindex++)
      {
      if ((R->U.Nat.ResName == NULL) ||
          (R->U.Nat.ResName[rindex][0] == '\0'))
        break;

      /* Only include license information that applies to this resource manager */

      if (MSNLGetIndexCount(&R->U.Nat.ResConfigCount,rindex) == 0)
        continue;

      GRE = NULL;

      MXMLCreateE(&GRE,"license");

      MXMLSetAttr(GRE,"name",(void *)R->U.Nat.ResName[rindex],mdfString);

      MXMLSetAttr(GRE,"ic",(void *)&IC,mdfInt);

      tmpD = (double)(MSNLGetIndexCount(&R->U.Nat.ResAvailCount,rindex)) / IC;

      MXMLSetAttr(GRE,"averageAvail",(void *)&tmpD,mdfDouble);

      tmpD = (double)(MSNLGetIndexCount(&R->U.Nat.ResConfigCount,rindex)) / IC;

      MXMLSetAttr(GRE,"averageConfig",(void *)&tmpD,mdfDouble);

      /* NOTE: percentages below are over all iterations since Moab started */

      tmpD = (double)(MSNLGetIndexCount(&R->U.Nat.ResFreeICount,rindex)) / IC;

      MXMLSetAttr(GRE,"percentIdle",(void *)&tmpD,mdfDouble);

      tmpD = (double)(MSNLGetIndexCount(&R->U.Nat.ResAvailICount,rindex) - MSNLGetIndexCount(&R->U.Nat.ResFreeICount,rindex)) / IC;

      MXMLSetAttr(GRE,"percentActive",(void *)&tmpD,mdfDouble);

      tmpD = (double)(R->U.Nat.ICount - MSNLGetIndexCount(&R->U.Nat.ResAvailICount,rindex)) / IC;

      MXMLSetAttr(GRE,"percentBusy",(void *)&tmpD,mdfDouble);

      if (R->U.Nat.N != NULL)
        {
        mnode_t *GN;

        GN = (mnode_t *)R->U.Nat.N;
          
        tmpD = (double)(MSNLGetIndexCount(&GN->CRes.GenericRes,rindex));

        MXMLSetAttr(GRE,"currentConfig",(void *)&tmpD,mdfDouble);

        tmpD = (double)(MSNLGetIndexCount(&GN->ARes.GenericRes,rindex));

        totalCfg += tmpD;

        MXMLSetAttr(GRE,"currentAvail",(void *)&tmpD,mdfDouble);

        tmpD = (double)(MSNLGetIndexCount(&GN->DRes.GenericRes,rindex));

        MXMLSetAttr(GRE,"currentDedicated",(void *)&tmpD,mdfDouble);

        tmpD = (double)(MSNLGetIndexCount(&GN->DRes.GenericRes,rindex));

        totalDed += tmpD;
        }

      MXMLAddE(RME,GRE);
      }  /* END for (rindex) */

    tmpD = totalDed / MAX(1.0,totalCfg);

    MXMLSetAttr(RME,"LOAD",(void *)&tmpD,mdfDouble);
    }    /* END if (bmisset(&R->RTypes,mrmrtLicense)) */

  if (bmisset(&R->RTypes,mrmrtNetwork))
    {
    if (!MNLIsEmpty(&R->NL))
      {
      double   tmpD;
      mnode_t *N;
      int      gindex;

      MNLGetNodeAtIndex(&R->NL,0,&N);

      gindex = MUMAGetIndex(
        meGRes,
        "bandwidth",
        mVerify);

      if (gindex > 0)
        {
        tmpD = MSNLGetIndexCount(&N->ARes.GenericRes,gindex) / MAX(1.0,MSNLGetIndexCount(&N->CRes.GenericRes,gindex));

        tmpD = 1.0 - tmpD;

        MXMLSetAttr(RME,"LOAD",(void *)&tmpD,mdfDouble);
        } 
      }
    }    /* END if (bmisset(&R->RTypes,mrmrtNetwork)) */

  if (bmisset(&R->RTypes,mrmrtProvisioning))
    {
    /* report ratio of I/O (ie, install) capacity currently in use */

    /* NYI */
    }

  if (bmisset(&R->RTypes,mrmrtStorage))
    {
    if (!MNLIsEmpty(&R->NL))
      {
      double   tmpD;
      mnode_t *N;

      MNLGetNodeAtIndex(&R->NL,0,&N);

      tmpD = N->ARes.Disk / MAX(1.0,N->CRes.Disk);

      tmpD = 1.0 - tmpD;

      MXMLSetAttr(RME,"LOAD",(void *)&tmpD,mdfDouble);
      }  /* END if (bmisset(&R->RTypes,mrmrtStorage)) */
    }

  return(SUCCESS);
  }  /* END MRMToXML() */
Ejemplo n.º 11
0
int MClassLoadCP(

  mclass_t *CS,
  char     *Buf)

  {
  char    tmpHeader[MAX_MNAME];
  char    CName[MAX_MNAME];

  char   *ptr;

  mclass_t *C;

  long    CkTime;

  mxml_t *E = NULL;

  const char *FName = "MClassLoadCP";

  DBG(4,fCKPT) DPrint("%s(CS,%s)\n",
    FName,
    (Buf != NULL) ? Buf : "NULL");

  if (Buf == NULL)
    {
    return(FAILURE);
    }

  /* FORMAT:  <HEADER> <GID> <CKTIME> <GSTRING> */

  /* load CP header */

  sscanf(Buf,"%s %s %ld",
    tmpHeader,
    CName,
    &CkTime);

  if (((long)MSched.Time - CkTime) > MCP.CPExpirationTime)
    {
    return(SUCCESS);
    }

  if (CS == NULL)
    {
    if (MClassAdd(CName,&C) != SUCCESS)
      {
      DBG(5,fCKPT) DPrint("ALERT:    cannot load CP class '%s'\n",
        CName);

      return(FAILURE);
      }
    }
  else
    {
    C = CS;
    }

  if ((ptr = strchr(Buf,'<')) == NULL)
    {
    return(FAILURE);
    }

  MXMLCreateE(&E,(char *)MXO[mxoClass]);

  MXMLFromString(&E,ptr,NULL,NULL);

  MOFromXML((void *)C,mxoClass,E);

  MXMLDestroyE(&E);

  return(SUCCESS);
  }  /* END MClassLoadCP() */
Ejemplo n.º 12
0
int __MSysTestXML(
 
  char *XMLString)  /* I */

  {
  char *tail;

  FILE *fp;

  mxml_t *E = NULL;

  char EMsg[MMAX_LINE];

  char buffer[MMAX_BUFFER << 3];

  if ((XMLString != NULL) && (XMLString[0] != '\0'))
    {
    if (XMLString[0] == '/')
      {
      int rc;

      fp = fopen(XMLString,"r");

      rc = fread((void *)buffer,sizeof(buffer),1,fp);

      XMLString = buffer;

      fprintf(stdout,"read in %d\n",rc);
      }

    fprintf(stdout,"XMLString: '%s'\n\n",
      XMLString);
  
    if (MXMLFromString(&E,XMLString,&tail,EMsg) == FAILURE)
      {
      fprintf(stderr,"ERROR: '%s'\n",
        EMsg);
  
      exit(1);
      }
  
    if (tail != NULL)
      {
      fprintf(stdout,"tail: '%s'\n\n",
        XMLString);
      }

    exit(0);
    }

  MXMLCreateE(&E,"Data");
  MXMLSetAttr(E,"Value",(void *)"this >> that",mdfString);

  MXMLToString(E,EMsg,sizeof(EMsg),NULL,TRUE);

  fprintf(stdout,"XML = '%s'\n\n",
    EMsg);

  MXMLDestroyE(&E);

  MXMLFromString(&E,EMsg,NULL,NULL);

  fprintf(stdout,"After MXMLFromString: <Data %s=\"%s\"></Data>\n\n",
    E->AName[0],
    E->AVal[0]);

  EMsg[0] = '\0';

  MXMLToString(E,EMsg,sizeof(EMsg),NULL,TRUE);

  fprintf(stdout,"XML = '%s'\n\n",
    EMsg);

  exit(1);

  /* NOTREACHED */

  return(SUCCESS);
  }  /* END __MSysTestXML() */
Ejemplo n.º 13
0
int MVMTransitionToXML(

  mtransvm_t       *V,
  mxml_t          **VEP,
  enum MVMAttrEnum *SAList)

  {
  char tmpString[MMAX_LINE];

  mxml_t *VE;     /* element for the VM */

  enum MVMAttrEnum *AList;  /**< VM attribute list */

  int aindex;

  const enum MVMAttrEnum DAList[] = {
    mvmaActiveOS,
    mvmaADisk,
    mvmaAlias,
    mvmaAMem,
    mvmaAProcs,
    mvmaCDisk,
    mvmaCMem,
    mvmaCProcs,
    mvmaCPULoad,
    mvmaContainerNode,
    mvmaDDisk,
    mvmaDMem,
    mvmaDProcs,
    mvmaDescription,
    mvmaEffectiveTTL,
    mvmaFlags,
    mvmaGMetric,
    mvmaID,
    mvmaJobID,
    mvmaLastMigrateTime,
    mvmaLastSubState,
    mvmaLastSubStateMTime,
    mvmaLastUpdateTime,
    mvmaMigrateCount,
    mvmaNetAddr,
    mvmaNextOS,
    mvmaOSList,
    mvmaPowerIsEnabled,
    mvmaPowerState,
    mvmaProvData,
    mvmaRackIndex,
    mvmaSlotIndex,
    mvmaSovereign,
    mvmaSpecifiedTTL,
    mvmaStartTime,
    mvmaState,
    mvmaSubState,
    mvmaStorageRsvNames,
    mvmaTrackingJob,
    mvmaVariables,
    mvmaLAST };

  *VEP = NULL;

  if ((V == NULL) || (VEP == NULL))
    {
    return(FAILURE);
    }

  if (MXMLCreateE(VEP,(char *)MXO[mxoxVM]) == FAILURE)
    {
    return(FAILURE);
    }

  VE = *VEP;
 
  if (SAList != NULL)
    AList = SAList;
  else
    AList = (enum MVMAttrEnum *)DAList;

  for (aindex = 0;AList[aindex] != mvmaLAST;aindex++)
    {
    if (AList[aindex] == mvmaVariables)
      {
      mxml_t *VarE = NULL;

      MXMLDupE(V->Variables,&VarE);

      MXMLAddE(VE,VarE);

      continue;
      }

    if ((MVMTransitionAToString(V,AList[aindex],tmpString,sizeof(tmpString)) == FAILURE) ||
        (tmpString[0] == '\0'))
      {
      continue;
      }

    MXMLSetAttr(VE,(char *)MVMAttr[AList[aindex]],tmpString,mdfString);
    }  /* END for (aindex) */

  return(SUCCESS);
  }  /* END MVMTransitionToXML() */
Ejemplo n.º 14
0
int MUIShowRes(

  msocket_t *S,      /* I */
  mbitmap_t *CFlags, /* I (not used) */
  char      *Auth)   /* I */

  {
  enum MXMLOTypeEnum ObjectType = mxoNONE;

  char Name[MMAX_NAME];
  char tmpName[MMAX_NAME];
  char tmpVal[MMAX_LINE];
  char FlagLine[MMAX_LINE];
  char EMsg[MMAX_LINE] = {0};

  mxml_t *RE = NULL;
  mxml_t *DE;

  mpar_t *P = NULL;

  mbitmap_t  Flags;

  const char *FName = "MUIShowRes";

  MDB(3,fUI) MLog("%s(S,CFlags,%s)\n",
    FName,
    Auth);

  /* need to get ObjectType, PName, Flags, Name */

  switch (S->WireProtocol)
    {
    case mwpXML:
    case mwpS32:

      {
      mxml_t *WE;

      int WTok;
   
      /* FORMAT:  <Request action="X" object="Y"><Where/></Request> */

      char *ptr;

      if (S->RDE != NULL)
        {
        RE = S->RDE;
        }
      else if ((S->RPtr != NULL) &&
              ((ptr = strchr(S->RPtr,'<')) != NULL) &&
               (MXMLFromString(&RE,ptr,NULL,NULL) == FAILURE))
        {
        MDB(3,fUI) MLog("WARNING:  corrupt command '%100.100s' received\n",
          S->RBuffer);

        MUISAddData(S,"ERROR:    corrupt command received\n");

        return(FAILURE);
        }

      WTok = -1;

      while (MS3GetWhere(
          RE,
          &WE,
          &WTok,
          tmpName,          /* O */
          sizeof(tmpName),
          tmpVal,           /* O */
          sizeof(tmpVal)) == SUCCESS)
        {
        if (!strcasecmp(tmpName,"partition"))
          {
          if (MParFind(tmpVal,&P) == FAILURE)
            {
            snprintf(EMsg,sizeof(EMsg),"ERROR:  invalid partition \"%s\" specified\n",
              tmpVal);

            MUISAddData(S,EMsg);

            return(FAILURE);
            }
          }
        else if (!strcmp(tmpName,MSON[msonObject]))
          {
          ObjectType = (enum MXMLOTypeEnum)MUGetIndexCI(tmpVal,MXOC,FALSE,mxoNONE);
          }
        }       /* END while (MXMLGetChild() == SUCCESS) */

      if (MXMLGetAttr(RE,MSAN[msanFlags],NULL,FlagLine,sizeof(FlagLine)) == SUCCESS)
        {
        bmfromstring(FlagLine,MClientMode,&Flags);

        if (strcasestr(FlagLine,"showfree") != NULL)
          {
          bmset(&Flags,mcmNonBlock);
          }
        }

      if (MXMLGetAttr(RE,MSAN[msanOp],NULL,Name,sizeof(Name)) == FAILURE)
        {
        MUStrCpy(Name,NONE,sizeof(Name));
        }
      }  /* END BLOCK (case mwpXML/mwpS3) */

      break;

    default:

      /* not supported */

      MUISAddData(S,"ERROR:    corrupt command received\n");

      return(FAILURE);

      /*NOTREACHED*/

      break;
    }  /* END switch (S->WireProtocol) */

  if (MXMLCreateE(&S->SDE,(char *)MSON[msonData]) == FAILURE)
    {
    MUISAddData(S,"ERROR:    cannot create response\n");

    return(FAILURE);
    }

  DE = S->SDE;

  switch (ObjectType)
    {
    case mxoNode:

      if (MNodeShowRsv(Auth,Name,P,&Flags,DE,EMsg) == FAILURE)
        {
        MUISAddData(S,EMsg);

        return(FAILURE);
        }

      break;

    case mxoJob:

      if (MUIRsvList(Auth,Name,P,&Flags,DE,EMsg) == FAILURE)
        {
        MUISAddData(S,EMsg);

        return(FAILURE);
        }

      break;

    default:

      MDB(0,fUI) MLog("ERROR:    reservation type '%d' not handled\n",
        ObjectType);

      snprintf(EMsg,sizeof(EMsg),"ERROR:    reservation type '%d' not handled\n",
        ObjectType);

      MUISAddData(S,EMsg);

      return(FAILURE);

      break;
    }  /* END switch (ObjectType) */

  return(SUCCESS);
  }  /* END MUIShowRes() */
Ejemplo n.º 15
0
int MXMLFromString(

  mxml_t **EP,        /* O (populate or create) */
  char    *XMLString, /* I */
  char   **Tail,      /* O (optional) */
  char    *EMsg,      /* O (optional) */
  int      emsg_size) /* I */

  {
  mxml_t  *E;
  char    *ptr;

  char    *tail;

  int      index;

  mbool_t  ElementIsClosed = FALSE;

  mbool_t  DoAppend = FALSE;

  char tmpNLine[MMAX_LINE + 1];
  char tmpVLine[MMAX_XBUFFER + 1];

  if (EP != NULL)
    *EP = NULL;

  if (EMsg != NULL)
    EMsg[0] = '\0';

  if ((XMLString == NULL) || (EP == NULL))
    {
    if (EMsg != NULL)
      snprintf(EMsg, emsg_size, "invalid arguments");

    return(FAILURE);
    }

  if ((ptr = strchr(XMLString, '<')) == NULL)
    {
    if (EMsg != NULL)
      snprintf(EMsg, emsg_size, "no XML in string");

    return(FAILURE);
    }

  if (ptr[1] == '/')
    {
    /* located tail marker */

    if (EMsg != NULL)
      snprintf(EMsg, emsg_size, "premature termination marker");

    return(FAILURE);
    }

  /* NOTE:  should support append/overlay parameter (NYI) */

  /* ignore 'meta' elements */

  while ((ptr[1] == '?') || (ptr[1] == '!'))
    {
    ptr++;

    /* ignore 'meta' elements */

    if (*ptr == '?')
      {
      ptr++;

      if ((ptr = strstr(ptr, "?>")) == NULL)
        {
        /* cannot locate end of meta element */

        return(FAILURE);
        }

      if ((ptr = strchr(ptr, '<')) == NULL)
        {
        /* cannot locate next element */

        if (EMsg != NULL)
          snprintf(EMsg, emsg_size, "cannot locate post-meta XML");

        return(FAILURE);
        }
      }    /* END if (*ptr == '?') */

    /* ignore 'comment' element */

    if (!strncmp(ptr, "!--", 3))
      {
      ptr += 3;

      if ((ptr = strstr(ptr, "-->")) == NULL)
        {
        /* cannot locate end of comment element */

        if (EMsg != NULL)
          snprintf(EMsg, emsg_size, "cannot locate comment termination marker");

        return(FAILURE);
        }

      if ((ptr = strchr(ptr, '<')) == NULL)
        {
        /* cannot locate next element */

        if (EMsg != NULL)
          snprintf(EMsg, emsg_size, "cannot locate post-comment XML");

        return(FAILURE);
        }
      }    /* END if (!strncmp(ptr,"!--",3)) */
    }      /* END while ((ptr[1] == '?') || (ptr[1] == '!')) */

  /* remove whitespace */

  while (isspace(*ptr))
    ptr++;

  /* extract root element */

  if (*ptr != '<')
    {
    /* cannot located start of element */

    if (EMsg != NULL)
      snprintf(EMsg, emsg_size, "cannot locate start of root element");

    return(FAILURE);
    }

  ptr++;  /* ignore '<' */

  index = 0;

  while ((*ptr != ' ') && (*ptr != '>'))
    {
    if ((ptr[0] == '/') && (ptr[1] == '>'))
      {
      ElementIsClosed = TRUE;

      break;
      }

    tmpNLine[index++] = *(ptr++);

    if ((index >= MMAX_LINE) || (ptr[0] == '\0'))
      {
      if (EMsg != NULL)
        snprintf(EMsg, emsg_size, "element name is too long - %.10s", tmpNLine);

      return(FAILURE);
      }
    }

  tmpNLine[index] = '\0';

  if ((*EP == NULL) && (MXMLCreateE(EP, tmpNLine) == FAILURE))
    {
    if (EMsg != NULL)
      snprintf(EMsg, emsg_size, "cannot create XML element '%s'", tmpNLine);

    return(FAILURE);
    }

  E = *EP;

  if ((E->ACount > 0) || (E->CCount > 0))
    {
    DoAppend = TRUE;
    }

  if (ElementIsClosed == TRUE)
    {
    ptr += 2; /* skip '/>' */

    if (Tail != NULL)
      *Tail = ptr;

    return(SUCCESS);
    }

  while (*ptr == ' ')
    ptr++;

  while (*ptr != '>')
    {
    /* extract attributes */

    /* FORMAT:  <ATTR>="<VAL>" */

    index = 0;

    while ((*ptr != '=') && (*ptr != '\0'))
      {
      tmpNLine[index++] = *(ptr++);

      if (index >= MMAX_LINE)
        break;
      }

    tmpNLine[index] = '\0';

    if (*ptr != '\0')
      ptr++;  /* skip '=' */

    if (*ptr != '\0')
      ptr++;  /* skip '"' */

    if (*ptr == '\0')
      {
      if (EMsg != NULL)
        snprintf(EMsg, emsg_size, "string is corrupt - early termination");

      return(FAILURE);
      }

    index = 0;

    while ((*ptr != '"') ||
           ((ptr > XMLString) && (*(ptr - 1) == '\\')))
      {
      tmpVLine[index++] = *(ptr++);

      if ((index >= MMAX_XBUFFER) || (*ptr == '\0'))
        {
        MXMLDestroyE(EP);

        /* locate tail */

        if (Tail != NULL)
          *Tail = ptr + strlen(ptr);

        if (EMsg != NULL)
          {
          snprintf(EMsg, emsg_size, "attribute name is too long - %.10s", tmpVLine);
          }

        return(FAILURE);
        }
      }

    tmpVLine[index] = '\0';

    MXMLSetAttr(E,tmpNLine,(void *)tmpVLine,mdfString);

    ptr++; /* ignore '"' */

    while (*ptr == ' ')
      ptr++;

    if ((ptr[0] == '/') && (ptr[1] == '>'))
      {
      /* element terminator reached */

      ptr += 2; /* skip '/>' */

      if (Tail != NULL)
        *Tail = ptr;

      return(SUCCESS);
      }
    }  /* END while (*ptr != '>') */

  ptr++; /* ignore '>' */

  /* skip whitespace */

  while (isspace(*ptr))
    ptr++;

  /* extract value */

  if (*ptr != '<')
    {
    char *ptr2;

    index = 0;

    while (*ptr != '<')
      {
      tmpVLine[index++] = *(ptr++);

      if (index >= MMAX_XBUFFER)
        break;
      }

    tmpVLine[index] = '\0';

    E->Val = strdup(tmpVLine);

    if (E->Val == NULL)
      {
      if (EMsg != NULL)
        {
        snprintf(EMsg, emsg_size, "cannot alloc memory for value - %.10s", tmpVLine);
        }

      return(FAILURE);
      }

    /* restore '<' symbols */

    for (ptr2 = strchr(E->Val,(char)14);ptr2 != NULL;ptr2 = strchr(ptr2,(char)14))
      *ptr2 = '<';
    }  /* END if (*ptr != '<') */

  /* extract children */

  while (ptr[1] != '/')
    {
    mxml_t *C;

    C = NULL;

    if (DoAppend == TRUE)
      {
      char *ptr2;
      char  tmpCName[MMAX_NAME];

      int   index;

      /* FORMAT:  <NAME>... */

      /* locate name */

      ptr2 = ptr + 1;  /* ignore '<' */

      index = 0;

      while ((*ptr2 != ' ') && (*ptr2 != '>'))
        {
        if ((ptr2[0] == '/') && (ptr2[1] == '>'))
          {
          break;
          }

        tmpCName[index++] = *(ptr2++);

        if ((index >= MMAX_LINE) || (ptr2[0] == '\0'))
          {
          if (EMsg != NULL)
            {
            snprintf(EMsg, emsg_size, "element name is too long - %.10s", tmpCName);
            }
 
          return(FAILURE);
          }
        }

      tmpCName[index] = '\0';

      MXMLGetChild(E, tmpCName, NULL, &C);
      }

    if ((MXMLFromString(&C, ptr, &tail, EMsg, emsg_size) == FAILURE) ||
        (MXMLAddE(E, C) == FAILURE))
      {
      break;
      }

    ptr = tail;

    if ((ptr == NULL) || (ptr[0] == '\0'))
      {
      /* XML is corrupt */

      if (Tail != NULL)
        *Tail = ptr;

      if ((EMsg != NULL) && (EMsg[0] == '\0'))
        snprintf(EMsg, emsg_size, "cannot extract child");

      return(FAILURE);
      }
    }  /* END while (ptr[1] != '/') */

  /* ignore whitespace */

  while (isspace(*ptr))
    ptr++;

  /* process tail */

  if (*ptr == '/')
    {
    /* process '/>' */

    ptr++; /* ignore '/' */
    }
  else
    {
    ptr++; /* ignore '<' */

    ptr++; /* ignore '/' */

    ptr += strlen(E->Name);
    }

  ptr++; /* ignore '>' */

  if (Tail != NULL)
    *Tail = ptr;

  return(SUCCESS);
  }  /* END MXMLFromString() */
Ejemplo n.º 16
0
int MVMFailuresToXML(

  mvm_t   *V,
  char    *VMID,
  mxml_t **FDE)

  {
  mxml_t *GEE = NULL;

  char             *GEName;
  mgevent_obj_t    *GEvent;
  mgevent_iter_t    GEIter;

  if (FDE == NULL)
    return(FAILURE);

  if ((V == NULL) &&
      (VMID == NULL))
    {
    /* at least one of these must be valid */

    return(FAILURE);
    }

  if (V == NULL)
    {
    if (MVMFind(VMID,&V) == FAILURE)
      return(FAILURE);
    }

  /* cycle through generic events and create failuredetails XML
   * if one is found! */
  MGEventIterInit(&GEIter);

  while (MGEventItemIterate(&V->GEventsList,&GEName,&GEvent,&GEIter) == SUCCESS)
    {
    if (GEvent->GEventMTime <= 0)
      continue;

    MXMLCreateE(&GEE,"failuredetails");

    /*  Not currently part of the spec, but may soon be
    MXMLSetAttr(GEE,"name",(void *)GEName,mdfString);
    MXMLSetAttr(GEE,"time",(void *)&GEvent->GEventMTime,mdfLong);
    MXMLSetAttr(GEE,"vmid",(void *)V->VMID,mdfString);
    */

    MXMLSetVal(GEE,(void *)GEvent->GEventMsg,mdfString);

    break;
    } /* END while (MUHTIterate(&V->GEvents...) == SUCCESS) */

  if (GEE == NULL)
    {
    return(FAILURE);
    }

  *FDE = GEE;  

  return(SUCCESS);
  }  /* END MVMFailuresToXML() */
Ejemplo n.º 17
0
int MVMCRToXML(

  mvm_req_create_t *VMCR, /* I */
  mxml_t          **VEP)  /* O */

  {
  mxml_t *VE = NULL;

  if (VMCR == NULL)
    return(FAILURE);

  if (*VEP == NULL)
    {
    if (MXMLCreateE(VEP,(char *)MXO[mxoxVMCR]) == FAILURE)
      {
      MDB(3,fCKPT) MLog("INFO:     failed to create xml for VMCR for '%s'\n",
        VMCR->VMID);

      return(FAILURE);
      }
    }

  VE = *VEP;

  if (VMCR->VMID[0] != '\0')
    {
    MXMLSetAttr(VE,"ID",(void *)VMCR->VMID,mdfString);
    }

  if (VMCR->Vars[0] != '\0')
    {
    MXMLSetAttr(VE,"VARS",(void *)VMCR->Vars,mdfString);
    }

  if (VMCR->Storage[0] != '\0')
    {
    MXMLSetAttr(VE,"STORAGE",(void *)VMCR->Storage,mdfString);
    }

  if (VMCR->Aliases[0] != '\0')
    {
    MXMLSetAttr(VE,"ALIAS",(void *)VMCR->Aliases,mdfString);
    }

  if (VMCR->Triggers[0] != '\0')
    {
    MXMLSetAttr(VE,"TRIGGER",(void *)VMCR->Triggers,mdfString);
    }

  if (VMCR->N != NULL)
    {
    MXMLSetAttr(VE,"HYPERVISOR",(void *)VMCR->N->Name,mdfString);
    }

  if (VMCR->JT != NULL)
    {
    MXMLSetAttr(VE,"TEMPLATE",(void *)VMCR->JT->Name,mdfString);
    }

  if (VMCR->OwnerJob != NULL)
    {
    MXMLSetAttr(VE,"OWNERJOB",(void *)VMCR->OwnerJob->Name,mdfString);
    }

  if (VMCR->OSIndex != 0)
    {
    /* Set to string so that OS loading order doesn't matter */

    MXMLSetAttr(VE,"IMAGE",(void *)MAList[meOpsys][VMCR->OSIndex],mdfString);
    }

  if (VMCR->TrackingJ[0] != '\0')
    MXMLSetAttr(VE,"TRACKINGJ",(void *)VMCR->TrackingJ,mdfString);

  MXMLSetAttr(VE,"WALLTIME",(void *)&VMCR->Walltime,mdfLong);
  MXMLSetAttr(VE,"SOVEREIGN",(void *)MBool[VMCR->IsSovereign],mdfString);
  MXMLSetAttr(VE,"ISONETIMEUSE",(void *)MBool[VMCR->IsOneTimeUse],mdfString);

  /* CRes info */

  MXMLSetAttr(VE,"DISK",(void *)&VMCR->CRes.Disk,mdfInt); 
  MXMLSetAttr(VE,"MEM",(void *)&VMCR->CRes.Mem,mdfInt); 
  MXMLSetAttr(VE,"PROCS",(void *)&VMCR->CRes.Procs,mdfInt);

  return(SUCCESS);
  } /* END MVMCRToXML() */
Ejemplo n.º 18
0
int MVMToPendingActionXML(

  mvm_t   *V,    /* I */
  mxml_t **VEP)  /* O (alloc) */

  {
  char tmpLine[MMAX_LINE];

  mxml_t  *PE;
  mxml_t  *CE;
  mulong JDuration = 0;
  mbool_t  GEventsSpecified = FALSE;

  enum MSystemJobTypeEnum PendingActionType = msjtNONE;
  char PendingActionTypeStr[MMAX_LINE];

  if (VEP == NULL)
    {
    return(FAILURE);
    }

  *VEP = NULL;

  if (V == NULL)
    {
    return(FAILURE);
    }

  PE = NULL;

  /* See if there are any GEvents */

  if (MGEventGetItemCount(&V->GEventsList) > 0)
    {
    GEventsSpecified = TRUE;
    }

  /* NOTE:  do not change pending actions strings w/o coordinating with MCM 
            team */

  if ((V->NextOS != 0) &&
      (V->NextOS != V->ActiveOS))
    {
    PendingActionType = msjtOSProvision;
    MUStrCpy(PendingActionTypeStr,(char *)MPendingActionType[mpatVMOSProvision],sizeof(PendingActionTypeStr));
    }
  else if (((V->PowerSelectState == mpowOn) || (V->PowerSelectState == mpowOff)) &&
            (V->PowerState != V->PowerSelectState) &&
            (MSched.Time - V->PowerMTime < MCONST_HOURLEN))
    {
    if (V->PowerSelectState == mpowOn)
      {
      PendingActionType = msjtPowerOn;
      MUStrCpy(PendingActionTypeStr,(char *)MPendingActionType[mpatVMPowerOn],sizeof(PendingActionTypeStr));
      }
    else if (V->PowerSelectState == mpowOff)
      {
      PendingActionType = msjtPowerOff;
      MUStrCpy(PendingActionTypeStr,(char *)MPendingActionType[mpatVMPowerOff],sizeof(PendingActionTypeStr));
      }
    }
  else
    {
    PendingActionType = msjtNONE;
    }

  if (PendingActionType == msjtNONE)
    {
    /* has no action on it to report as a pending action */

    return(FAILURE);
    }

    /* create common elements */

  if (MXMLCreateE(&PE,(char *)MXO[mxoxPendingAction]) == FAILURE)
    {
    return(FAILURE);
    }

  snprintf(tmpLine,sizeof(tmpLine),"%s-%ld",
    V->VMID,
    V->LastOSModRequestTime);

  MXMLSetAttr(PE,(char *)MPendingActionAttr[mpaaPendingActionID],(void *)tmpLine,mdfString);
  MXMLSetAttr(PE,(char *)MPendingActionAttr[mpaaSched],(void *)MSched.Name,mdfString);

  if (PendingActionType != msjtNONE)
    {
    MXMLSetAttr(PE,(char *)MPendingActionAttr[mpaaType],(void *)PendingActionTypeStr,mdfString);

    if (V->LastOSModRequestTime > 0)
      {
      /* Viewpoint only wants positive starttimes reported */

      MXMLSetAttr(PE,(char *)MPendingActionAttr[mpaaStartTime],(void *)&V->LastOSModRequestTime,mdfLong);
      }

    if (MSched.DefProvDuration > 0)
      JDuration = MSched.DefProvDuration;
    else
      JDuration = MDEF_PROVDURATION;

    MXMLSetAttr(PE,(char *)MPendingActionAttr[mpaaMaxDuration],(void *)&JDuration,mdfLong);

    if (V->N != NULL)
      MXMLSetAttr(PE,(char *)MPendingActionAttr[mpaaHostlist],(void *)V->N->Name,mdfString);

    MXMLSetAttr(PE,(char *)MPendingActionAttr[mpaaState],(void *)MJobState[mjsRunning],mdfString);

    if (V->LastSubState != NULL)
      {
      MXMLSetAttr(PE,(char *)MPendingActionAttr[mpaaSubState],(void *)V->LastSubState,mdfString);
      }

    /* now set action specific data */
  
    switch (PendingActionType)
      {
      case msjtOSProvision:
  
        /* handle re-provisioning of VM's */
  
        MXMLAddChild(PE,PendingActionTypeStr,NULL,&CE);
        MXMLSetAttr(CE,(char *)MPendingActionAttr[mpaaVMID],(void *)V->VMID,mdfString);
        MXMLSetAttr(CE,(char *)MPendingActionAttr[mpaaTargetOS],(void *)MAList[meOpsys][V->NextOS],mdfString);
  
        break;
  
      case msjtPowerOn:
      case msjtPowerOff:
  
        /* handle start/stop */
  
        MXMLAddChild(PE,PendingActionTypeStr,NULL,&CE);
        MXMLSetAttr(CE,(char *)MPendingActionAttr[mpaaVMID],(void *)V->VMID,mdfString);
  
        break;
  
      default:
  
        /* NO-OP */
  
        break;
      }  /* END switch (PendingActionType) */
    } /* END if (PendingActionType != msjtNONE) */

  if (GEventsSpecified != FALSE)
    {
    mxml_t *GEE;

    if (MVMFailuresToXML(V,NULL,&GEE) == SUCCESS)
      MXMLAddE(PE,GEE);
    } /* END if (GEventsSpecified != FALSE) */

  *VEP = PE;

  return(SUCCESS);
  }  /* END MVMToPendingActionXML() */
Ejemplo n.º 19
0
int main(

  int  argc,  /* I */
  char **argv)  /* I */

  {
  struct batch_status  *bstatus = NULL;
  int                   con;
  char                 *specified_server = NULL;
  int                   errflg = 0;
  int                   i;
  extern char          *optarg;
  extern int            optind;
  char                **pa;

  struct batch_status  *pbstat;
  int                   flag = ALLI;
  char                 *note = NULL;
  enum  note_flags      note_flag = unused;
  char                **nodeargs = NULL;
  int                   lindex;

  enum NStateEnum ListType = tnsNONE;

  /* get default server, may be changed by -s option */

  progname = strdup(argv[0]);

  while ((i = getopt(argc, argv, "acdlopqrs:x-:N:n")) != EOF)
    {
    switch (i)
      {
      case 'a':

        flag = ALLI;

        break;

      case 'c':

        flag = CLEAR;

        break;

      case 'd':

        flag = DIAG;

        break;

      case 'l':

        flag = LIST;

        break;

      case 'o':

        flag = OFFLINE;

        break;

      case 'p':

        flag = PURGE;

        break;

      case 'q':

        quiet = 1;

        break;

      case 'r':

        flag = RESET;

        break;

      case 's':

        specified_server = optarg;

        break;

      case 'x':

        flag = ALLI;

        DisplayXML = TRUE;

        break;

      case 'N':

        /* preserve any previous option other than the default,
         * to allow -N to be combined with -o, -c, etc
         */

        if (flag == ALLI)
          flag = NOTE;

        note = strdup(optarg);

        if (note == NULL)
          {
          perror("Error: strdup() returned NULL");

          exit(1);
          }

        note_flag = set;

        /* -N n is the same as -N ""  -- it clears the note */

        if (!strcmp(note, "n"))
          *note = '\0';

        if (strlen(note) > MAX_NOTE)
          {
          fprintf(stderr, "Warning: note exceeds length limit (%d) - server may reject it...\n",
            MAX_NOTE);
          }

        if (strchr(note, '\n') != NULL)
          fprintf(stderr, "Warning: note contains a newline - server may reject it...\n");

        break;

      case 'n':

        note_flag = list;

        break;

      case '-':

        if ((optarg != NULL) && !strcmp(optarg, "version"))
          {
          fprintf(stderr, "Version: %s\nRevision: %s\n",
            PACKAGE_VERSION, SVN_VERSION);

          exit(0);
          }
        else if ((optarg != NULL) && !strcmp(optarg, "about"))
          {
          TShowAbout_exit();
          }

        errflg = 1;

        break;

      case '?':

      default:

        errflg = 1;

        break;
      }  /* END switch (i) */
    }    /* END while (i = getopt()) */

  if ((note_flag == list) && (flag != LIST))
    {
    fprintf(stderr, "Error: -n requires -l\n");
    errflg = 1;
    }

  for (pa = argv + optind;*pa;pa++)
    {
    if (strlen(*pa) == 0)
      {
      errflg = 1;
      }
    }

  if (errflg != 0)
    {
    if (!quiet)
      {
      fprintf(stderr, "usage:\t%s [-{c|d|l|o|p|r}] [-s server] [-n] [-N \"note\"] [-q] node ...\n",
              progname);

      fprintf(stderr, "\t%s [-{a|x}] [-s server] [-q] [node]\n",
              progname);
      }

    exit(1);
    }

  con = cnt2server(specified_server);

  if (con <= 0)
    {
    if (!quiet)
      {
      fprintf(stderr, "%s: cannot connect to server %s, error=%d (%s)\n",
        progname,
        (specified_server) ? specified_server : pbs_default(),
        con * -1,
        pbs_strerror(con * -1));
      }

    exit(1);
    }

  /* if flag is ALLI, LIST, get status of all nodes */

  if ((flag == ALLI) || (flag == LIST) || (flag == DIAG))
    {
    if ((flag == ALLI) || (flag == LIST) || (flag == DIAG))
      {
      if (flag == LIST)
        {
        /* allow state specification */

        if (argv[optind] != NULL)
          {

          for (lindex = 1;lindex < tnsLAST;lindex++)
            {
            if (!strcasecmp(NState[lindex], argv[optind]))
              {
              ListType = lindex;

              optind++;

              break;
              }
            }
          }
        }

      /* allow node specification (if none, then create an empty list) */

      if (argv[optind] != NULL)
        {
        nodeargs = argv + optind;
        }
      else
        {
        nodeargs = calloc(2, sizeof(char **));
        nodeargs[0] = strdup("");
        nodeargs[1] = '\0';
        }
      }
    }


  if ((note_flag == set) && (note != NULL))
    {
    /* set the note attrib string on specified nodes */

    for (pa = argv + optind;*pa;pa++)
      {
      set_note(con, *pa, note);
      }
    }

  switch (flag)
    {

    case DIAG:

      /* NYI */

      break;

    case CLEAR:

      /* clear  OFFLINE from specified nodes */

      for (pa = argv + optind;*pa;pa++)
        {
        marknode(con, *pa, ND_offline, DECR, NULL, DECR);
        }

      break;

    case RESET:

      /* clear OFFLINE, add DOWN to specified nodes */

      for (pa = argv + optind;*pa;pa++)
        {
        marknode(con, *pa, ND_offline, DECR, ND_down, INCR);
        }

      break;

    case OFFLINE:

      /* set OFFLINE on specified nodes */

      for (pa = argv + optind;*pa;pa++)
        {
        marknode(con, *pa, ND_offline, INCR, NULL, INCR);
        }

      break;

    case PURGE:

      /* remove node record */

      /* NYI */

      break;

    case ALLI:

      if (DisplayXML == TRUE)
        {

        char *tmpBuf = NULL, *tail = NULL;
        int  bufsize;

        mxml_t *DE;

        DE = NULL;

        MXMLCreateE(&DE, "Data");

        for (lindex = 0;nodeargs[lindex] != '\0';lindex++)
          {
          bstatus = statnode(con, nodeargs[lindex]);

          for (pbstat = bstatus;pbstat;pbstat = pbstat->next)
            {
            addxmlnode(DE, pbstat);
            }    /* END for (pbstat) */

          pbs_statfree(pbstat);
          }

        MXMLToXString(DE, &tmpBuf, &bufsize, INT_MAX, &tail, TRUE);

        MXMLDestroyE(&DE);

        fprintf(stdout, "%s\n",
                tmpBuf);
        }
      else
        {
        for (lindex = 0;nodeargs[lindex] != '\0';lindex++)
          {
          bstatus = statnode(con, nodeargs[lindex]);

          for (pbstat = bstatus;pbstat;pbstat = pbstat->next)
            {
            printf("%s\n",
                   pbstat->name);

            prt_node_attr(pbstat, 0);

            putchar('\n');
            }  /* END for (bpstat) */

          pbs_statfree(pbstat);
          }
        }

      break;

    case LIST:

      /* list any node that is DOWN, OFFLINE, or UNKNOWN */

      for (lindex = 0;nodeargs[lindex] != '\0';lindex++)
        {
        bstatus = statnode(con, nodeargs[lindex]);

        for (pbstat = bstatus;pbstat != NULL;pbstat = pbstat->next)
          {
          char *S;

          S = get_nstate(pbstat);

          if (filterbystate(pbstat, ListType, S))
            {
            char *n;

            if ((note_flag == list) && (n = get_note(pbstat)))
              {
              printf("%-20.20s %-26.26s %s\n",
                     pbstat->name,
                     S,
                     n);
              }
            else
              {
              printf("%-20.20s %s\n",
                     pbstat->name,
                     S);
              }
            }
          }

        pbs_statfree(pbstat);
        }

      break;
    }  /* END switch (flag) */

  pbs_disconnect(con);

  return(0);
  }  /* END main() */
Ejemplo n.º 20
0
int MUIRsvDiagnoseXML(

  msocket_t *S,       /* I (modified) */
  mbitmap_t *CFlagBM, /* I enum MRoleEnum bitmap */
  char      *Auth)    /* I */

  {
  rsv_iter RTI;

  char DiagOpt[MMAX_LINE];
  char FlagString[MMAX_LINE];
  char RsvID[MMAX_LINE];

  mxml_t *DE;
  mxml_t *RE;

  mrsv_t *R;

  mgcred_t *U;

  mbitmap_t CFlags;  /* bitmap of enum MCModeEnum */

  const enum MRsvAttrEnum RAList[] = {
    mraName,
    mraACL,       /**< @see also mraCL */
    mraAAccount,
    mraAGroup,
    mraAUser,
    mraAQOS,
    mraAllocNodeCount,
    mraAllocNodeList,
    mraAllocProcCount,
    mraAllocTaskCount,
    mraCL,        /**< credential list */
    mraComment,
    mraCost,      /**< rsv AM lien/charge */
    mraCTime,     /**< creation time */
    mraDuration,
    mraEndTime,
    mraExcludeRsv,
    mraExpireTime,
    mraFlags,
    mraGlobalID,
    mraHostExp,
    mraHistory,
    mraLabel,
    mraLastChargeTime, /* time rsv charge was last flushed */
    mraLogLevel,
    mraMessages,
    mraOwner,
    mraPartition,
    mraPriority,
    mraProfile,
    mraReqArch,
    mraReqFeatureList,
    mraReqMemory,
    mraReqNodeCount,
    mraReqNodeList,
    mraReqOS,
    mraReqTaskCount,
    mraReqTPN,
    mraResources,
    mraRsvAccessList, /* list of rsv's and rsv groups which can be accessed */
    mraRsvGroup,
    mraRsvParent,
    mraSID,
    mraStartTime,
    mraStatCAPS,
    mraStatCIPS,
    mraStatTAPS,
    mraStatTIPS,
    mraSubType,
    mraTrigger,
    mraType,
    mraVariables,
    mraVMList,
    mraNONE };

  RsvID[0] = '\0';

  if (MXMLCreateE(&S->SDE,(char *)MSON[msonData]) == FAILURE)
    {
    MUISAddData(S,"ERROR:    cannot create response\n");

    MCacheJobLock(FALSE,TRUE);
    return(FAILURE);
    }

  DE = S->SDE;

  /* find the user who issued the request */

  MUserAdd(Auth,&U);

  /* get the argument flags for the request */

  if (MXMLGetAttr(S->RDE,MSAN[msanFlags],NULL,FlagString,sizeof(FlagString)) == SUCCESS)
    bmfromstring(FlagString,MClientMode,&CFlags);

  /* look for a specified resveration id */

  if (MXMLGetAttr(S->RDE,MSAN[msanOp],NULL,DiagOpt,sizeof(DiagOpt)) == SUCCESS)
    {
    MUStrCpy(RsvID,DiagOpt,sizeof(RsvID));
    }

  /* loop through all reservations and create an xml element for each, adding
   * it to the return data element */

  MRsvIterInit(&RTI);

  while (MRsvTableIterate(&RTI,&R))
    {
    if ((!MUStrIsEmpty(RsvID)) && (strcmp(RsvID,R->Name) != 0))
      continue;

    if (MUICheckAuthorization(
          U,
          NULL,
          (void *)R,
          mxoRsv,
          mcsDiagnose,
          mrcmQuery,
          NULL,
          NULL,
          0) == FAILURE)
      {
      /* no authority to diagnose reservation */

      continue;
      } /* END if (MUICheckAuthorization...) */

    MDB(6,fUI) MLog("INFO:     evaluating MRsv '%s'\n",
      R->Name);

    RE = NULL;

    MXMLCreateE(&RE,(char *)MXO[mxoRsv]);

    MXMLAddE(DE,RE);

    MRsvToXML(R,&RE,(enum MRsvAttrEnum *)RAList,NULL,TRUE,mcmNONE);
    }  /* END for (rindex) */

  return(SUCCESS);
  } /* END MUIRsvDiagnoseXML() */