Java TitanException类代码示例

import com.thinkaurelius.titan.core.TitanException; //导入依赖的package包/类
static <E extends ZonableEntity> E saveWithRetry(final GraphGenericRepository<E> repository,
        final E zonableEntity, final int retryCount) throws TitanException {
    try {
        repository.save(zonableEntity);
    } catch (TitanException te) {
        if (te.getCause().getCause().getMessage().contains("Local lock") && retryCount > 0) {
            try {
                Thread.sleep(250);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            zonableEntity.setId(0L); // Repository does not reset the vertex Id, on commit failure. Clear.
            saveWithRetry(repository, zonableEntity, retryCount - 1);
        } else {
            throw te;
        }
    }
    return zonableEntity;
}
 

import com.thinkaurelius.titan.core.TitanException; //导入依赖的package包/类
@Override
public synchronized Future<Message> add(StaticBuffer content) {
    TestMessage msg = new TestMessage(content);
    FutureMessage<TestMessage> fmsg = new FutureMessage<TestMessage>(msg);

    if (failAdds) {
        System.out.println("Failed message add");
        throw new TitanException("Log unavailable");
    }

    if (readers.isEmpty()) {
        messageBacklog.add(fmsg);
    } else {
        process(fmsg);
    }
    return fmsg;
}
 

import com.thinkaurelius.titan.core.TitanException; //导入依赖的package包/类
@Test
public void testIDBlockAllocationTimeout()
{
    config.set("ids.authority.wait-time", Duration.of(0L, ChronoUnit.NANOS));
    config.set("ids.renew-timeout", Duration.of(1L, ChronoUnit.MILLIS));
    close();
    TitanCleanup.clear(graph);
    open(config);
    try {
        graph.addVertex();
        fail();
    } catch (TitanException e) {

    }

    assertTrue(graph.isOpen());

    close(); // must be able to close cleanly

    // Must be able to reopen
    open(config);

    assertEquals(0L, (long)graph.traversal().V().count().next());
}
 

import com.thinkaurelius.titan.core.TitanException; //导入依赖的package包/类
/**
 * If ES already contains this instance's target index, then do nothing.
 * Otherwise, create the index, then wait {@link #CREATE_SLEEP}.
 * <p>
 * The {@code client} field must point to a live, connected client.
 * The {@code indexName} field must be non-null and point to the name
 * of the index to check for existence or create.
 *
 * @param config the config for this ElasticSearchIndex
 * @throws java.lang.IllegalArgumentException if the index could not be created
 */
private void checkForOrCreateIndex(Configuration config) {
    Preconditions.checkState(null != client);

    //Create index if it does not already exist
    IndicesExistsResponse response = client.admin().indices().exists(new IndicesExistsRequest(indexName)).actionGet();
    if (!response.isExists()) {

        ImmutableSettings.Builder settings = ImmutableSettings.settingsBuilder();

        ElasticSearchSetup.applySettingsFromTitanConf(settings, config, ES_CREATE_EXTRAS_NS);

        CreateIndexResponse create = client.admin().indices().prepareCreate(indexName)
                .setSettings(settings.build()).execute().actionGet();
        try {
            final long sleep = config.get(CREATE_SLEEP);
            log.debug("Sleeping {} ms after {} index creation returned from actionGet()", sleep, indexName);
            Thread.sleep(sleep);
        } catch (InterruptedException e) {
            throw new TitanException("Interrupted while waiting for index to settle in", e);
        }
        if (!create.isAcknowledged()) throw new IllegalArgumentException("Could not create index: " + indexName);
    }
}
 

import com.thinkaurelius.titan.core.TitanException; //导入依赖的package包/类
@Test
public void testErrorInBatch() throws Exception {
    initialize("vertex");
    Multimap<String, Object> doc1 = HashMultimap.create();
    doc1.put(TIME, "not a time");

    add("vertex", "failing-doc", doc1, true);
    add("vertex", "non-failing-doc", getRandomDocument(), true);

    try {
        tx.commit();
        fail("Commit should not have succeeded.");
    } catch (TitanException e) {
        // Looking for a NumberFormatException since we tried to stick a string of text into a time field.
        if (!Throwables.getRootCause(e).getMessage().contains("NumberFormatException")) {
            throw e;
        }
    } finally {
        tx = null;
    }
}
 

import com.thinkaurelius.titan.core.TitanException; //导入依赖的package包/类
@Override
public EntryList getSlice(final KeySliceQuery query, final StoreTransaction txh) throws BackendException {
    incActionBy(1, CacheMetricsAction.RETRIEVAL,txh);
    if (isExpired(query)) {
        incActionBy(1, CacheMetricsAction.MISS,txh);
        return store.getSlice(query, unwrapTx(txh));
    }

    try {
        return cache.get(query,new Callable<EntryList>() {
            @Override
            public EntryList call() throws Exception {
                incActionBy(1, CacheMetricsAction.MISS,txh);
                return store.getSlice(query, unwrapTx(txh));
            }
        });
    } catch (Exception e) {
        if (e instanceof TitanException) throw (TitanException)e;
        else if (e.getCause() instanceof TitanException) throw (TitanException)e.getCause();
        else throw new TitanException(e);
    }
}
 

import com.thinkaurelius.titan.core.TitanException; //导入依赖的package包/类
public static KCVSConfiguration getStandaloneGlobalConfiguration(final KeyColumnValueStoreManager manager,
                                                                 final Configuration config) {
    try {
        final StoreFeatures features = manager.getFeatures();
        return getGlobalConfiguration(new BackendOperation.TransactionalProvider() {
            @Override
            public StoreTransaction openTx() throws BackendException {
                return manager.beginTransaction(StandardBaseTransactionConfig.of(config.get(TIMESTAMP_PROVIDER),features.getKeyConsistentTxConfig()));
            }

            @Override
            public void close() throws BackendException {
                manager.close();
            }
        },manager.openDatabase(SYSTEM_PROPERTIES_STORE_NAME),config);
    } catch (BackendException e) {
        throw new TitanException("Could not open global configuration",e);
    }
}
 

import com.thinkaurelius.titan.core.TitanException; //导入依赖的package包/类
@Override
public synchronized void shutdown() throws TitanException {
    if (!isOpen) return;
    isOpen = false;
    try {
        try {
            for (Log log : processorLogs.values()) {
                log.close();
            }
            processorLogs.clear();
        } finally {
        }
    } catch (BackendException e) {
        throw new TitanException(e);
    }
}
 

import com.thinkaurelius.titan.core.TitanException; //导入依赖的package包/类
private DataOutput writeObjectNotNullInternal(Object object, boolean byteOrder) {
    Preconditions.checkNotNull(object);
    AttributeSerializer s = getSerializer(object.getClass());
    if (byteOrder) {
        Preconditions.checkArgument(s!=null && s instanceof OrderPreservingSerializer,"Invalid serializer for class: %s",object.getClass());
        ((OrderPreservingSerializer)s).writeByteOrder(this,object);
    } else {
        if (s!=null) s.write(this, object);
        else {
            try {
                getBackupSerializer().writeObjectNotNull(this,object);
            } catch (Exception e) {
                throw new TitanException("Serializer Restriction: Cannot serialize object of type: " + object.getClass(),e);
            }
        }
    }
    return this;
}
 

import com.thinkaurelius.titan.core.TitanException; //导入依赖的package包/类
@Test
public void testAllocationTimeout() {
    final MockIDAuthority idauth = new MockIDAuthority(10000, Integer.MAX_VALUE, 5000);
    StandardIDPool pool = new StandardIDPool(idauth, 1, 1, Integer.MAX_VALUE, Duration.ofMillis(4000), 0.1);
    try {
        pool.nextID();
        fail();
    } catch (TitanException e) {

    }

}
 

import com.thinkaurelius.titan.core.TitanException; //导入依赖的package包/类
@Override
public void add(StaticBuffer key, Entry cell) {
    try {
        kcvs.mutateEntries(key, Lists.newArrayList(cell), KCVSCache.NO_DELETIONS,tx);
    } catch (BackendException e) {
        throw new TitanException("Unexpected storage exception in log persistence against cache",e);
    }
}
 

import com.thinkaurelius.titan.core.TitanException; //导入依赖的package包/类
@Override
public void close() {
    try {
        store.close();
        txProvider.close();
        IOUtils.closeQuietly(serializer);
    } catch (BackendException e) {
        throw new TitanException("Could not close configuration store",e);
    }
}
 

import com.thinkaurelius.titan.core.TitanException; //导入依赖的package包/类
public KCVSLog getSystemTxLog() {
    try {
        return txLogManager.openLog(SYSTEM_TX_LOG_NAME);
    } catch (BackendException e) {
        throw new TitanException("Could not re-open transaction log", e);
    }
}
 

import com.thinkaurelius.titan.core.TitanException; //导入依赖的package包/类
public Log getSystemMgmtLog() {
    try {
        return mgmtLogManager.openLog(SYSTEM_MGMT_LOG_NAME);
    } catch (BackendException e) {
        throw new TitanException("Could not re-open management log", e);
    }
}
 

import com.thinkaurelius.titan.core.TitanException; //导入依赖的package包/类
private static KCVSConfiguration getConfiguration(final BackendOperation.TransactionalProvider txProvider,
                                                        final KeyColumnValueStore store, final String identifier,
                                                        final Configuration config) {
    try {
        KCVSConfiguration kcvsConfig =
                new KCVSConfiguration(txProvider,config,store,identifier);
        kcvsConfig.setMaxOperationWaitTime(config.get(SETUP_WAITTIME));
        return kcvsConfig;
    } catch (BackendException e) {
        throw new TitanException("Could not open global configuration",e);
    }
}