Java OperationTimeoutException类代码示例

import net.spy.memcached.OperationTimeoutException; //导入依赖的package包/类
@Override
public HttpCacheEntry getEntry(final String url) throws IOException {
    final String key = getCacheKey(url);
    if (key == null) {
        return null;
    }
    try {
        final MemcachedCacheEntry mce = reconstituteEntry(client.get(key));
        if (mce == null || !url.equals(mce.getStorageKey())) {
            return null;
        }
        return mce.getHttpCacheEntry();
    } catch (final OperationTimeoutException ex) {
        throw new MemcachedOperationTimeoutException(ex);
    }
}
 

import net.spy.memcached.OperationTimeoutException; //导入依赖的package包/类
public void testThrowsIOExceptionWhenMemcachedPutTimesOut() {
    final String url = "foo";
    final String key = "key";
    final HttpCacheEntry value = HttpTestUtils.makeCacheEntry();
    final byte[] serialized = HttpTestUtils.getRandomBytes(128);

    when(mockMemcachedCacheEntryFactory.getMemcachedCacheEntry(url, value))
        .thenReturn(mockMemcachedCacheEntry);
    when(mockMemcachedCacheEntry.toByteArray())
        .thenReturn(serialized);
    when(mockKeyHashingScheme.hash(url))
        .thenReturn(key);
    when(mockMemcachedClient.set(key, 0, serialized))
        .thenThrow(new OperationTimeoutException("timed out"));

    try {
        impl.putEntry(url, value);
        fail("should have thrown exception");
    } catch (final IOException expected) {
    }

    verify(mockMemcachedCacheEntryFactory).getMemcachedCacheEntry(url, value);
    verify(mockMemcachedCacheEntry).toByteArray();
    verify(mockKeyHashingScheme).hash(url);
    verify(mockMemcachedClient).set(key, 0, serialized);
}
 

import net.spy.memcached.OperationTimeoutException; //导入依赖的package包/类
@Test
public void testThrowsIOExceptionIfMemcachedTimesOutOnGet() {
    final String url = "foo";
    final String key = "key";
    when(mockKeyHashingScheme.hash(url)).thenReturn(key);
    when(mockMemcachedClient.get(key))
        .thenThrow(new OperationTimeoutException(""));

    try {
        impl.getEntry(url);
        fail("should have thrown exception");
    } catch (final IOException expected) {
    }
    verify(mockKeyHashingScheme).hash(url);
    verify(mockMemcachedClient).get(key);
}
 

import net.spy.memcached.OperationTimeoutException; //导入依赖的package包/类
@Test
public void testCacheRemoveThrowsIOExceptionOnMemcachedTimeout() {
    final String url = "foo";
    final String key = "key";
    when(mockKeyHashingScheme.hash(url)).thenReturn(key);
    when(mockMemcachedClient.delete(key))
        .thenThrow(new OperationTimeoutException(""));

    try {
        impl.removeEntry(url);
        fail("should have thrown exception");
    } catch (final IOException expected) {
    }

    verify(mockKeyHashingScheme).hash(url);
    verify(mockMemcachedClient).delete(key);
}
 

import net.spy.memcached.OperationTimeoutException; //导入依赖的package包/类
@Override
public void putEntry(final String url, final HttpCacheEntry entry) throws IOException  {
    final byte[] bytes = serializeEntry(url, entry);
    final String key = getCacheKey(url);
    if (key == null) {
        return;
    }
    try {
        client.set(key, 0, bytes);
    } catch (final OperationTimeoutException ex) {
        throw new MemcachedOperationTimeoutException(ex);
    }
}
 

import net.spy.memcached.OperationTimeoutException; //导入依赖的package包/类
@Override
public void removeEntry(final String url) throws IOException {
    final String key = getCacheKey(url);
    if (key == null) {
        return;
    }
    try {
        client.delete(key);
    } catch (final OperationTimeoutException ex) {
        throw new MemcachedOperationTimeoutException(ex);
    }
}
 

