예제 #1
0
static rc_t perform_curl_load( const p_context ctx, const TableWriterRefSeq* wr )
{
    CURL *curl_handle;
    CURLcode rcc;
    data_ctx dctx;
    rc_t rc = 0;

    curl_handle = curl_easy_init();
    if ( curl_handle == NULL )
    {
        rc = RC( rcExe, rcFile, rcConstructing, rcData, rcInvalid );
        LOGERR( klogErr, rc, "cur_easy_init() failed" );
        return rc;
    }

#ifdef _DEBUGGING
    if( KDbgTestModConds( DBG_APP, DBG_FLAG_ANY ) )
    {
        curl_easy_setopt( curl_handle, CURLOPT_VERBOSE , 1 );
    }
#endif

    rc = init_data_context( ctx, wr, &dctx );
    if ( rc != 0 )
    {
        curl_easy_cleanup( curl_handle );
        return rc;
    }

    rcc = curl_easy_setopt( curl_handle, CURLOPT_WRITEFUNCTION, on_curl_data );
    if ( rcc != CURLE_OK )
    {
        rc = RC( rcExe, rcFile, rcConstructing, rcParam, rcInvalid );
        LOGERR( klogErr, rc, "curl_easy_setopt(callback) failed" );
        free( dctx.buffer );
        curl_easy_cleanup( curl_handle );
        return rc;
    }

    rcc = curl_easy_setopt( curl_handle, CURLOPT_WRITEDATA, (void*)&dctx );
    if ( rcc != CURLE_OK )
    {
        rc = RC( rcExe, rcFile, rcConstructing, rcParam, rcInvalid );
        LOGERR( klogErr, rc, "curl_easy_setopt(context) failed" );
        free( dctx.buffer );
        curl_easy_cleanup( curl_handle );
        return rc;
    }

    rcc = curl_easy_setopt( curl_handle, CURLOPT_URL, ctx->src );
    if ( rcc != CURLE_OK )
    {
        rc = RC( rcExe, rcFile, rcConstructing, rcParam, rcInvalid );
        LOGERR( klogErr, rc, "curl_easy_setopt(uri) failed" );
        free( dctx.buffer );
        curl_easy_cleanup( curl_handle );
        return rc;
    }

    rcc = curl_easy_setopt( curl_handle, CURLOPT_LOW_SPEED_LIMIT, 1000 );
    if ( rcc != CURLE_OK )
    {
        rc = RC( rcExe, rcFile, rcConstructing, rcParam, rcInvalid );
        LOGERR( klogErr, rc, "curl_easy_setopt(CURLOPT_LOW_SPEED_LIMIT) to 1000 failed" );
        free( dctx.buffer );
        curl_easy_cleanup( curl_handle );
        return rc;
    }

    rcc = curl_easy_setopt( curl_handle, CURLOPT_LOW_SPEED_TIME, 5 );
    if ( rcc != CURLE_OK )
    {
        rc = RC( rcExe, rcFile, rcConstructing, rcParam, rcInvalid );
        LOGERR( klogErr, rc, "curl_easy_setopt(CURLOPT_LOW_SPEED_TIME) to 5 failed" );
        free( dctx.buffer );
        curl_easy_cleanup( curl_handle );
        return rc;
    }

    rcc = curl_easy_perform( curl_handle );
    if ( rcc != CURLE_OK )
    {
        rc = RC( rcExe, rcFile, rcConstructing, rcParam, rcInvalid );
        LOGERR( klogErr, rc, "curl_easy_perform() failed" );
    }

    finish_data_context( ctx, &dctx );
    curl_easy_cleanup( curl_handle );
    if ( dctx.rc == 0 )
    {
        dctx.rc = rc;
    }
    return dctx.rc;
}
예제 #2
0
파일: column.c 프로젝트: binlu1981/ncbi-vdb
/* KColumnBlobRead
 *  read data from blob
 *
 *  "offset" [ IN ] - starting offset into blob
 *
 *  "buffer" [ OUT ] and "bsize" [ IN ] - return buffer for read
 *
 *  "num_read" [ OUT ] - number of bytes actually read
 *
 *  "remaining" [ OUT, NULL OKAY ] - optional return parameter for
 *  the number of bytes remaining to be read. specifically,
 *  "offset" + "num_read" + "remaining" == sizeof blob
 */
LIB_EXPORT rc_t CC KColumnBlobRead ( const KColumnBlob *self,
    size_t offset, void *buffer, size_t bsize,
    size_t *num_read, size_t *remaining )
{
    rc_t rc;
    size_t ignore;
    if ( remaining == NULL )
        remaining = & ignore;

    if ( num_read == NULL )
        rc = RC ( rcDB, rcBlob, rcReading, rcParam, rcNull );
    else
    {
        if ( self == NULL )
            rc = RC ( rcDB, rcBlob, rcReading, rcSelf, rcNull );
        else
        {
            size_t size = self -> loc . u . blob . size;
            const KColumn *col = self -> col;

            if ( offset > size )
                offset = size;

            if ( bsize == 0 )
                rc = 0;
            else if ( buffer == NULL )
                rc = RC ( rcDB, rcBlob, rcReading, rcBuffer, rcNull );
            else
            {
                size_t to_read = size - offset;
                if ( to_read > bsize )
                    to_read = bsize;

                POS_DEBUG(( "KDB: %s,%lu,%lu\n", self->col->path, offset, to_read ));

#ifdef _DEBUGGING
                if ( KDbgTestModConds ( DBG_KFS, DBG_FLAG( DBG_KFS_POS ) ) ||
                     KDbgTestModConds ( DBG_KFS, DBG_FLAG( DBG_KFS_PAGE ) ) )
                {
                    KDbgSetColName( self->col->path );
                }
#endif
                *num_read = 0;
                while ( * num_read < to_read )
                {
                    size_t nread = 0;

                    rc = KColumnDataRead ( & col -> df, & self -> pmorig, offset - *num_read,
                        & ( ( char * ) buffer ) [ * num_read ], to_read - * num_read, & nread );
                    if ( rc != 0 )
                        break;
                    if (nread == 0)
                    {
                        rc = RC ( rcDB, rcBlob, rcReading, rcFile, rcInsufficient );
                        break;
                    }

                    *num_read += nread;
                }
#ifdef _DEBUGGING
                if ( KDbgTestModConds ( DBG_KFS, DBG_FLAG( DBG_KFS_POS ) ) ||
                     KDbgTestModConds ( DBG_KFS, DBG_FLAG( DBG_KFS_PAGE ) ) )
                {
                    KDbgSetColName( NULL );
                }
#endif

                if ( rc == 0 )
                {
                    * remaining = size - offset - * num_read;
                    return 0;
                }
            }

            * remaining = size - offset;
            * num_read = 0;
            return rc;
        }

        * num_read = 0;
    }

    * remaining = 0;
    return rc;
}