Java WrappedRunnable类代码示例

import org.apache.cassandra.utils.WrappedRunnable; //导入依赖的package包/类
public PropertyFileSnitch() throws ConfigurationException
{
    reloadConfiguration();

    try
    {
        FBUtilities.resourceToFile(SNITCH_PROPERTIES_FILENAME);
        Runnable runnable = new WrappedRunnable()
        {
            protected void runMayThrow() throws ConfigurationException
            {
                reloadConfiguration();
            }
        };
        ResourceWatcher.watch(SNITCH_PROPERTIES_FILENAME, runnable, 60 * 1000);
    }
    catch (ConfigurationException ex)
    {
        logger.error("{} found, but does not look like a plain file. Will not watch it for changes", SNITCH_PROPERTIES_FILENAME);
    }
}
 

import org.apache.cassandra.utils.WrappedRunnable; //导入依赖的package包/类
private static Future<?> announce(final Collection<Mutation> schema)
{
    Future<?> f = StageManager.getStage(Stage.MIGRATION).submit(new WrappedRunnable()
    {
        protected void runMayThrow() throws IOException, ConfigurationException
        {
            DefsTables.mergeSchema(schema);
        }
    });

    for (InetAddress endpoint : Gossiper.instance.getLiveMembers())
    {
        // only push schema to nodes with known and equal versions
        if (!endpoint.equals(FBUtilities.getBroadcastAddress()) &&
                MessagingService.instance().knowsVersion(endpoint) &&
                MessagingService.instance().getRawVersion(endpoint) == MessagingService.current_version)
            pushSchemaMutation(endpoint, schema);
    }

    return f;
}
 

import org.apache.cassandra.utils.WrappedRunnable; //导入依赖的package包/类
public void maybeArchive(final CommitLogSegment segment)
{
    if (Strings.isNullOrEmpty(archiveCommand))
        return;

    archivePending.put(segment.getName(), executor.submit(new WrappedRunnable()
    {
        protected void runMayThrow() throws IOException
        {
            segment.waitForFinalSync();
            String command = archiveCommand.replace("%name", segment.getName());
            command = command.replace("%path", segment.getPath());
            exec(command);
        }
    }));
}
 

import org.apache.cassandra.utils.WrappedRunnable; //导入依赖的package包/类
public void start()
{
    MBeanServer mbs = ManagementFactory.getPlatformMBeanServer();
    try
    {
        mbs.registerMBean(this, new ObjectName(MBEAN_NAME));
    }
    catch (Exception e)
    {
        throw new RuntimeException(e);
    }

    Runnable runnable = new WrappedRunnable()
    {
        public void runMayThrow() throws ExecutionException, InterruptedException
        {
            replayAllFailedBatches();
        }
    };

    batchlogTasks.scheduleWithFixedDelay(runnable, StorageService.RING_DELAY, REPLAY_INTERVAL, TimeUnit.MILLISECONDS);
}
 

import org.apache.cassandra.utils.WrappedRunnable; //导入依赖的package包/类
public static void trace(final ByteBuffer sessionIdBytes, final String message, final int elapsed)
{
    final String threadName = Thread.currentThread().getName();

    StageManager.getStage(Stage.TRACING).execute(new WrappedRunnable()
    {
        public void runMayThrow()
        {
            Mutation mutation = new Mutation(Tracing.TRACE_KS, sessionIdBytes);
            ColumnFamily cells = mutation.addOrGet(CFMetaData.TraceEventsCf);

            CFRowAdder adder = new CFRowAdder(cells, cells.metadata().comparator.make(UUIDGen.getTimeUUID()), FBUtilities.timestampMicros());
            adder.add("activity", message);
            adder.add("source", FBUtilities.getBroadcastAddress());
            if (elapsed >= 0)
                adder.add("source_elapsed", elapsed);
            adder.add("thread", threadName);

            Tracing.mutateWithCatch(mutation);
        }
    });
}
 