import net.spy.memcached.OperationTimeoutException; //导入依赖的package包/类
@Test
public void testUpdateThrowsIOExceptionIfMemcachedTimesOut() throws HttpCacheUpdateException {
    final String url = "foo";
    final String key = "key";
    final HttpCacheEntry updatedValue = HttpTestUtils.makeCacheEntry();

    final HttpCacheUpdateCallback callback = new HttpCacheUpdateCallback() {
        @Override
        public HttpCacheEntry update(final HttpCacheEntry old) {
            assertNull(old);
            return updatedValue;
        }
    };

    // get empty old entry
    when(mockKeyHashingScheme.hash(url)).thenReturn(key);
    when(mockMemcachedClient.gets(key))
        .thenThrow(new OperationTimeoutException(""));

    try {
        impl.updateEntry(url, callback);
        fail("should have thrown exception");
    } catch (final IOException expected) {
    }

    verify(mockKeyHashingScheme).hash(url);
    verify(mockMemcachedClient).gets(key);
}
 

import net.spy.memcached.OperationTimeoutException; //导入依赖的package包/类
/**
 * Increments the object count
 *
 * @param key  
 * @param value  
 * @param defaultValue  this value is set if the object doesn't exists
 * @param timeoutMiliSec  not used
 * @return new count value of the object
 */
public long increment(String key, int delta, long defaultValue, long timeoutMiliSec) 
		throws TimeoutException, com.quickserverlab.quickcached.client.MemcachedException {	
	long newval = -1;
	try{
		newval = getCache().incr(key, delta, defaultValue);
	}catch(OperationTimeoutException ote){
		throw new TimeoutException("Timeout "+ ote);
	}catch(IllegalStateException ise){
		throw new com.quickserverlab.quickcached.client.MemcachedException("IllegalStateException "+ ise);
	}
	return newval;
}
 

import net.spy.memcached.OperationTimeoutException; //导入依赖的package包/类
public long decrement(String key, int delta, long defaultValue, long timeoutMiliSec) 
		throws TimeoutException, com.quickserverlab.quickcached.client.MemcachedException {	
	long newval = -1;
	try{
		newval = getCache().decr(key, delta, defaultValue);
	}catch(OperationTimeoutException ote){
		throw new TimeoutException("Timeout "+ ote);
	}catch(IllegalStateException ise){
		throw new com.quickserverlab.quickcached.client.MemcachedException("IllegalStateException "+ ise);
	}
	return newval;
}
 

import net.spy.memcached.OperationTimeoutException; //导入依赖的package包/类
@Override
public void updateEntry(final String url, final HttpCacheUpdateCallback callback)
        throws HttpCacheUpdateException, IOException {
    int numRetries = 0;
    final String key = getCacheKey(url);
    if (key == null) {
        throw new HttpCacheUpdateException("couldn't generate cache key");
    }
    do {
        try {
            final CASValue<Object> v = client.gets(key);
            MemcachedCacheEntry mce = (v == null) ? null
                    : reconstituteEntry(v.getValue());
            if (mce != null && (!url.equals(mce.getStorageKey()))) {
                mce = null;
            }
            final HttpCacheEntry existingEntry = (mce == null) ? null
                    : mce.getHttpCacheEntry();
            final HttpCacheEntry updatedEntry = callback.update(existingEntry);

            if (existingEntry == null) {
                putEntry(url, updatedEntry);
                return;

            } else {
                final byte[] updatedBytes = serializeEntry(url, updatedEntry);
                final CASResponse casResult = client.cas(key, v.getCas(),
                        updatedBytes);
                if (casResult != CASResponse.OK) {
                    numRetries++;
                } else {
                    return;
                }
            }
        } catch (final OperationTimeoutException ex) {
            throw new MemcachedOperationTimeoutException(ex);
        }
    } while (numRetries <= maxUpdateRetries);

    throw new HttpCacheUpdateException("Failed to update");
}
 

import net.spy.memcached.OperationTimeoutException; //导入依赖的package包/类
@Override
   public CASResponse cas(String key, long casId, Object value)
    throws OperationTimeoutException {
return null;
   }
 

import net.spy.memcached.OperationTimeoutException; //导入依赖的package包/类
@Override
   public <T> CASValue<T> gets(String key, Transcoder<T> tc)
    throws OperationTimeoutException {

return null;
   }
 

import net.spy.memcached.OperationTimeoutException; //导入依赖的package包/类
@Override
   public <T> T get(String key, Transcoder<T> tc)
    throws OperationTimeoutException {
return null;
   }
 

import net.spy.memcached.OperationTimeoutException; //导入依赖的package包/类
@Override
   public <T> Map<String, T> getBulk(Collection<String> keys, Transcoder<T> tc)
    throws OperationTimeoutException {
return Collections.emptyMap();
   }
 

import net.spy.memcached.OperationTimeoutException; //导入依赖的package包/类
@Override
   public long incr(String key, int by) throws OperationTimeoutException {
return 0;
   }