Seleccionar y ordenar objetos por orden de restauración

Una vez que se ha realizado la consulta de copia de seguridad o archivado, el cliente de la aplicación debe determinar qué objetos, si es que hay alguno, se van a restaurar o recuperar.

Después se ordenan los objetos en orden ascendente (de bajo a alto). Este orden es muy importante para el rendimiento de la operación de restauración. Al ordenar los objetos en los campo restoreOrderExt se garantiza que los datos se leen desde el servidor en el orden más eficaz.

Primero se restauran todos los datos del disco, seguido de los datos en clases de medios que requieren montajes de volumen (como una cinta). El campo restoreOrderExt también garantiza que los datos de la cinta se lean en orden con el proceso empezando al principio de la cinta y progresando hacia el final.

Un orden adecuado en el campo restoreOrderExt significa que no se realizan montajes de cintas duplicados ni rebobinados de cintas innecesarios.

Un valor distinto de cero en el campo restoreOrderExt.top se correlaciona con un dispositivo de acceso serie exclusivo en el servidor de IBM® Storage Protect . Debido a que un dispositivo de acceso de serie sólo se puede utilizar en un punto de sesión/montaje a la vez, la aplicación debe asegurarse de que si utiliza varias sesiones no existen restauraciones simultaneas con el mismo valor restoreOrderExt.top. De lo contrario la primera sesión es capaz de acceder a los objetos, pero las otras sesiones esperan hasta que la primera sesión termina y el dispositivo esté disponible.

El ejemplo siguiente muestra cómo ordenar objetos utilizando campos de Restore Order .

typedef struct {
dsStruct64_t      objId;
dsUint160_t      restoreOrderExt;
 
}  SortOrder;                /* struct used for sorting */
 
===================================================================
/* the code for sorting starts from here */
dsmQueryType      queryType;
qryBackupData     queryBuffer;
DataBlk           qDataBlkArea;
qryRespBackupData qbDataArea;
dsInt16_t   rc;
dsBool_t  done = bFalse;
int i = 0;
int qry_item;
SortOrder  sortorder[100]; /* sorting can be done up to 100 items
                                  only right now.  Set appropriate
                                  array size to fit your needs */
/*-----------------------------------------------------------------+
| NOTE: Make sure that proper initializations have been done to
|  queryType, 
|       queryBuffer, qDataBlkAre, and qbDataArea.  
|
------------------------------------------------------------------*/
 
   qDataBlkArea.bufferPtf = (char*) &qbDataArea;
 
   rc = dsmBeginQuery(dsmHandle, queryType, (void *) &queryBuffer);
   
   /*----------------------------------------+
   | Make sure to check rc from dsmBeginQuery
   +-----------------------------------------*/
   while (!done)
   {
      rc = dsmGetNextQObj(dsmHandle, &qDataBlkArea);
 if ((rc == DSM_RC_MORE_DATA) ||
          (rc == DSM_RC_FINISHED)) 
           &&( qDataBlkArea.numBytes))
      {
         /******************************************/
         /* transferring restoreOrderExt and objId */
         /******************************************/
         sortorder[i].restoreOrderExt = qbDataArea.restoreOrderExt;
         sortorder[i].objId = qbDataArea.objId;
 
      } /*  if ((rc == DSM_RC_MORE_DATA) || (rc == DSM_RC_FINISHED)) */
      else
      {
          done = bTrue;
          /****************************/
          /* take appropriate action. */
          /****************************/
      } 
     
      i++;
      qry_item++;
 
   } /* while (!done) */
   rc = dsmEndQuery(dsmHandle);
  /*check rc  */
   /*****************************************************/
   /* sorting the array using qsort.  After the call,   */
   /* sortorder will be sorted by restoreOrderExt field */ 
   /*****************************************************/
 
   qsort(sortorder, qry_item, sizeof(SortOrder), SortRestoreOrder);
 
 /*-----------------------------------------------------------------+
| NOTE: Make sure to extract sorted object ids and store them in
|       any data structure you want.  
------------------------------------------------------------------*/

/*----------------------------------------------------------------+
| int SortRestoreOrder(SortOrder *a, SortOrder *b)
|
| This function compares restoreOrder fields from two structures.
| if (a > b)
|   return(GREATERTHAN);
|| if (a < b)
|   return(LESSTHAN);
|| if (a == b)
|   return(EQUAL);
|+----------------------------------------------------------------*/
int SortRestoreOrder(SortOrder *a, SortOrder *b)
{
    if (a->restoreOrderExt.top > b->restoreOrderExt.top)
       return(GREATERTHAN);
    else if (a->restoreOrderExt.top < b->restoreOrderExt.top)
       return(LESSTHAN);
    else if (a->restoreOrderExt.hi_hi > b->restoreOrderExt.hi_hi)
       return(GREATERTHAN);
    else if (a->restoreOrderExt.hi_hi < b->restoreOrderExt.hi_hi)
       return(LESSTHAN);
    else if (a->restoreOrderExt.hi_lo > b->restoreOrderExt.hi_lo)
       return(GREATERTHAN);
    else if (a->restoreOrderExt.hi_lo < b->restoreOrderExt.hi_lo)
       return(LESSTHAN);
     else if (a->restoreOrderExt.lo_hi > b->restoreOrderExt.lo_hi)
       return(GREATERTHAN);
    else if (a->restoreOrderExt.lo_hi < b->restoreOrderExt.lo_hi)
       return(LESSTHAN);
    else if (a->restoreOrderExt.lo_lo > b->restoreOrderExt.lo_lo)
       return(GREATERTHAN);
    else if (a->restoreOrderExt.lo_lo < b->restoreOrderExt.lo_lo)
       return(LESSTHAN);
    else
       return(EQUAL);
}