import org.apache.cassandra.utils.WrappedRunnable; //导入依赖的package包/类
public PropertyFileSnitch() throws ConfigurationException
{
    reloadConfiguration();

    try
    {
        FBUtilities.resourceToFile(SNITCH_PROPERTIES_FILENAME);
        Runnable runnable = new WrappedRunnable()
        {
            protected void runMayThrow() throws ConfigurationException
            {
                reloadConfiguration();
            }
        };
        ResourceWatcher.watch(SNITCH_PROPERTIES_FILENAME, runnable, 60 * 1000);
    }
    catch (ConfigurationException ex)
    {
        logger.debug(SNITCH_PROPERTIES_FILENAME + " found, but does not look like a plain file. Will not watch it for changes");
    }
}
 

import org.apache.cassandra.utils.WrappedRunnable; //导入依赖的package包/类
private static Future<?> announce(final Collection<RowMutation> schema)
{
    Future<?> f = StageManager.getStage(Stage.MIGRATION).submit(new WrappedRunnable()
    {
        protected void runMayThrow() throws IOException, ConfigurationException
        {
            DefsTables.mergeSchema(schema);
        }
    });

    for (InetAddress endpoint : Gossiper.instance.getLiveMembers())
    {
        if (endpoint.equals(FBUtilities.getBroadcastAddress()))
            continue; // we've dealt with localhost already

        // don't send schema to the nodes with the versions older than current major
        if (MessagingService.instance().getVersion(endpoint) < MessagingService.current_version)
            continue;

        pushSchemaMutation(endpoint, schema);
    }
    return f;
}
 

import org.apache.cassandra.utils.WrappedRunnable; //导入依赖的package包/类
public BatchCommitLogExecutorService(int queueSize)
{
    queue = new LinkedBlockingQueue<CheaterFutureTask>(queueSize);
    Runnable runnable = new WrappedRunnable()
    {
        public void runMayThrow() throws Exception
        {
            while (run)
            {
                if (processWithSyncBatch())
                    completedTaskCount++;
            }
        }
    };
    appendingThread = new Thread(runnable, "COMMIT-LOG-WRITER");
    appendingThread.start();

}
 

import org.apache.cassandra.utils.WrappedRunnable; //导入依赖的package包/类
public PropertyFileSnitch(int refreshPeriodInSeconds) throws ConfigurationException
{
    reloadConfiguration(false);

    try
    {
        FBUtilities.resourceToFile(SNITCH_PROPERTIES_FILENAME);
        Runnable runnable = new WrappedRunnable()
        {
            protected void runMayThrow() throws ConfigurationException
            {
                reloadConfiguration(true);
            }
        };
        ResourceWatcher.watch(SNITCH_PROPERTIES_FILENAME, runnable, refreshPeriodInSeconds * 1000);
    }
    catch (ConfigurationException ex)
    {
        logger.error("{} found, but does not look like a plain file. Will not watch it for changes", SNITCH_PROPERTIES_FILENAME);
    }
}
 

import org.apache.cassandra.utils.WrappedRunnable; //导入依赖的package包/类
private static Future<?> announce(final Collection<Mutation> schema)
{
    Future<?> f = StageManager.getStage(Stage.MIGRATION).submit(new WrappedRunnable()
    {
        protected void runMayThrow() throws ConfigurationException
        {
            SchemaKeyspace.mergeSchemaAndAnnounceVersion(schema);
        }
    });

    for (InetAddress endpoint : Gossiper.instance.getLiveMembers())
    {
        // only push schema to nodes with known and equal versions
        if (!endpoint.equals(FBUtilities.getBroadcastAddress()) &&
                MessagingService.instance().knowsVersion(endpoint) &&
                MessagingService.instance().getRawVersion(endpoint) == MessagingService.current_version)
            pushSchemaMutation(endpoint, schema);
    }

    return f;
}
 

import org.apache.cassandra.utils.WrappedRunnable; //导入依赖的package包/类
@Test
public void testEmptyRow() throws Exception
{
    Keyspace keyspace = Keyspace.open(KEYSPACE1);
    final ColumnFamilyStore cfs = keyspace.getColumnFamilyStore(CF_STANDARD2);

    RowUpdateBuilder.deleteRow(cfs.metadata, FBUtilities.timestampMicros(), "key1", "Column1").applyUnsafe();

    Runnable r = new WrappedRunnable()
    {
        public void runMayThrow() throws IOException
        {
            Row toCheck = Util.getOnlyRowUnfiltered(Util.cmd(cfs, "key1").build());
            Iterator<Cell> iter = toCheck.cells().iterator();
            assert(Iterators.size(iter) == 0);
        }
    };

    reTest(cfs, r);
}
 

import org.apache.cassandra.utils.WrappedRunnable; //导入依赖的package包/类
public Future<?> submitMaximal(final ColumnFamilyStore cfStore, final int gcBefore)
{
    // here we compute the task off the compaction executor, so having that present doesn't
    // confuse runWithCompactionsDisabled -- i.e., we don't want to deadlock ourselves, waiting
    // for ourselves to finish/acknowledge cancellation before continuing.
    final Collection<AbstractCompactionTask> tasks = cfStore.getCompactionStrategy().getMaximalTask(gcBefore);
    Runnable runnable = new WrappedRunnable()
    {
        protected void runMayThrow() throws IOException
        {
            if (tasks == null)
                return;
            for (AbstractCompactionTask task : tasks)
                task.execute(metrics);
        }
    };
    return executor.submit(runnable);
}
 

import org.apache.cassandra.utils.WrappedRunnable; //导入依赖的package包/类
public static void trace(final ByteBuffer sessionIdBytes, final String message, final int elapsed)
{
    final ByteBuffer eventId = ByteBuffer.wrap(UUIDGen.getTimeUUIDBytes());
    final String threadName = Thread.currentThread().getName();

    StageManager.getStage(Stage.TRACING).execute(new WrappedRunnable()
    {
        public void runMayThrow()
        {
            CFMetaData cfMeta = CFMetaData.TraceEventsCf;
            ColumnFamily cf = ArrayBackedSortedColumns.factory.create(cfMeta);
            Tracing.addColumn(cf, Tracing.buildName(cfMeta, eventId, ByteBufferUtil.bytes("activity")), message);
            Tracing.addColumn(cf, Tracing.buildName(cfMeta, eventId, ByteBufferUtil.bytes("source")), FBUtilities.getBroadcastAddress());
            if (elapsed >= 0)
                Tracing.addColumn(cf, Tracing.buildName(cfMeta, eventId, ByteBufferUtil.bytes("source_elapsed")), elapsed);
            Tracing.addColumn(cf, Tracing.buildName(cfMeta, eventId, ByteBufferUtil.bytes("thread")), threadName);
            Tracing.mutateWithCatch(new Mutation(Tracing.TRACE_KS, sessionIdBytes, cf));
        }
    });
}
 

import org.apache.cassandra.utils.WrappedRunnable; //导入依赖的package包/类
private static Future<?> announce(final Collection<RowMutation> schema)
{
    Future<?> f = StageManager.getStage(Stage.MIGRATION).submit(new WrappedRunnable()
    {
        protected void runMayThrow() throws IOException, ConfigurationException
        {
            DefsTable.mergeSchema(schema);
        }
    });

    for (InetAddress endpoint : Gossiper.instance.getLiveMembers())
    {
        if (endpoint.equals(FBUtilities.getBroadcastAddress()))
            continue; // we've dealt with localhost already

        // don't send schema to the nodes with the versions older than current major
        if (MessagingService.instance().getVersion(endpoint) < MessagingService.current_version)
            continue;

        pushSchemaMutation(endpoint, schema);
    }
    return f;
}
 

import org.apache.cassandra.utils.WrappedRunnable; //导入依赖的package包/类
public void start()
{
    MBeanServer mbs = ManagementFactory.getPlatformMBeanServer();
    try
    {
        mbs.registerMBean(this, new ObjectName(MBEAN_NAME));
    }
    catch (Exception e)
    {
        throw new RuntimeException(e);
    }

    Runnable runnable = new WrappedRunnable()
    {
        public void runMayThrow() throws ExecutionException, InterruptedException
        {
            replayAllFailedBatches();
        }
    };
    StorageService.optionalTasks.scheduleWithFixedDelay(runnable, StorageService.RING_DELAY, REPLAY_INTERVAL, TimeUnit.MILLISECONDS);
}