Unnamed: 0
int64 0
6.7k
| func
stringlengths 12
89.6k
| target
bool 2
classes | project
stringlengths 45
151
|
|---|---|---|---|
500
|
public class LifeSupportTest
{
@Test
public void testOkLifecycle()
throws LifecycleException
{
LifeSupport lifeSupport = newLifeSupport();
LifecycleMock instance1 = new LifecycleMock( null, null, null, null );
lifeSupport.add( instance1 );
LifecycleMock instance2 = new LifecycleMock( null, null, null, null );
lifeSupport.add( instance2 );
LifecycleMock instance3 = new LifecycleMock( null, null, null, null );
lifeSupport.add( instance3 );
lifeSupport.init();
assertEquals( LifecycleStatus.STOPPED, lifeSupport.getStatus());
assertEquals( LifecycleStatus.STOPPED, instance1.getStatus());
assertEquals( LifecycleStatus.STOPPED, instance2.getStatus());
assertEquals( LifecycleStatus.STOPPED, instance3.getStatus());
lifeSupport.start();
assertEquals( LifecycleStatus.STARTED, lifeSupport.getStatus());
assertEquals( LifecycleStatus.STARTED, instance1.getStatus());
assertEquals( LifecycleStatus.STARTED, instance2.getStatus() );
assertEquals( LifecycleStatus.STARTED, instance3.getStatus());
lifeSupport.stop();
assertEquals( LifecycleStatus.STOPPED, lifeSupport.getStatus());
assertEquals( LifecycleStatus.STOPPED, instance1.getStatus());
assertEquals( LifecycleStatus.STOPPED, instance2.getStatus());
assertEquals( LifecycleStatus.STOPPED, instance3.getStatus());
lifeSupport.start();
assertEquals( LifecycleStatus.STARTED, lifeSupport.getStatus());
assertEquals( LifecycleStatus.STARTED, instance1.getStatus());
assertEquals( LifecycleStatus.STARTED, instance2.getStatus());
assertEquals( LifecycleStatus.STARTED, instance3.getStatus());
lifeSupport.shutdown();
assertEquals( LifecycleStatus.SHUTDOWN, lifeSupport.getStatus());
assertEquals( LifecycleStatus.SHUTDOWN, instance1.getStatus());
assertEquals( LifecycleStatus.SHUTDOWN, instance2.getStatus());
assertEquals( LifecycleStatus.SHUTDOWN, instance3.getStatus());
}
@Test()
public void testFailingInit()
{
LifeSupport lifeSupport = newLifeSupport();
LifecycleMock instance1 = new LifecycleMock( null, null, null, null );
lifeSupport.add( instance1 );
Exception initThrowable = new Exception();
LifecycleMock instance2 = new LifecycleMock( initThrowable, null, null, null );
lifeSupport.add( instance2 );
LifecycleMock instance3 = new LifecycleMock( null, null, null, null );
lifeSupport.add( instance3 );
try
{
lifeSupport.init();
Assert.fail( );
}
catch( LifecycleException throwable )
{
assertEquals( initThrowable, throwable.getCause() );
}
assertEquals( LifecycleStatus.SHUTDOWN, lifeSupport.getStatus());
assertEquals( LifecycleStatus.SHUTDOWN , instance1.getStatus());
assertEquals( LifecycleStatus.NONE , instance2.getStatus() );
assertEquals( LifecycleStatus.NONE , instance3.getStatus() );
}
@Test()
public void testFailingStart()
{
LifeSupport lifeSupport = newLifeSupport();
LifecycleMock instance1 = new LifecycleMock( null, null, null, null );
lifeSupport.add( instance1 );
Exception startThrowable = new Exception();
LifecycleMock instance2 = new LifecycleMock( null, startThrowable, null, null );
lifeSupport.add( instance2 );
LifecycleMock instance3 = new LifecycleMock( null, null, null, null );
lifeSupport.add( instance3 );
try
{
lifeSupport.start();
Assert.fail( );
}
catch( LifecycleException throwable )
{
assertEquals( startThrowable, throwable.getCause());
}
assertEquals( LifecycleStatus.STOPPED, lifeSupport.getStatus());
assertEquals( LifecycleStatus.STOPPED , instance1.getStatus());
assertEquals( LifecycleStatus.STOPPED , instance2.getStatus() );
assertEquals( LifecycleStatus.STOPPED , instance3.getStatus() );
}
@Test()
public void testFailingStartAndFailingStop()
{
LifeSupport lifeSupport = newLifeSupport();
Exception stopThrowable = new Exception();
LifecycleMock instance1 = new LifecycleMock( null, null, stopThrowable, null );
lifeSupport.add( instance1 );
Exception startThrowable = new Exception();
LifecycleMock instance2 = new LifecycleMock( null, startThrowable, null, null );
lifeSupport.add( instance2 );
LifecycleMock instance3 = new LifecycleMock( null, null, null, null );
lifeSupport.add( instance3 );
try
{
lifeSupport.start();
Assert.fail( );
}
catch( LifecycleException throwable )
{
assertEquals( stopThrowable, throwable.getCause());
assertEquals( startThrowable, throwable.getCause().getCause().getCause() );
}
lifeSupport.dump( StringLogger.DEV_NULL );
assertEquals( LifecycleStatus.STOPPED, lifeSupport.getStatus() );
assertEquals( LifecycleStatus.STOPPED , instance1.getStatus());
assertEquals( LifecycleStatus.STOPPED , instance2.getStatus() );
assertEquals( LifecycleStatus.STOPPED , instance3.getStatus() );
}
@Test()
public void testFailingStop()
throws LifecycleException
{
LifeSupport lifeSupport = newLifeSupport();
LifecycleMock instance1 = new LifecycleMock( null, null, null, null );
lifeSupport.add( instance1 );
Exception stopThrowable = new Exception();
LifecycleMock instance2 = new LifecycleMock( null, null, stopThrowable, null );
lifeSupport.add( instance2 );
LifecycleMock instance3 = new LifecycleMock( null, null, null, null );
lifeSupport.add( instance3 );
lifeSupport.start();
try
{
lifeSupport.stop();
Assert.fail( );
}
catch( LifecycleException throwable )
{
assertEquals( stopThrowable, throwable.getCause());
}
assertEquals( LifecycleStatus.STOPPED, lifeSupport.getStatus());
assertEquals( LifecycleStatus.STOPPED , instance1.getStatus());
assertEquals( LifecycleStatus.STOPPED , instance2.getStatus() );
assertEquals( LifecycleStatus.STOPPED , instance3.getStatus() );
}
@Test()
public void testFailingShutdown()
throws LifecycleException
{
LifeSupport lifeSupport = newLifeSupport();
LifecycleMock instance1 = new LifecycleMock( null, null, null, null );
lifeSupport.add( instance1 );
Exception shutdownThrowable = new Exception();
LifecycleMock instance2 = new LifecycleMock( null, null, null, shutdownThrowable );
lifeSupport.add( instance2 );
LifecycleMock instance3 = new LifecycleMock( null, null, null, null );
lifeSupport.add( instance3 );
lifeSupport.start();
try
{
lifeSupport.shutdown();
Assert.fail( );
}
catch( LifecycleException throwable )
{
assertEquals( shutdownThrowable, throwable.getCause());
}
assertEquals( LifecycleStatus.SHUTDOWN, lifeSupport.getStatus());
assertEquals( LifecycleStatus.SHUTDOWN , instance1.getStatus());
assertEquals( LifecycleStatus.SHUTDOWN , instance2.getStatus() );
assertEquals( LifecycleStatus.SHUTDOWN , instance3.getStatus() );
}
@Test
public void testRestartOk()
throws LifecycleException
{
LifeSupport lifeSupport = newLifeSupport();
LifecycleMock instance1 = new LifecycleMock( null, null, null, null );
lifeSupport.add( instance1 );
LifecycleMock instance2 = new LifecycleMock( null, null, null, null );
lifeSupport.add( instance2 );
LifecycleMock instance3 = new LifecycleMock( null, null, null, null );
lifeSupport.add( instance3 );
lifeSupport.init();
assertEquals( LifecycleStatus.STOPPED, lifeSupport.getStatus());
assertEquals( LifecycleStatus.STOPPED, instance1.getStatus());
assertEquals( LifecycleStatus.STOPPED, instance2.getStatus());
assertEquals( LifecycleStatus.STOPPED, instance3.getStatus());
lifeSupport.start();
assertEquals( LifecycleStatus.STARTED, lifeSupport.getStatus());
assertEquals( LifecycleStatus.STARTED, instance1.getStatus());
assertEquals( LifecycleStatus.STARTED, instance2.getStatus() );
assertEquals( LifecycleStatus.STARTED, instance3.getStatus());
lifeSupport.stop();
assertEquals( LifecycleStatus.STOPPED, lifeSupport.getStatus());
assertEquals( LifecycleStatus.STOPPED, instance1.getStatus());
assertEquals( LifecycleStatus.STOPPED, instance2.getStatus());
assertEquals( LifecycleStatus.STOPPED, instance3.getStatus());
lifeSupport.start();
assertEquals( LifecycleStatus.STARTED, lifeSupport.getStatus());
assertEquals( LifecycleStatus.STARTED, instance1.getStatus());
assertEquals( LifecycleStatus.STARTED, instance2.getStatus());
assertEquals( LifecycleStatus.STARTED, instance3.getStatus());
lifeSupport.shutdown();
assertEquals( LifecycleStatus.SHUTDOWN, lifeSupport.getStatus());
assertEquals( LifecycleStatus.SHUTDOWN, instance1.getStatus());
assertEquals( LifecycleStatus.SHUTDOWN, instance2.getStatus());
assertEquals( LifecycleStatus.SHUTDOWN, instance3.getStatus());
}
@Test
public void testAddInstanceWhenInitInitsInstance()
throws LifecycleException
{
LifeSupport support = newLifeSupport();
support.init();
LifecycleMock instance1 = new LifecycleMock( null, null, null, null );
support.add( instance1 );
assertEquals( LifecycleStatus.STOPPED, instance1.getStatus() );
assertEquals( LifecycleStatus.NONE, instance1.transitions.get( 0 ) );
assertEquals( 2, instance1.transitions.size() );
}
@Test
public void testAddInstanceWhenStartedStartsInstance()
throws LifecycleException
{
LifeSupport support = newLifeSupport();
support.init();
support.start();
LifecycleMock instance1 = new LifecycleMock( null, null, null, null );
support.add( instance1 );
assertEquals( LifecycleStatus.STARTED, instance1.getStatus() );
assertEquals( LifecycleStatus.NONE, instance1.transitions.get( 0 ) );
assertEquals( LifecycleStatus.STOPPED, instance1.transitions.get( 1 ) );
assertEquals( 3, instance1.transitions.size() );
}
@Test
public void testAddInstanceWhenStoppedInitsInstance()
throws LifecycleException
{
LifeSupport support = newLifeSupport();
support.init();
support.start();
support.stop();
LifecycleMock instance1 = new LifecycleMock( null, null, null, null );
support.add( instance1 );
assertEquals( LifecycleStatus.STOPPED, instance1.getStatus() );
assertEquals( LifecycleStatus.NONE, instance1.transitions.get( 0 ) );
assertEquals( LifecycleStatus.STOPPED, instance1.transitions.get( 1 ) );
assertEquals( 2, instance1.transitions.size() );
}
@Test
public void testAddInstanceWhenShutdownDoesNotAffectInstance()
throws LifecycleException
{
LifeSupport support = newLifeSupport();
support.init();
support.start();
support.stop();
support.shutdown();
LifecycleMock instance1 = new LifecycleMock( null, null, null, null );
support.add( instance1 );
assertEquals( LifecycleStatus.NONE, instance1.getStatus() );
assertEquals( 1, instance1.transitions.size() );
}
public class LifecycleMock
implements Lifecycle
{
Throwable initThrowable;
Throwable startThrowable;
Throwable stopThrowable;
Throwable shutdownThrowable;
List<LifecycleStatus> transitions;
public LifecycleMock( Throwable initThrowable,
Throwable startThrowable,
Throwable stopThrowable,
Throwable shutdownThrowable
)
{
this.initThrowable = initThrowable;
this.startThrowable = startThrowable;
this.stopThrowable = stopThrowable;
this.shutdownThrowable = shutdownThrowable;
transitions = new LinkedList<LifecycleStatus>();
transitions.add( LifecycleStatus.NONE );
}
@Override
public void init()
throws Throwable
{
if (initThrowable != null)
throw initThrowable;
transitions.add(LifecycleStatus.STOPPED);
}
@Override
public void start()
throws Throwable
{
if (startThrowable != null)
throw startThrowable;
transitions.add(LifecycleStatus.STARTED);
}
@Override
public void stop()
throws Throwable
{
transitions.add(LifecycleStatus.STOPPED);
if (stopThrowable != null)
throw stopThrowable;
}
@Override
public void shutdown()
throws Throwable
{
transitions.add(LifecycleStatus.SHUTDOWN);
if (shutdownThrowable != null)
throw shutdownThrowable;
}
public LifecycleStatus getStatus()
{
return transitions.get( transitions.size() - 1 );
}
}
private LifeSupport newLifeSupport()
{
return new LifeSupport( StringLogger.DEV_NULL );
}
}
| false
|
community_kernel_src_test_java_org_neo4j_kernel_lifecycle_LifeSupportTest.java
|
501
|
public class LifecycleMock
implements Lifecycle
{
Throwable initThrowable;
Throwable startThrowable;
Throwable stopThrowable;
Throwable shutdownThrowable;
List<LifecycleStatus> transitions;
public LifecycleMock( Throwable initThrowable,
Throwable startThrowable,
Throwable stopThrowable,
Throwable shutdownThrowable
)
{
this.initThrowable = initThrowable;
this.startThrowable = startThrowable;
this.stopThrowable = stopThrowable;
this.shutdownThrowable = shutdownThrowable;
transitions = new LinkedList<LifecycleStatus>();
transitions.add( LifecycleStatus.NONE );
}
@Override
public void init()
throws Throwable
{
if (initThrowable != null)
throw initThrowable;
transitions.add(LifecycleStatus.STOPPED);
}
@Override
public void start()
throws Throwable
{
if (startThrowable != null)
throw startThrowable;
transitions.add(LifecycleStatus.STARTED);
}
@Override
public void stop()
throws Throwable
{
transitions.add(LifecycleStatus.STOPPED);
if (stopThrowable != null)
throw stopThrowable;
}
@Override
public void shutdown()
throws Throwable
{
transitions.add(LifecycleStatus.SHUTDOWN);
if (shutdownThrowable != null)
throw shutdownThrowable;
}
public LifecycleStatus getStatus()
{
return transitions.get( transitions.size() - 1 );
}
}
| false
|
community_kernel_src_test_java_org_neo4j_kernel_lifecycle_LifeSupportTest.java
|
502
|
public class LifecycleAdapter
implements Lifecycle
{
@Override
public void init()
throws Throwable
{
}
@Override
public void start()
throws Throwable
{
}
@Override
public void stop()
throws Throwable
{
}
@Override
public void shutdown()
throws Throwable
{
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_lifecycle_LifecycleAdapter.java
|
503
|
MISS_COUNT
{
@Override
long get( Cache bean )
{
return bean.getMissCount();
}
};
| false
|
advanced_management_src_test_java_org_neo4j_management_TestCacheBeans.java
|
504
|
private static class LockManagerImpl extends Neo4jMBean implements LockManager
{
private final org.neo4j.kernel.impl.transaction.LockManager lockManager;
LockManagerImpl( ManagementData management ) throws NotCompliantMBeanException
{
super( management );
this.lockManager = lockManager( management );
}
private org.neo4j.kernel.impl.transaction.LockManager lockManager( ManagementData management )
{
return management.getKernelData().graphDatabase().getDependencyResolver()
.resolveDependency( org.neo4j.kernel.impl.transaction.LockManager.class );
}
LockManagerImpl( ManagementData management, boolean mxBean )
{
super( management, mxBean );
this.lockManager = lockManager( management );
}
@Override
public long getNumberOfAvertedDeadlocks()
{
return lockManager.getDetectedDeadlockCount();
}
@Override
public List<LockInfo> getLocks()
{
return lockManager.getAllLocks();
}
@Override
public List<LockInfo> getContendedLocks( long minWaitTime )
{
return lockManager.getAwaitedLocks( minWaitTime );
}
}
| false
|
advanced_management_src_main_java_org_neo4j_management_impl_LockManagerBean.java
|
505
|
@Service.Implementation( ManagementBeanProvider.class )
public final class LockManagerBean extends ManagementBeanProvider
{
public LockManagerBean()
{
super( LockManager.class );
}
@Override
protected Neo4jMBean createMBean( ManagementData management ) throws NotCompliantMBeanException
{
return new LockManagerImpl( management );
}
@Override
protected Neo4jMBean createMXBean( ManagementData management ) throws NotCompliantMBeanException
{
return new LockManagerImpl( management, true );
}
private static class LockManagerImpl extends Neo4jMBean implements LockManager
{
private final org.neo4j.kernel.impl.transaction.LockManager lockManager;
LockManagerImpl( ManagementData management ) throws NotCompliantMBeanException
{
super( management );
this.lockManager = lockManager( management );
}
private org.neo4j.kernel.impl.transaction.LockManager lockManager( ManagementData management )
{
return management.getKernelData().graphDatabase().getDependencyResolver()
.resolveDependency( org.neo4j.kernel.impl.transaction.LockManager.class );
}
LockManagerImpl( ManagementData management, boolean mxBean )
{
super( management, mxBean );
this.lockManager = lockManager( management );
}
@Override
public long getNumberOfAvertedDeadlocks()
{
return lockManager.getDetectedDeadlockCount();
}
@Override
public List<LockInfo> getLocks()
{
return lockManager.getAllLocks();
}
@Override
public List<LockInfo> getContendedLocks( long minWaitTime )
{
return lockManager.getAwaitedLocks( minWaitTime );
}
}
}
| false
|
advanced_management_src_main_java_org_neo4j_management_impl_LockManagerBean.java
|
506
|
public abstract class KernelProxy
{
static final String KERNEL_BEAN_TYPE = "org.neo4j.jmx.Kernel";
protected static final String KERNEL_BEAN_NAME = "Kernel";
static final String MBEAN_QUERY = "MBeanQuery";
protected final MBeanServerConnection server;
protected final ObjectName kernel;
protected KernelProxy( MBeanServerConnection server, ObjectName kernel )
{
String className = null;
try
{
className = server.getMBeanInfo( kernel ).getClassName();
}
catch ( Exception e )
{
// fall through
}
if ( !KERNEL_BEAN_TYPE.equals( className ) )
{
throw new IllegalArgumentException(
"The specified ObjectName does not represent a Neo4j Kernel bean in the specified MBean server." );
}
this.server = server;
this.kernel = kernel;
}
protected List<Object> allBeans()
{
List<Object> beans = new ArrayList<Object>();
Iterable<ObjectInstance> mbeans;
try
{
mbeans = server.queryMBeans( mbeanQuery(), null );
}
catch ( IOException handled )
{
return beans;
}
for ( ObjectInstance instance : mbeans )
{
String className = instance.getClassName();
Class<?> beanType = null;
try
{
if ( className != null ) beanType = Class.forName( className );
}
catch ( Exception ignored )
{
// fall through
}
catch ( LinkageError ignored )
{
// fall through
}
if ( beanType != null )
{
try
{
beans.add( BeanProxy.load( server, beanType, instance.getObjectName() ) );
}
catch ( Exception ignored )
{
// fall through
}
}
}
return beans;
}
private ObjectName assertExists( ObjectName name )
{
try
{
if ( !server.queryNames( name, null ).isEmpty() )
{
return name;
}
}
catch ( IOException handled )
{
// fall through
}
throw new NoSuchElementException( "No MBeans matching " + name );
}
protected <T> T getBean( Class<T> beanInterface )
{
return BeanProxy.load( server, beanInterface, createObjectName( beanInterface ) );
}
protected <T> Collection<T> getBeans( Class<T> beanInterface )
{
return BeanProxy.loadAll( server, beanInterface, createObjectNameQuery( beanInterface ) );
}
private ObjectName createObjectNameQuery( Class<?> beanInterface )
{
return createObjectNameQuery( mbeanQuery(), beanInterface );
}
private ObjectName createObjectName( Class<?> beanInterface )
{
return assertExists( createObjectName( mbeanQuery(), beanInterface ) );
}
protected ObjectName createObjectName( String beanName )
{
return assertExists( createObjectName( mbeanQuery(), beanName, false ) );
}
protected ObjectName mbeanQuery()
{
try
{
return (ObjectName) server.getAttribute( kernel, MBEAN_QUERY );
}
catch ( Exception cause )
{
throw new IllegalStateException( "Could not get MBean query.", cause );
}
}
protected static ObjectName createObjectName( String kernelIdentifier, Class<?> beanInterface )
{
return createObjectName( kernelIdentifier, beanName( beanInterface ) );
}
protected static ObjectName createObjectName( String kernelIdentifier, String beanName, String... extraNaming )
{
Hashtable<String, String> properties = new Hashtable<String, String>();
properties.put( "instance", "kernel#" + kernelIdentifier );
return createObjectName( "org.neo4j", properties, beanName, false, extraNaming );
}
static ObjectName createObjectNameQuery( String kernelIdentifier, String beanName, String... extraNaming )
{
Hashtable<String, String> properties = new Hashtable<String, String>();
properties.put( "instance", "kernel#" + kernelIdentifier );
return createObjectName( "org.neo4j", properties, beanName, true, extraNaming );
}
static ObjectName createObjectName( ObjectName query, Class<?> beanInterface )
{
return createObjectName( query, beanName( beanInterface ), false );
}
static ObjectName createObjectNameQuery( ObjectName query, Class<?> beanInterface )
{
return createObjectName( query, beanName( beanInterface ), true );
}
private static ObjectName createObjectName( ObjectName query, String beanName, boolean isQuery )
{
Hashtable<String, String> properties = new Hashtable<String, String>(query.getKeyPropertyList());
return createObjectName( query.getDomain(), properties, beanName, isQuery );
}
static String beanName( Class<?> beanInterface )
{
if ( beanInterface.isInterface() )
{
ManagementInterface management = beanInterface.getAnnotation( ManagementInterface.class );
if ( management != null )
{
return management.name();
}
}
throw new IllegalArgumentException( beanInterface + " is not a Neo4j Management Been interface" );
}
private static ObjectName createObjectName( String domain, Hashtable<String, String> properties, String beanName,
boolean query, String... extraNaming )
{
properties.put( "name", beanName );
for ( int i = 0; i < extraNaming.length; i++ )
{
properties.put( "name" + i, extraNaming[i] );
}
ObjectName result;
try
{
result = new ObjectName( domain, properties );
if ( query ) result = ObjectName.getInstance( result.toString() + ",*" );
}
catch ( MalformedObjectNameException e )
{
return null;
}
return result;
}
}
| false
|
advanced_management_src_main_java_org_neo4j_management_impl_KernelProxy.java
|
507
|
@Service.Implementation( ManagementSupport.class )
public class HotspotManagementSupport extends AdvancedManagementSupport
{
@Override
protected JMXServiceURL getJMXServiceURL( KernelData kernel )
{
JMXServiceURL url = null;
StringLogger logger = kernel.graphDatabase().getDependencyResolver().resolveDependency( Logging.class )
.getMessagesLog( HotspotManagementSupport.class );
try
{
Class<?> cal = Class.forName( "sun.management.ConnectorAddressLink" );
try
{
Method importRemoteFrom = cal.getMethod( "importRemoteFrom", int.class );
@SuppressWarnings("unchecked")
Map<String, String> remote = (Map<String, String>) importRemoteFrom.invoke( null, 0 );
url = getUrlFrom( remote );
}
catch ( NoSuchMethodException ex )
{
// handled by null check
}
if ( url == null )
{
Method importFrom = cal.getMethod( "importFrom", int.class );
url = getUrlFrom( (String) importFrom.invoke( null, 0 ) );
}
}
catch ( InvocationTargetException e )
{
logger.warn( "Failed to load local JMX connection URL.", e.getTargetException() );
}
catch ( LinkageError e )
{
logger.warn( "Failed to load local JMX connection URL.", e );
}
catch ( Exception e )
{
logger.warn( "Failed to load local JMX connection URL.", e );
}
// No previous connection server -- create one!
if ( url == null )
{
int port = 0;
try
{
port = Integer.parseInt( kernel.getConfig().getParams().get( "jmx.port" ) );
}
catch ( NumberFormatException ok )
{
// handled by 0-check
}
if ( port > 0 )
{
boolean useSSL = Boolean.parseBoolean( kernel.getConfig().getParams().get( "jmx.use_ssl" ) );
logger.debug( format( "Creating new MBean server on port %s%s", port, useSSL ? " using ssl" : "" ) );
JMXConnectorServer server = createServer( port, useSSL, logger );
if ( server != null )
{
try
{
server.start();
}
catch ( IOException e )
{
logger.warn( "Failed to start MBean server", e );
server = null;
}
if ( server != null )
{
try
{
server.getMBeanServer().registerMBean( server,
KernelProxy.createObjectName( kernel.instanceId(), "JMX Server" ) );
}
catch ( Exception e )
{
logger.warn( "Failed to register MBean server as JMX bean", e );
}
url = server.getAddress();
}
}
}
}
return url;
}
private JMXServiceURL getUrlFrom( Map<String, String> remote )
{
Set<Integer> instances = new HashSet<Integer>();
for ( String key : remote.keySet() )
{
if ( key.startsWith( "sun.management.JMXConnectorServer" ) )
{
int end = key.lastIndexOf( '.' );
if ( end < 0 )
{
continue;
}
int start = key.lastIndexOf( '.', end );
if ( start < 0 )
{
continue;
}
final int id;
try
{
id = Integer.parseInt( key.substring( start, end ) );
}
catch ( NumberFormatException e )
{
continue;
}
instances.add( id );
}
}
if ( !instances.isEmpty() )
{
String prefix = "sun.management.JMXConnectorServer.";
if ( instances.size() > 1 )
{
for ( Object key : instances.toArray() )
{
if ( !remote.containsKey( "sun.management.JMXConnectorServer." + key + ".remoteAddress" ) )
{
instances.remove( key );
}
}
if ( instances.contains( Integer.valueOf( 0 ) ) )
{
prefix = prefix + "0.";
}
}
if ( instances.size() == 1 )
{
String remoteAddress = remote.get( prefix + instances.iterator().next() + "remoteAddress" );
try
{
return new JMXServiceURL( remoteAddress );
}
catch ( MalformedURLException e )
{
return null;
}
}
else if ( !instances.isEmpty() )
{
// TODO: find the appropriate one
}
}
return null;
}
private JMXServiceURL getUrlFrom( String url )
{
if ( url == null )
{
return null;
}
JMXServiceURL jmxUrl;
try
{
jmxUrl = new JMXServiceURL( url );
}
catch ( MalformedURLException e1 )
{
return null;
}
String host = null;
try
{
host = InetAddress.getLocalHost().getHostAddress();
}
catch ( UnknownHostException ok )
{
// handled by null check
}
if ( host == null )
{
host = jmxUrl.getHost();
}
try
{
return new JMXServiceURL( jmxUrl.getProtocol(), host, jmxUrl.getPort(), jmxUrl.getURLPath() );
}
catch ( MalformedURLException e )
{
return null;
}
}
private JMXConnectorServer createServer( int port, boolean useSSL, StringLogger logger )
{
MBeanServer server = getMBeanServer();
final JMXServiceURL url;
try
{
url = new JMXServiceURL( "rmi", null, port );
}
catch ( MalformedURLException e )
{
logger.warn( "Failed to start JMX Server", e );
return null;
}
Map<String, Object> env = new HashMap<String, Object>();
if ( useSSL )
{
env.put( RMIConnectorServer.RMI_CLIENT_SOCKET_FACTORY_ATTRIBUTE, new SslRMIClientSocketFactory() );
env.put( RMIConnectorServer.RMI_SERVER_SOCKET_FACTORY_ATTRIBUTE, new SslRMIServerSocketFactory() );
}
try
{
return JMXConnectorServerFactory.newJMXConnectorServer( url, env, server );
}
catch ( IOException e )
{
logger.warn( "Failed to start JMX Server", e );
return null;
}
}
}
| false
|
advanced_management_src_main_java_org_neo4j_management_impl_HotspotManagementSupport.java
|
508
|
private static class DiagnosticsImpl extends Neo4jMBean implements Diagnostics
{
private final DiagnosticsManager diagnostics;
DiagnosticsImpl( ManagementData management ) throws NotCompliantMBeanException
{
super( management );
DependencyResolver resolver = management.getKernelData().graphDatabase().getDependencyResolver();
this.diagnostics = resolver.resolveDependency( DiagnosticsManager.class );
}
@Override
public void dumpToLog()
{
diagnostics.dumpAll();
}
@Override
public List<String> getDiagnosticsProviders()
{
List<String> result = new ArrayList<>();
for ( DiagnosticsProvider provider : diagnostics )
{
result.add( provider.getDiagnosticsIdentifier() );
}
return result;
}
@Override
public void dumpToLog( String providerId )
{
diagnostics.dump( providerId );
}
@Override
public String dumpAll( )
{
StringBuffer result = new StringBuffer();
diagnostics.dumpAll(StringLogger.wrap( result ) );
return result.toString();
}
@Override
public String extract( String providerId )
{
StringBuffer result = new StringBuffer();
diagnostics.extract( providerId, StringLogger.wrap( result ) );
return result.toString();
}
}
| false
|
advanced_management_src_main_java_org_neo4j_management_impl_DiagnosticsBean.java
|
509
|
@Service.Implementation( ManagementBeanProvider.class )
public class DiagnosticsBean extends ManagementBeanProvider
{
public DiagnosticsBean()
{
super( Diagnostics.class );
}
@Override
protected Neo4jMBean createMBean( ManagementData management ) throws NotCompliantMBeanException
{
return new DiagnosticsImpl( management );
}
private static class DiagnosticsImpl extends Neo4jMBean implements Diagnostics
{
private final DiagnosticsManager diagnostics;
DiagnosticsImpl( ManagementData management ) throws NotCompliantMBeanException
{
super( management );
DependencyResolver resolver = management.getKernelData().graphDatabase().getDependencyResolver();
this.diagnostics = resolver.resolveDependency( DiagnosticsManager.class );
}
@Override
public void dumpToLog()
{
diagnostics.dumpAll();
}
@Override
public List<String> getDiagnosticsProviders()
{
List<String> result = new ArrayList<>();
for ( DiagnosticsProvider provider : diagnostics )
{
result.add( provider.getDiagnosticsIdentifier() );
}
return result;
}
@Override
public void dumpToLog( String providerId )
{
diagnostics.dump( providerId );
}
@Override
public String dumpAll( )
{
StringBuffer result = new StringBuffer();
diagnostics.dumpAll(StringLogger.wrap( result ) );
return result.toString();
}
@Override
public String extract( String providerId )
{
StringBuffer result = new StringBuffer();
diagnostics.extract( providerId, StringLogger.wrap( result ) );
return result.toString();
}
}
}
| false
|
advanced_management_src_main_java_org_neo4j_management_impl_DiagnosticsBean.java
|
510
|
private class DefaultManagementSupport extends ManagementSupport
{
@Override
protected ObjectName createObjectName( String instanceId, String beanName, boolean query, String... extraNaming )
{
return super.createObjectName( instanceId, beanName, query, extraNaming );
}
@Override
protected String getBeanName( Class<?> beanInterface )
{
return super.getBeanName( beanInterface );
}
}
| false
|
advanced_management_src_test_java_org_neo4j_management_impl_CodeDuplicationValidationTest.java
|
511
|
private class CustomManagementSupport extends AdvancedManagementSupport
{
// belongs to this package - no override needed
}
| false
|
advanced_management_src_test_java_org_neo4j_management_impl_CodeDuplicationValidationTest.java
|
512
|
public class CodeDuplicationValidationTest
{
private class DefaultManagementSupport extends ManagementSupport
{
@Override
protected ObjectName createObjectName( String instanceId, String beanName, boolean query, String... extraNaming )
{
return super.createObjectName( instanceId, beanName, query, extraNaming );
}
@Override
protected String getBeanName( Class<?> beanInterface )
{
return super.getBeanName( beanInterface );
}
}
private class CustomManagementSupport extends AdvancedManagementSupport
{
// belongs to this package - no override needed
}
@Test
public void kernelBeanTypeNameMatchesExpected() throws Exception
{
assertEquals( Kernel.class.getName(), KernelProxy.KERNEL_BEAN_TYPE );
assertEquals( Kernel.NAME, KernelProxy.KERNEL_BEAN_NAME );
}
@Test
public void mbeanQueryAttributeNameMatchesMethodName() throws Exception
{
assertEquals( ObjectName.class, Kernel.class.getMethod( "get" + KernelProxy.MBEAN_QUERY ).getReturnType() );
}
@Test
public void interfacesGetsTheSameBeanNames() throws Exception
{
assertEqualBeanName( Kernel.class );
assertEqualBeanName( Primitives.class );
assertEqualBeanName( Cache.class );
assertEqualBeanName( HighAvailability.class );
assertEqualBeanName( BranchedStore.class );
assertEqualBeanName( LockManager.class );
assertEqualBeanName( MemoryMapping.class );
assertEqualBeanName( StoreFile.class );
assertEqualBeanName( TransactionManager.class );
assertEqualBeanName( XaManager.class );
}
private void assertEqualBeanName( Class<?> beanClass )
{
assertEquals( new DefaultManagementSupport().getBeanName( beanClass ),
new CustomManagementSupport().getBeanName( beanClass ) );
}
@Test
public void generatesEqualObjectNames() throws Exception
{
assertEquals( new DefaultManagementSupport().createMBeanQuery( "test-instance" ),
new CustomManagementSupport().createMBeanQuery( "test-instance" ) );
assertEquals( new DefaultManagementSupport().createObjectName( "test-instace", Kernel.class ),
new CustomManagementSupport().createObjectName( "test-instace", Kernel.class ) );
}
}
| false
|
advanced_management_src_test_java_org_neo4j_management_impl_CodeDuplicationValidationTest.java
|
513
|
private class CacheManager extends Neo4jMBean implements org.neo4j.management.Cache
{
private final Cache cache;
private final NodeManager nodeManager;
CacheManager( ManagementData management, NodeManager nodeManager, Cache cache )
throws NotCompliantMBeanException
{
super( management, cache.getName() );
this.nodeManager = nodeManager;
this.cache = cache;
}
public String getCacheType()
{
return nodeManager.getCacheType().getDescription();
}
public void clear()
{
cache.clear();
}
@Override
public long getCacheSize()
{
return cache.size();
}
@Override
public long getHitCount()
{
return cache.hitCount();
}
@Override
public long getMissCount()
{
return cache.missCount();
}
}
| false
|
advanced_management_src_main_java_org_neo4j_management_impl_CacheBean.java
|
514
|
@Service.Implementation( ManagementBeanProvider.class )
public class CacheBean extends ManagementBeanProvider
{
public CacheBean()
{
super( org.neo4j.management.Cache.class );
}
@Override
protected Iterable<? extends Neo4jMBean> createMBeans( ManagementData management )
throws NotCompliantMBeanException
{
NodeManager nm = management.getKernelData().graphDatabase().getDependencyResolver()
.resolveDependency( NodeManager.class );
Collection<CacheManager> cacheBeans = new LinkedList<>();
for ( Cache<?> cache : nm.caches() )
{
cacheBeans.add( new CacheManager( management, nm, cache ) );
}
return cacheBeans;
}
@Override
protected Neo4jMBean createMBean( ManagementData management ) throws NotCompliantMBeanException
{
throw new UnsupportedOperationException( "Uses createMBeans" );
}
private class CacheManager extends Neo4jMBean implements org.neo4j.management.Cache
{
private final Cache cache;
private final NodeManager nodeManager;
CacheManager( ManagementData management, NodeManager nodeManager, Cache cache )
throws NotCompliantMBeanException
{
super( management, cache.getName() );
this.nodeManager = nodeManager;
this.cache = cache;
}
public String getCacheType()
{
return nodeManager.getCacheType().getDescription();
}
public void clear()
{
cache.clear();
}
@Override
public long getCacheSize()
{
return cache.size();
}
@Override
public long getHitCount()
{
return cache.hitCount();
}
@Override
public long getMissCount()
{
return cache.missCount();
}
}
}
| false
|
advanced_management_src_main_java_org_neo4j_management_impl_CacheBean.java
|
515
|
private static class Java6ProxyMaker extends BeanProxy
{
private final Method newMXBeanProxy;
Java6ProxyMaker() throws Exception
{
super( true );
Class<?> JMX = Class.forName( "javax.management.JMX" );
this.newMXBeanProxy = JMX.getMethod( "newMXBeanProxy", MBeanServerConnection.class,
ObjectName.class, Class.class );
}
@Override
<T> T makeProxy( MBeanServerConnection mbs, Class<T> beanType, ObjectName name )
{
try
{
return beanType.cast( newMXBeanProxy.invoke( null, mbs, name, beanType ) );
}
catch ( InvocationTargetException exception )
{
throw launderRuntimeException( exception.getTargetException() );
}
catch ( Exception exception )
{
throw new UnsupportedOperationException(
"Creating Management Bean proxies requires Java 1.6", exception );
}
}
static RuntimeException launderRuntimeException( Throwable exception )
{
if ( exception instanceof RuntimeException )
{
return (RuntimeException) exception;
}
else if ( exception instanceof Error )
{
throw (Error) exception;
}
else
{
throw new RuntimeException( "Unexpected Exception!", exception );
}
}
}
| false
|
advanced_management_src_main_java_org_neo4j_management_impl_BeanProxy.java
|
516
|
private static class Java5ProxyMaker extends BeanProxy
{
Java5ProxyMaker() throws Exception
{
super( false );
Class.forName( "javax.management.MBeanServerInvocationHandler" );
}
@Override
<T> T makeProxy( MBeanServerConnection mbs, Class<T> beanType, ObjectName name )
{
return MBeanServerInvocationHandler.newProxyInstance( mbs, name, beanType, false );
}
}
| false
|
advanced_management_src_main_java_org_neo4j_management_impl_BeanProxy.java
|
517
|
abstract class BeanProxy
{
final boolean supportsMxBeans;
private BeanProxy( boolean supportsMxBeans )
{
this.supportsMxBeans = supportsMxBeans;
}
public static <T> T load( MBeanServerConnection mbs, Class<T> beanInterface, ObjectName name )
{
return factory.makeProxy( mbs, beanInterface, name );
}
public static <T> Collection<T> loadAll( MBeanServerConnection mbs, Class<T> beanInterface, ObjectName query )
{
Collection<T> beans = new LinkedList<T>();
try
{
for ( ObjectName name : mbs.queryNames( query, null ) )
{
beans.add( factory.makeProxy( mbs, beanInterface, name ) );
}
}
catch ( IOException e )
{
// fall through and return the empty collection...
}
return beans;
}
static boolean supportsMxBeans()
{
return factory != null && factory.supportsMxBeans;
}
abstract <T> T makeProxy( MBeanServerConnection mbs, Class<T> beanInterface, ObjectName name );
private static final BeanProxy factory;
static
{
BeanProxy proxyMaker;
try
{
proxyMaker = new Java6ProxyMaker();
}
catch ( Exception t )
{
proxyMaker = null;
}
catch ( LinkageError t )
{
proxyMaker = null;
}
if ( proxyMaker == null )
{
try
{
proxyMaker = new Java5ProxyMaker();
}
catch ( Exception t )
{
proxyMaker = null;
}
catch ( LinkageError t )
{
proxyMaker = null;
}
}
factory = proxyMaker;
}
private static class Java6ProxyMaker extends BeanProxy
{
private final Method newMXBeanProxy;
Java6ProxyMaker() throws Exception
{
super( true );
Class<?> JMX = Class.forName( "javax.management.JMX" );
this.newMXBeanProxy = JMX.getMethod( "newMXBeanProxy", MBeanServerConnection.class,
ObjectName.class, Class.class );
}
@Override
<T> T makeProxy( MBeanServerConnection mbs, Class<T> beanType, ObjectName name )
{
try
{
return beanType.cast( newMXBeanProxy.invoke( null, mbs, name, beanType ) );
}
catch ( InvocationTargetException exception )
{
throw launderRuntimeException( exception.getTargetException() );
}
catch ( Exception exception )
{
throw new UnsupportedOperationException(
"Creating Management Bean proxies requires Java 1.6", exception );
}
}
static RuntimeException launderRuntimeException( Throwable exception )
{
if ( exception instanceof RuntimeException )
{
return (RuntimeException) exception;
}
else if ( exception instanceof Error )
{
throw (Error) exception;
}
else
{
throw new RuntimeException( "Unexpected Exception!", exception );
}
}
}
private static class Java5ProxyMaker extends BeanProxy
{
Java5ProxyMaker() throws Exception
{
super( false );
Class.forName( "javax.management.MBeanServerInvocationHandler" );
}
@Override
<T> T makeProxy( MBeanServerConnection mbs, Class<T> beanType, ObjectName name )
{
return MBeanServerInvocationHandler.newProxyInstance( mbs, name, beanType, false );
}
}
}
| false
|
advanced_management_src_main_java_org_neo4j_management_impl_BeanProxy.java
|
518
|
abstract class AdvancedManagementSupport extends ManagementSupport
{
@Override
protected final boolean supportsMxBeans()
{
return BeanProxy.supportsMxBeans();
}
@Override
protected final <T> T makeProxy( KernelBean kernel, ObjectName name, Class<T> beanInterface )
{
return BeanProxy.load( getMBeanServer(), beanInterface, name );
}
@Override
protected String getBeanName( Class<?> beanInterface )
{
if ( beanInterface == DynamicMBean.class ) return ConfigurationBean.CONFIGURATION_MBEAN_NAME;
return KernelProxy.beanName( beanInterface );
}
@Override
protected ObjectName createObjectName( String instanceId, String beanName, boolean query, String... extraNaming )
{
return query ? KernelProxy.createObjectNameQuery( instanceId, beanName, extraNaming ) : KernelProxy
.createObjectName( instanceId, beanName, extraNaming );
}
}
| false
|
advanced_management_src_main_java_org_neo4j_management_impl_AdvancedManagementSupport.java
|
519
|
@SuppressWarnings( "serial" )
public final class XaResourceInfo implements Serializable
{
private final String name;
private final String branchId;
private final long lastTxId;
private final long logVersion;
@ConstructorProperties( { "name", "branchId", "lastTxId", "logVersion" } )
public XaResourceInfo( String name, String branchId, long lastTxId, long logVersion )
{
this.name = name;
this.branchId = branchId;
this.lastTxId = lastTxId;
this.logVersion = logVersion;
}
public String getName()
{
return name;
}
public String getBranchId()
{
return branchId;
}
public long getLastTxId()
{
return lastTxId;
}
public long getLogVersion()
{
return logVersion;
}
}
| false
|
advanced_management_src_main_java_org_neo4j_management_XaResourceInfo.java
|
520
|
public final class WindowPoolInfo implements Serializable
{
private static final long serialVersionUID = 1L;
private final String name;
private final long memAvail;
private final long memUsed;
private final int windowCount;
private final int windowSize;
private final int hitCount;
private final int missCount;
private final int oomCount;
@ConstructorProperties( { "windowPoolName", "availableMemory",
"usedMemory", "numberOfWindows", "windowSize", "windowHitCount",
"windowMissCount", "numberOfOutOfMemory" } )
public WindowPoolInfo( String name, long memAvail, long memUsed,
int windowCount, int windowSize, int hitCount, int missCount,
int oomCount )
{
this.name = name;
this.memAvail = memAvail;
this.memUsed = memUsed;
this.windowCount = windowCount;
this.windowSize = windowSize;
this.hitCount = hitCount;
this.missCount = missCount;
this.oomCount = oomCount;
}
public String getWindowPoolName()
{
return name;
}
public long getAvailableMemory()
{
return memAvail;
}
public long getUsedMemory()
{
return memUsed;
}
public int getNumberOfWindows()
{
return windowCount;
}
public int getWindowSize()
{
return windowSize;
}
public int getWindowHitCount()
{
return hitCount;
}
public int getWindowMissCount()
{
return missCount;
}
public int getNumberOfOutOfMemory()
{
return oomCount;
}
}
| false
|
advanced_management_src_main_java_org_neo4j_management_WindowPoolInfo.java
|
521
|
public class TestXaManagerBeans
{
private GraphDatabaseAPI graphDb;
private XaManager xaManager;
private TargetDirectory dir = TargetDirectory.forTest( getClass() );
@Before
public synchronized void startGraphDb()
{
graphDb = (GraphDatabaseAPI) new GraphDatabaseFactory().newEmbeddedDatabase(dir.cleanDirectory( "test" ).getAbsolutePath() );
xaManager = graphDb.getDependencyResolver().resolveDependency( JmxKernelExtension.class )
.getSingleManagementBean( XaManager.class );
}
@After
public synchronized void stopGraphDb()
{
if ( graphDb != null )
{
graphDb.shutdown();
}
graphDb = null;
}
@Test
public void canAccessXaManagerBean() throws Exception
{
assertNotNull( "no XA manager bean", xaManager );
assertTrue( "no XA resources", xaManager.getXaResources().length > 0 );
}
@Test
public void hasAllXaManagerBeans()
{
for ( XaDataSource xaDataSource : graphDb.getDependencyResolver().resolveDependency( XaDataSourceManager.class )
.getAllRegisteredDataSources() )
{
XaResourceInfo info = getByName( xaDataSource.getName() );
assertEquals( "wrong branchid for XA data source " + xaDataSource.getName(),
XaManagerBean.toHexString( xaDataSource.getBranchId() ), info.getBranchId() );
assertEquals( "wrong log version for XA data source " + xaDataSource.getName(),
xaDataSource.getCurrentLogVersion(), info.getLogVersion() );
assertEquals( "wrong last tx ID for XA data source " + xaDataSource.getName(),
xaDataSource.getLastCommittedTxId(), info.getLastTxId() );
}
}
private XaResourceInfo getByName( String name )
{
for ( XaResourceInfo xaResourceInfo : xaManager.getXaResources() )
{
if ( name.equals( xaResourceInfo.getName() ) )
{
return xaResourceInfo;
}
}
fail( "no such XA resource: " + name );
return null;
}
}
| false
|
advanced_management_src_test_java_org_neo4j_management_TestXaManagerBeans.java
|
522
|
{
@Override
public void run()
{
try( Transaction tx = graphDb.beginTx() )
{
tx.acquireWriteLock( node );
}
}
};
| false
|
advanced_management_src_test_java_org_neo4j_management_TestLockManagerBean.java
|
523
|
@Service.Implementation( ManagementBeanProvider.class )
public final class MemoryMappingBean extends ManagementBeanProvider
{
public MemoryMappingBean()
{
super( MemoryMapping.class );
}
@Override
protected Neo4jMBean createMBean( ManagementData management ) throws NotCompliantMBeanException
{
return new MemoryMappingImpl( management );
}
@Override
protected Neo4jMBean createMXBean( ManagementData management ) throws NotCompliantMBeanException
{
return new MemoryMappingImpl( management, true );
}
private static class MemoryMappingImpl extends Neo4jMBean implements MemoryMapping
{
private final NeoStoreXaDataSource datasource;
MemoryMappingImpl( ManagementData management ) throws NotCompliantMBeanException
{
super( management );
this.datasource = neoDataSource( management );
}
private NeoStoreXaDataSource neoDataSource( ManagementData management )
{
return management.getKernelData().graphDatabase().getDependencyResolver().resolveDependency(
XaDataSourceManager.class ).getNeoStoreDataSource();
}
MemoryMappingImpl( ManagementData management, boolean isMxBean )
{
super( management, isMxBean );
this.datasource = neoDataSource( management );
}
public WindowPoolInfo[] getMemoryPools()
{
return getMemoryPoolsImpl( datasource );
}
public static WindowPoolInfo[] getMemoryPoolsImpl( NeoStoreXaDataSource datasource )
{
Collection<WindowPoolStats> stats = datasource.getWindowPoolStats();
WindowPoolInfo[] pools = new WindowPoolInfo[stats.size()];
Iterator<WindowPoolStats> iter = stats.iterator();
for ( int index = 0; iter.hasNext(); index++ )
{
pools[index] = createWindowPoolInfo( iter.next() );
}
return pools;
}
private static WindowPoolInfo createWindowPoolInfo( WindowPoolStats stats )
{
return new WindowPoolInfo( stats.getName(), stats.getMemAvail(), stats.getMemUsed(),
stats.getWindowCount(), stats.getWindowSize(), stats.getHitCount(),
stats.getMissCount(), stats.getOomCount() );
}
}
}
| false
|
advanced_management_src_main_java_org_neo4j_management_impl_MemoryMappingBean.java
|
524
|
private static class MemoryMappingImpl extends Neo4jMBean implements MemoryMapping
{
private final NeoStoreXaDataSource datasource;
MemoryMappingImpl( ManagementData management ) throws NotCompliantMBeanException
{
super( management );
this.datasource = neoDataSource( management );
}
private NeoStoreXaDataSource neoDataSource( ManagementData management )
{
return management.getKernelData().graphDatabase().getDependencyResolver().resolveDependency(
XaDataSourceManager.class ).getNeoStoreDataSource();
}
MemoryMappingImpl( ManagementData management, boolean isMxBean )
{
super( management, isMxBean );
this.datasource = neoDataSource( management );
}
public WindowPoolInfo[] getMemoryPools()
{
return getMemoryPoolsImpl( datasource );
}
public static WindowPoolInfo[] getMemoryPoolsImpl( NeoStoreXaDataSource datasource )
{
Collection<WindowPoolStats> stats = datasource.getWindowPoolStats();
WindowPoolInfo[] pools = new WindowPoolInfo[stats.size()];
Iterator<WindowPoolStats> iter = stats.iterator();
for ( int index = 0; iter.hasNext(); index++ )
{
pools[index] = createWindowPoolInfo( iter.next() );
}
return pools;
}
private static WindowPoolInfo createWindowPoolInfo( WindowPoolStats stats )
{
return new WindowPoolInfo( stats.getName(), stats.getMemAvail(), stats.getMemUsed(),
stats.getWindowCount(), stats.getWindowSize(), stats.getHitCount(),
stats.getMissCount(), stats.getOomCount() );
}
}
| false
|
advanced_management_src_main_java_org_neo4j_management_impl_MemoryMappingBean.java
|
525
|
@Service.Implementation(ManagementBeanProvider.class)
public final class TransactionManagerBean extends ManagementBeanProvider
{
public TransactionManagerBean()
{
super( TransactionManager.class );
}
@Override
protected Neo4jMBean createMBean( ManagementData management ) throws NotCompliantMBeanException
{
return new TransactionManagerImpl( management );
}
private static class TransactionManagerImpl extends Neo4jMBean implements TransactionManager
{
private final TxManager txManager;
private final XaDataSourceManager xadsm;
TransactionManagerImpl( ManagementData management ) throws NotCompliantMBeanException
{
super( management );
this.txManager = management.getKernelData().graphDatabase().getDependencyResolver()
.resolveDependency( TxManager.class );
this.xadsm = management.getKernelData().graphDatabase().getDependencyResolver().resolveDependency(
XaDataSourceManager.class );
}
public int getNumberOfOpenTransactions()
{
return txManager.getActiveTxCount();
}
public int getPeakNumberOfConcurrentTransactions()
{
return txManager.getPeakConcurrentTxCount();
}
public int getNumberOfOpenedTransactions()
{
return txManager.getStartedTxCount();
}
public long getNumberOfCommittedTransactions()
{
return txManager.getCommittedTxCount();
}
public long getNumberOfRolledBackTransactions()
{
return txManager.getRolledbackTxCount();
}
public long getLastCommittedTxId()
{
NeoStoreXaDataSource neoStoreDataSource = xadsm.getNeoStoreDataSource();
if ( neoStoreDataSource == null )
{
return -1;
}
else
{
return neoStoreDataSource.getNeoStore().getLastCommittedTx();
}
}
}
}
| false
|
advanced_management_src_main_java_org_neo4j_management_impl_TransactionManagerBean.java
|
526
|
abstract class Widget
{
final JPanel view()
{
JPanel panel = new JPanel();
populate( panel );
return panel;
}
abstract void populate( JPanel view );
void dispose()
{
}
final UpdateEvent[] update()
{
Collection<UpdateEvent> result = new ArrayList<UpdateEvent>();
update( result );
return result.isEmpty() ? null : result.toArray( new UpdateEvent[result.size()] );
}
abstract void update( Collection<UpdateEvent> result );
}
| false
|
advanced_management_src_main_java_org_neo4j_management_impl_jconsole_Widget.java
|
527
|
@SuppressWarnings( "serial" )
private static class ParentProcess extends SubProcess<Object, Callback>
{
@Override
protected void startup( Callback parameter ) throws Throwable
{
HandoverImpl handover = new HandoverImpl( parameter );
new ChildProcess().start( handover );
if ( !handover.isCalled( /*timeout:*/5, SECONDS ) ) System.out.println( "Child never started" );
shutdown();
}
}
| false
|
community_kernel_src_test_java_org_neo4j_metatest_SubProcessTest.java
|
528
|
private static class HandoverImpl extends UnicastRemoteObject implements Handover
{
private volatile boolean called = false;
private final Callback callback;
protected HandoverImpl( Callback callback ) throws RemoteException
{
super();
this.callback = callback;
}
@Override
public Callback handOver() throws RemoteException
{
called = true;
return callback;
}
boolean isCalled( int timeout, TimeUnit unit ) throws InterruptedException
{
long end = System.currentTimeMillis() + unit.toMillis( timeout );
while ( !called && System.currentTimeMillis() < end )
Thread.sleep( 1 );
return called;
}
}
| false
|
community_kernel_src_test_java_org_neo4j_metatest_SubProcessTest.java
|
529
|
@SuppressWarnings( "serial" )
private static class ChildProcess extends SubProcess<Object, Handover>
{
private Callback callback;
@Override
protected synchronized void startup( Handover parameter ) throws Throwable
{
System.out.println( "startup" );
this.callback = parameter.handOver();
}
@Override
protected synchronized void shutdown( boolean normal )
{
System.out.println( normal ? "normal shutdown" : "abnormal shutdown" );
try
{
callback.callBack();
}
catch ( RemoteException e )
{
e.printStackTrace();
}
}
}
| false
|
community_kernel_src_test_java_org_neo4j_metatest_SubProcessTest.java
|
530
|
@SuppressWarnings( "serial" )
private static class CallbackImpl extends UnicastRemoteObject implements Callback
{
private volatile boolean called = false;
protected CallbackImpl() throws RemoteException
{
super();
}
boolean isCalled( int timeout, TimeUnit unit ) throws InterruptedException
{
long end = System.currentTimeMillis() + unit.toMillis( timeout );
while ( !called && System.currentTimeMillis() < end )
Thread.sleep( 1 );
return called;
}
@Override
public void callBack()
{
called = true;
}
}
| false
|
community_kernel_src_test_java_org_neo4j_metatest_SubProcessTest.java
|
531
|
{
@Override
protected void callback( DebugInterface debug )
{
called.set( true );
}
}.enable() );
| false
|
community_kernel_src_test_java_org_neo4j_metatest_SubProcessTest.java
|
532
|
public class SubProcessTest
{
private static final String MESSAGE = "message";
@SuppressWarnings( "serial" )
private static class TestingProcess extends SubProcess<Callable<String>, String> implements Callable<String>
{
private String message;
private transient volatile boolean started = false;
@Override
protected void startup( String parameter )
{
message = parameter;
started = true;
}
public String call() throws Exception
{
while ( !started )
// because all calls are asynchronous
Thread.sleep( 1 );
return message;
}
}
@Test
public void canInvokeSubprocessMethod() throws Exception
{
Callable<String> subprocess = new TestingProcess().start( MESSAGE );
try
{
assertEquals( MESSAGE, subprocess.call() );
}
finally
{
SubProcess.stop( subprocess );
}
}
@Test
public void canDebugSubprocess() throws Exception
{
final AtomicBoolean called = new AtomicBoolean( false );
Callable<String> proc = new TestingProcess().start( MESSAGE,//
new BreakPoint( TestingProcess.class, "call" )
{
@Override
protected void callback( DebugInterface debug )
{
called.set( true );
}
}.enable() );
try
{
assertEquals( MESSAGE, proc.call() );
assertTrue( "breakpoint callback never reached", called.get() );
}
finally
{
SubProcess.stop( proc );
}
}
@Ignore( "not reliable - the processes do exit though" )
@Test
public void subprocessShouldExitWhenParentProcessExits() throws Exception
{
CallbackImpl callback = new CallbackImpl();
Object proc = new ParentProcess().start( callback );
assertTrue( "Subprocess didn't exit properly", callback.isCalled( /*timeout:*/10, SECONDS ) );
SubProcess.kill( proc );
}
private interface Callback extends Remote
{
void callBack() throws RemoteException;
}
private interface Handover extends Remote
{
Callback handOver() throws RemoteException;
}
@SuppressWarnings( "serial" )
private static class CallbackImpl extends UnicastRemoteObject implements Callback
{
private volatile boolean called = false;
protected CallbackImpl() throws RemoteException
{
super();
}
boolean isCalled( int timeout, TimeUnit unit ) throws InterruptedException
{
long end = System.currentTimeMillis() + unit.toMillis( timeout );
while ( !called && System.currentTimeMillis() < end )
Thread.sleep( 1 );
return called;
}
@Override
public void callBack()
{
called = true;
}
}
private static class HandoverImpl extends UnicastRemoteObject implements Handover
{
private volatile boolean called = false;
private final Callback callback;
protected HandoverImpl( Callback callback ) throws RemoteException
{
super();
this.callback = callback;
}
@Override
public Callback handOver() throws RemoteException
{
called = true;
return callback;
}
boolean isCalled( int timeout, TimeUnit unit ) throws InterruptedException
{
long end = System.currentTimeMillis() + unit.toMillis( timeout );
while ( !called && System.currentTimeMillis() < end )
Thread.sleep( 1 );
return called;
}
}
@SuppressWarnings( "serial" )
private static class ParentProcess extends SubProcess<Object, Callback>
{
@Override
protected void startup( Callback parameter ) throws Throwable
{
HandoverImpl handover = new HandoverImpl( parameter );
new ChildProcess().start( handover );
if ( !handover.isCalled( /*timeout:*/5, SECONDS ) ) System.out.println( "Child never started" );
shutdown();
}
}
@SuppressWarnings( "serial" )
private static class ChildProcess extends SubProcess<Object, Handover>
{
private Callback callback;
@Override
protected synchronized void startup( Handover parameter ) throws Throwable
{
System.out.println( "startup" );
this.callback = parameter.handOver();
}
@Override
protected synchronized void shutdown( boolean normal )
{
System.out.println( normal ? "normal shutdown" : "abnormal shutdown" );
try
{
callback.callBack();
}
catch ( RemoteException e )
{
e.printStackTrace();
}
}
}
}
| false
|
community_kernel_src_test_java_org_neo4j_metatest_SubProcessTest.java
|
533
|
public class BatchTransactionTest
{
@Test
public void shouldUseProgressListener() throws Exception
{
// GIVEN
Transaction transaction = mock( Transaction.class );
GraphDatabaseService db = mock( GraphDatabaseService.class );
when( db.beginTx() ).thenReturn( transaction );
ProgressListener progress = mock( ProgressListener.class );
BatchTransaction tx = beginBatchTx( db ).withIntermediarySize( 10 ).withProgress( progress );
// WHEN
tx.increment();
tx.increment( 9 );
// THEN
verify( db, times( 2 ) ).beginTx();
verify( transaction, times( 1 ) ).close();
verify( progress, times( 1 ) ).add( 1 );
verify( progress, times( 1 ) ).add( 9 );
}
}
| false
|
community_kernel_src_test_java_org_neo4j_metatest_BatchTransactionTest.java
|
534
|
public class AsciiDocGeneratorTest
{
File directory = TargetDirectory.forTest( getClass() )
.cleanDirectory( "testasciidocs" );
String sectionName = "testsection";
File sectionDirectory = new File( directory, sectionName );
@Test
public void dumpToSeparateFile() throws IOException
{
String reference = AsciiDocGenerator.dumpToSeparateFile(
sectionDirectory, "test1", ".title1\ntest1-content" );
assertEquals( ".title1\ninclude::includes/test1.asciidoc[]\n",
reference );
File includeDir = new File( sectionDirectory, "includes" );
File includeFile = new File( includeDir, "test1.asciidoc" );
assertTrue( includeFile.canRead() );
String fileContent = TestJavaTestDocsGenerator.readFileAsString( includeFile );
assertEquals( "test1-content", fileContent );
}
@Test
public void dumpToSeparateFileWithType() throws IOException
{
String reference = AsciiDocGenerator.dumpToSeparateFileWithType(
sectionDirectory,
"console", "test2-content" );
assertEquals( "include::includes/console-1.asciidoc[]\n", reference );
File includeDir = new File( sectionDirectory, "includes" );
File includeFile = new File( includeDir, "console-1.asciidoc" );
String fileContent = TestJavaTestDocsGenerator.readFileAsString( includeFile );
assertEquals( "test2-content", fileContent );
// make sure the next console doesn't overwrite the first one
reference = AsciiDocGenerator.dumpToSeparateFileWithType(
sectionDirectory, "console", "test3-content" );
includeFile = new File( includeDir, "console-2.asciidoc" );
fileContent = TestJavaTestDocsGenerator.readFileAsString( includeFile );
assertEquals( "test3-content", fileContent );
}
}
| false
|
community_kernel_src_test_java_org_neo4j_metatest_AsciiDocGeneratorTest.java
|
535
|
abstract class UpdateEvent
{
abstract void apply();
}
| false
|
advanced_management_src_main_java_org_neo4j_management_impl_jconsole_UpdateEvent.java
|
536
|
private static class TransactionManagerImpl extends Neo4jMBean implements TransactionManager
{
private final TxManager txManager;
private final XaDataSourceManager xadsm;
TransactionManagerImpl( ManagementData management ) throws NotCompliantMBeanException
{
super( management );
this.txManager = management.getKernelData().graphDatabase().getDependencyResolver()
.resolveDependency( TxManager.class );
this.xadsm = management.getKernelData().graphDatabase().getDependencyResolver().resolveDependency(
XaDataSourceManager.class );
}
public int getNumberOfOpenTransactions()
{
return txManager.getActiveTxCount();
}
public int getPeakNumberOfConcurrentTransactions()
{
return txManager.getPeakConcurrentTxCount();
}
public int getNumberOfOpenedTransactions()
{
return txManager.getStartedTxCount();
}
public long getNumberOfCommittedTransactions()
{
return txManager.getCommittedTxCount();
}
public long getNumberOfRolledBackTransactions()
{
return txManager.getRolledbackTxCount();
}
public long getLastCommittedTxId()
{
NeoStoreXaDataSource neoStoreDataSource = xadsm.getNeoStoreDataSource();
if ( neoStoreDataSource == null )
{
return -1;
}
else
{
return neoStoreDataSource.getNeoStore().getLastCommittedTx();
}
}
}
| false
|
advanced_management_src_main_java_org_neo4j_management_impl_TransactionManagerBean.java
|
537
|
{
@Override
protected Void doInBackground() throws Exception
{
Iterator<Widget> widget = widgets.iterator();
for ( int i = 0; widget.hasNext(); i++ )
{
setProgress( ( 100 * i ) / widgets.size() );
UpdateEvent[] updates = widget.next().update();
if ( updates != null ) publish( updates );
}
setProgress( 100 );
return null;
}
@Override
protected void process( List<UpdateEvent> events )
{
for ( UpdateEvent event : events )
{
event.apply();
}
}
};
| false
|
advanced_management_src_main_java_org_neo4j_management_impl_jconsole_Neo4jPlugin.java
|
538
|
public class Neo4jPlugin extends JConsolePlugin
{
private final Collection<Widget> widgets = new LinkedList<Widget>();
@Override
public Map<String, JPanel> getTabs()
{
ManagementAccess[] managers = ManagementAccess.getAll( getContext().getMBeanServerConnection() );
Map<String, JPanel> result = new LinkedHashMap<String, JPanel>();
if ( managers.length == 1 )
{
addTabs( managers[0], "", result );
}
else
{
for ( ManagementAccess manager : managers )
{
addTabs( manager,
" (" + manager.getMBeanQuery().getKeyProperty( "instance" ) + ")", result );
}
}
return result;
}
private void addTabs( ManagementAccess manager, String suffix, Map<String, JPanel> result )
{
result.put( "Neo4j" + suffix, add( new KernelWidget( manager ) ) );
try
{
HighAvailability ha = manager.getBean( HighAvailability.class );
if ( ha != null )
{
result.put( "Neo4j HA" + suffix, add( new HaWidget( manager, ha ) ) );
}
}
catch ( Exception haNotAvailable )
{
// ok, just don't include HA info
}
try
{
RemoteConnection remote = manager.getBean( RemoteConnection.class );
if ( remote != null )
{
DataBrowser browser = new DataBrowser( remote );
result.put( "Neo4j Graph" + suffix, browser.view() );
}
}
catch ( LinkageError dataBrowserNotAvailable )
{
// ok, just don't data browser
}
catch ( Exception dataBrowserNotAvailable )
{
// ok, just don't data browser
}
}
private JPanel add( Widget tab )
{
widgets.add( tab );
return tab.view();
}
@Override
public void dispose()
{
for ( Widget widget : widgets )
{
widget.dispose();
}
super.dispose();
}
@Override
public SwingWorker<?, ?> newSwingWorker()
{
return new SwingWorker<Void, UpdateEvent>()
{
@Override
protected Void doInBackground() throws Exception
{
Iterator<Widget> widget = widgets.iterator();
for ( int i = 0; widget.hasNext(); i++ )
{
setProgress( ( 100 * i ) / widgets.size() );
UpdateEvent[] updates = widget.next().update();
if ( updates != null ) publish( updates );
}
setProgress( 100 );
return null;
}
@Override
protected void process( List<UpdateEvent> events )
{
for ( UpdateEvent event : events )
{
event.apply();
}
}
};
}
}
| false
|
advanced_management_src_main_java_org_neo4j_management_impl_jconsole_Neo4jPlugin.java
|
539
|
class ManagementAccess extends KernelProxy
{
private ManagementAccess( MBeanServerConnection server, ObjectName kernel )
{
super( server, kernel );
}
@Override
protected <T> T getBean( Class<T> beanInterface )
{
return super.getBean( beanInterface );
}
static ManagementAccess[] getAll( MBeanServerConnection server )
{
final Set<ObjectName> names;
try
{
names = server.queryNames( createObjectName( "*", KERNEL_BEAN_NAME ), null );
}
catch ( IOException e )
{
return new ManagementAccess[0];
}
ManagementAccess[] proxies = new ManagementAccess[names.size()];
Iterator<ObjectName> iter = names.iterator();
for ( int i = 0; i < proxies.length || iter.hasNext(); i++ )
{
proxies[i] = new ManagementAccess( server, iter.next() );
}
return proxies;
}
public ObjectName getMBeanQuery()
{
return super.mbeanQuery();
}
}
| false
|
advanced_management_src_main_java_org_neo4j_management_impl_jconsole_ManagementAccess.java
|
540
|
class KernelWidget extends Widget
{
KernelWidget( ManagementAccess manager )
{
}
@Override
void populate( JPanel view )
{
view.add( new JLabel( "Neo4j Rocks!" ) );
}
@Override
void update( Collection<UpdateEvent> result )
{
// TODO tobias: Implement update() [Nov 30, 2010]
}
}
| false
|
advanced_management_src_main_java_org_neo4j_management_impl_jconsole_KernelWidget.java
|
541
|
class HaWidget extends Widget
{
HaWidget( ManagementAccess manager, HighAvailability ha )
{
// TODO Auto-generated constructor stub
}
@Override
void populate( JPanel view )
{
view.add( new JLabel( "Neo4j is Highly Available!" ) );
}
@Override
void update( Collection<UpdateEvent> result )
{
// TODO tobias: Implement update() [Nov 30, 2010]
}
}
| false
|
advanced_management_src_main_java_org_neo4j_management_impl_jconsole_HaWidget.java
|
542
|
class DataBrowser extends Widget
{
private final GraphDatabaseService graphDb;
DataBrowser( RemoteConnection remote ) throws ClassNotFoundException, SecurityException,
NoSuchMethodException, IllegalAccessException, IllegalArgumentException
{
Class<?> jmxTarget = Class.forName( "org.neo4j.remote.transports.JmxTarget" );
Method connect = jmxTarget.getMethod( "connectGraphDatabase", RemoteConnection.class );
try
{
this.graphDb = (GraphDatabaseService) connect.invoke( null, remote );
}
catch ( InvocationTargetException e )
{
throw launderRuntimeException( e.getTargetException() );
}
}
static RuntimeException launderRuntimeException( Throwable exception )
{
if ( exception instanceof RuntimeException )
{
return (RuntimeException) exception;
}
else if ( exception instanceof Error )
{
throw (Error) exception;
}
else
{
throw new RuntimeException( "Unexpected Exception!", exception );
}
}
@Override
void populate( JPanel view )
{
view.add( new JLabel( "Place holder for the Neo4j data viewer" ) );
}
@Override
void dispose()
{
graphDb.shutdown();
}
@Override
void update( Collection<UpdateEvent> result )
{
// TODO tobias: Implement update() [Nov 30, 2010]
}
}
| false
|
advanced_management_src_main_java_org_neo4j_management_impl_jconsole_DataBrowser.java
|
543
|
private static class XaManagerImpl extends Neo4jMBean implements XaManager
{
private final XaDataSourceManager datasourceMananger;
XaManagerImpl( ManagementData management ) throws NotCompliantMBeanException
{
super( management );
this.datasourceMananger = xaManager( management );
}
XaManagerImpl( ManagementData management, boolean isMxBean )
{
super( management, isMxBean );
this.datasourceMananger = xaManager( management );
}
public XaResourceInfo[] getXaResources()
{
return getXaResourcesImpl( datasourceMananger );
}
private static XaResourceInfo[] getXaResourcesImpl( XaDataSourceManager datasourceMananger )
{
List<XaResourceInfo> result = new ArrayList<XaResourceInfo>();
for ( XaDataSource datasource : datasourceMananger.getAllRegisteredDataSources() )
{
result.add( createXaResourceInfo( datasource ) );
}
return result.toArray( new XaResourceInfo[result.size()] );
}
private static XaResourceInfo createXaResourceInfo( XaDataSource datasource )
{
return new XaResourceInfo( datasource.getName(), toHexString( datasource.getBranchId() ),
datasource.getLastCommittedTxId(), datasource.getCurrentLogVersion() );
}
private XaDataSourceManager xaManager( ManagementData management )
{
return management.getKernelData().graphDatabase().getDependencyResolver().resolveDependency( XaDataSourceManager.class );
}
}
| false
|
advanced_management_src_main_java_org_neo4j_management_impl_XaManagerBean.java
|
544
|
@Service.Implementation( ManagementBeanProvider.class )
public final class XaManagerBean extends ManagementBeanProvider
{
public XaManagerBean()
{
super( XaManager.class );
}
@Override
protected Neo4jMBean createMBean( ManagementData management ) throws NotCompliantMBeanException
{
return new XaManagerImpl( management );
}
@Override
protected Neo4jMBean createMXBean( ManagementData management ) throws NotCompliantMBeanException
{
return new XaManagerImpl( management, true );
}
private static class XaManagerImpl extends Neo4jMBean implements XaManager
{
private final XaDataSourceManager datasourceMananger;
XaManagerImpl( ManagementData management ) throws NotCompliantMBeanException
{
super( management );
this.datasourceMananger = xaManager( management );
}
XaManagerImpl( ManagementData management, boolean isMxBean )
{
super( management, isMxBean );
this.datasourceMananger = xaManager( management );
}
public XaResourceInfo[] getXaResources()
{
return getXaResourcesImpl( datasourceMananger );
}
private static XaResourceInfo[] getXaResourcesImpl( XaDataSourceManager datasourceMananger )
{
List<XaResourceInfo> result = new ArrayList<XaResourceInfo>();
for ( XaDataSource datasource : datasourceMananger.getAllRegisteredDataSources() )
{
result.add( createXaResourceInfo( datasource ) );
}
return result.toArray( new XaResourceInfo[result.size()] );
}
private static XaResourceInfo createXaResourceInfo( XaDataSource datasource )
{
return new XaResourceInfo( datasource.getName(), toHexString( datasource.getBranchId() ),
datasource.getLastCommittedTxId(), datasource.getCurrentLogVersion() );
}
private XaDataSourceManager xaManager( ManagementData management )
{
return management.getKernelData().graphDatabase().getDependencyResolver().resolveDependency( XaDataSourceManager.class );
}
}
public static String toHexString( byte[] branchId )
{
StringBuilder result = new StringBuilder();
for ( byte part : branchId )
{
String chunk = Integer.toHexString( part );
if ( chunk.length() < 2 ) result.append( "0" );
if ( chunk.length() > 2 )
result.append( chunk.substring( chunk.length() - 2 ) );
else
result.append( chunk );
}
return result.toString();
}
}
| false
|
advanced_management_src_main_java_org_neo4j_management_impl_XaManagerBean.java
|
545
|
public class TestLockManagerBean
{
private LockManager lockManager;
@Rule
public ImpermanentDatabaseRule dbRule = new ImpermanentDatabaseRule();
@SuppressWarnings("deprecation")
private GraphDatabaseAPI graphDb;
@Before
public void setup()
{
graphDb = dbRule.getGraphDatabaseAPI();
lockManager = graphDb.getDependencyResolver().resolveDependency( JmxKernelExtension.class )
.getSingleManagementBean( LockManager.class );
}
@Test
public void restingGraphHoldsNoLocks()
{
assertEquals( "unexpected lock count", 0, lockManager.getLocks().size() );
}
@Test
public void modifiedNodeImpliesLock()
{
Node node = createNode();
try(Transaction ignore = graphDb.beginTx())
{
node.setProperty( "key", "value" );
List<LockInfo> locks = lockManager.getLocks();
assertEquals( "unexpected lock count", 2, locks.size() );
LockInfo lock = locks.get( 0 );
assertNotNull( "null lock", lock );
Collection<LockingTransaction> transactions = lock.getLockingTransactions();
assertEquals( "unexpected transaction count", 1, transactions.size() );
LockingTransaction txInfo = transactions.iterator().next();
assertNotNull( "null transaction", txInfo );
assertEquals( "read count", 0, txInfo.getReadCount() );
/* Before property handling moved from Primitive into the Kernel API there were two
* locks acquired for setting a property. One was about acquiring a write lock for that entity
* before even accessing the Primitive. The other one was the normal write lock for a change
* to an entity. The former guarded for a property data race, which is at the point of writing this
* unknown if it exists after the move or not (which also made the change to only acquire
* one lock again). */
assertEquals( "write count should be 1", 1, txInfo.getWriteCount() );
assertNotNull( "transaction", txInfo.getTransaction() );
assertEquals( "read count", 0, lock.getReadCount() );
assertEquals( "write count", 1, lock.getWriteCount() );
assertEquals( "waiting thread count", 0, lock.getWaitingThreadsCount() );
}
List<LockInfo> locks = lockManager.getLocks();
assertEquals( "unexpected lock count", 0, locks.size() );
}
@Test
public void explicitLocksAffectTheLockCount()
{
try ( Transaction tx = graphDb.beginTx() )
{
Node root = graphDb.createNode();
Lock first = tx.acquireReadLock( root );
LockInfo lock = getSingleLock();
assertEquals( "read count", 1, lock.getReadCount() );
assertEquals( "write count", 1, lock.getWriteCount() );
tx.acquireReadLock( root );
lock = getSingleLock();
assertEquals( "read count", 2, lock.getReadCount() );
assertEquals( "write count", 1, lock.getWriteCount() );
tx.acquireWriteLock( root );
lock = getSingleLock();
assertEquals( "read count", 2, lock.getReadCount() );
assertEquals( "write count", 2, lock.getWriteCount() );
first.release();
lock = getSingleLock();
assertEquals( "read count", 1, lock.getReadCount() );
assertEquals( "write count", 2, lock.getWriteCount() );
}
List<LockInfo> locks = lockManager.getLocks();
assertEquals( "unexpected lock count", 0, locks.size() );
}
@Test
public void shouldCountContendedLocks() throws Exception
{
final Node node = createNode();
Thread thread = null;
try ( Transaction tx = graphDb.beginTx() )
{
tx.acquireReadLock( node );
assertEquals( "all locks", 1, lockManager.getLocks().size() );
assertEquals( "contended locks", 0, lockManager.getContendedLocks( 0 ).size() );
thread = new Thread()
{
@Override
public void run()
{
try( Transaction tx = graphDb.beginTx() )
{
tx.acquireWriteLock( node );
}
}
};
thread.start();
awaitWaitingStateIn( thread );
assertEquals( "all locks", 1, lockManager.getLocks().size() );
assertEquals( "contended locks", 1, lockManager.getContendedLocks( 0 ).size() );
LockInfo contended = lockManager.getContendedLocks( 0 ).get( 0 );
assertEquals( "resource type", ResourceType.NODE, contended.getResourceType() );
assertEquals( "resource id", Long.toString( node.getId() ), contended.getResourceId() );
assertEquals( "read count", 1, contended.getReadCount() );
assertEquals( "write count", 0, contended.getWriteCount() );
assertEquals( "number of waiting thread", 1, contended.getWaitingThreads().size() );
assertEquals( "waiting thread name", thread.getName(), contended.getWaitingThreads().get( 0 ).getThreadName() );
}
finally
{
if ( thread != null ) thread.join();
}
}
private Node createNode()
{
try( Transaction tx = graphDb.beginTx() )
{
Node node = graphDb.createNode();
tx.success();
return node;
}
}
private void awaitWaitingStateIn( Thread t )
{
while ( t.getState() != State.WAITING )
{
try
{
Thread.sleep( 1 );
}
catch ( InterruptedException e )
{
Thread.interrupted();
}
}
}
private LockInfo getSingleLock()
{
List<LockInfo> locks = lockManager.getLocks();
assertEquals( "unexpected lock count", 1, locks.size() );
LockInfo lock = locks.get( 0 );
assertNotNull( "null lock", lock );
return lock;
}
}
| false
|
advanced_management_src_test_java_org_neo4j_management_TestLockManagerBean.java
|
546
|
HIT_COUNT
{
@Override
long get( Cache bean )
{
return bean.getHitCount();
}
},
| false
|
advanced_management_src_test_java_org_neo4j_management_TestCacheBeans.java
|
547
|
public class LifecycleException
extends RuntimeException
{
private static final String humanReadableMessage( Object instance, LifecycleStatus from, LifecycleStatus to )
{
switch(to)
{
case STOPPED:
if(from == LifecycleStatus.NONE)
{
return String.format( "Component '%s' failed to initialize. Please see attached cause exception" +
".", instance.toString() );
}
if(from == LifecycleStatus.STARTED)
{
return String.format( "Component '%s' failed to stop. Please see attached cause exception.",
instance.toString() );
}
break;
case STARTED:
if(from == LifecycleStatus.STOPPED)
{
return String.format( "Component '%s' was successfully initialized, but failed to start. Please " +
"see attached cause exception.", instance.toString() );
}
break;
case SHUTDOWN:
return String.format( "Component '%s' failed to shut down. Please " +
"see attached cause exception.", instance.toString() );
}
return String.format( "Failed to transition component '%s' from %s to %s. Please see attached cause exception",
instance.toString(), from.name(), to.name() );
}
public LifecycleException( Object instance, LifecycleStatus from, LifecycleStatus to, Throwable cause )
{
super( humanReadableMessage( instance, from, to ), cause);
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_lifecycle_LifecycleException.java
|
548
|
NUMBER_OF_CACHED_ELEMENTS
{
@Override
long get( Cache bean )
{
return bean.getCacheSize();
}
},
| false
|
advanced_management_src_test_java_org_neo4j_management_TestCacheBeans.java
|
549
|
{
@Override
public Object apply( Config from )
{
try
{
return Class.forName( LOGGER_CONTEXT_CLASS_NAME ).getConstructor().newInstance();
}
catch ( Exception e )
{
throw launderedException( e );
}
}
};
| false
|
community_kernel_src_main_java_org_neo4j_kernel_logging_LogbackWeakDependency.java
|
550
|
{
@Override
public Logging apply( Config config )
{
return new ClassicLoggingService( config );
}
};
| false
|
community_kernel_src_main_java_org_neo4j_kernel_logging_LogbackWeakDependency.java
|
551
|
public class LogbackWeakDependency
{
public static final Function<Config, Logging> DEFAULT_TO_CLASSIC = new Function<Config, Logging>()
{
@Override
public Logging apply( Config config )
{
return new ClassicLoggingService( config );
}
};
public static final Function<Config, Object> NEW_LOGGER_CONTEXT = new Function<Config, Object>()
{
@Override
public Object apply( Config from )
{
try
{
return Class.forName( LOGGER_CONTEXT_CLASS_NAME ).getConstructor().newInstance();
}
catch ( Exception e )
{
throw launderedException( e );
}
}
};
public static final Function<Config, Object> STATIC_LOGGER_CONTEXT = new Function<Config, Object>()
{
@Override
public Object apply( Config config )
{
try
{
Class<?> loggerBinderClass = Class.forName( LOGGER_BINDER_CLASS_NAME );
Object loggerBinder = loggerBinderClass.getDeclaredMethod( "getSingleton" ).invoke( null );
return loggerBinder.getClass().getDeclaredMethod( "getLoggerFactory" ).invoke( loggerBinder );
}
catch ( Exception e )
{
throw launderedException( e );
}
}
};
private static final String LOGGER_CONTEXT_CLASS_NAME = "ch.qos.logback.classic.LoggerContext";
private static final String LOGGER_BINDER_CLASS_NAME = "org.slf4j.impl.StaticLoggerBinder";
public Logging tryLoadLogbackService( Config config, Function<Config, Object> loggerContextGetter,
Function<Config, Logging> otherwiseDefaultTo )
{
try
{
if ( logbackIsOnClasspath() )
{
return newLogbackService( config, loggerContextGetter.apply( config ) );
}
}
catch ( Exception e )
{ // OK, we'll return fallback below
}
return otherwiseDefaultTo.apply( config );
}
public Logging tryLoadLogbackService( Config config, Function<Config, Logging> otherwiseDefaultTo )
{
return tryLoadLogbackService( config, STATIC_LOGGER_CONTEXT, otherwiseDefaultTo );
}
/**
* To work around the problem where we have an object that is actually a LoggerContext, but we
* cannot refer to it as such since that class may not exist at runtime.
*/
private Logging newLogbackService( Config config, Object loggerContext ) throws Exception
{
Class<?> loggerContextClass = Class.forName( LOGGER_CONTEXT_CLASS_NAME );
return LogbackService.class
.getConstructor( Config.class, loggerContextClass )
.newInstance( config, loggerContext );
}
private boolean logbackIsOnClasspath()
{
try
{
getClass().getClassLoader().loadClass( LOGGER_CONTEXT_CLASS_NAME );
return true;
}
catch ( ClassNotFoundException e )
{
return false;
}
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_logging_LogbackWeakDependency.java
|
552
|
{
@Override
public void logLine( String line )
{
logMessage( line, flush );
}
} );
| false
|
community_kernel_src_main_java_org_neo4j_kernel_logging_LogbackService.java
|
553
|
private static class Slf4jToStringLoggerAdapter
extends StringLogger
{
private final Logger logger;
public Slf4jToStringLoggerAdapter( Logger logger )
{
this.logger = logger;
}
@Override
protected void logLine( String line )
{
logger.info( line );
}
@Override
public void logLongMessage( final String msg, Visitor<LineLogger, RuntimeException> source, final boolean flush )
{
logMessage( msg, flush );
source.visit( new LineLogger()
{
@Override
public void logLine( String line )
{
logMessage( line, flush );
}
} );
}
@Override
public void logMessage( String msg, boolean flush )
{
if ( logger.isDebugEnabled() )
{
logger.debug( msg );
}
else
{
logger.info( msg );
}
}
@Override
public void logMessage( String msg, LogMarker marker )
{
logger.info( from( marker ), msg );
}
@Override
public void logMessage( String msg, Throwable cause, boolean flush )
{
logger.error( msg, cause );
}
@Override
public void debug( String msg )
{
logger.debug( msg );
}
@Override
public void debug( String msg, Throwable cause )
{
logger.debug( msg, cause );
}
@Override
public boolean isDebugEnabled()
{
return logger.isDebugEnabled();
}
@Override
public void info( String msg )
{
logger.info( msg );
}
@Override
public void info( String msg, Throwable cause )
{
logger.info( msg, cause );
}
@Override
public void warn( String msg )
{
logger.warn( msg );
}
@Override
public void warn( String msg, Throwable throwable )
{
logger.warn( msg, throwable );
}
@Override
public void error( String msg )
{
logger.error( msg );
}
@Override
public void error( String msg, Throwable throwable )
{
logger.error( msg, throwable );
}
@Override
public void addRotationListener( Runnable listener )
{
// Ignore
}
@Override
public void flush()
{
// Ignore
}
@Override
public void close()
{
// Ignore
}
private static Marker from( LogMarker marker )
{
return new Slf4jMarkerAdapter( marker.getName() );
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_logging_LogbackService.java
|
554
|
{
@Override
public void start()
throws Throwable
{
JoranConfigurator configurator = new JoranConfigurator();
configurator.setContext( loggerContext );
if (config.getParams().containsKey( "ha.server_id" ))
loggerContext.putProperty( "host", config.getParams().get( "ha.server_id" ) );
loggerContext.putProperty( "neo_store", storeDir.getPath() );
loggerContext.putProperty( "remote_logging_enabled", config.get( GraphDatabaseSettings
.remote_logging_enabled ).toString() );
loggerContext.putProperty( "remote_logging_host", config.get( GraphDatabaseSettings
.remote_logging_host ) );
loggerContext.putProperty( "remote_logging_port", config.get( GraphDatabaseSettings
.remote_logging_port ).toString() );
try
{
URL resource = getClass().getClassLoader().getResource( logbackConfigurationFilename );
if (resource == null)
throw new IllegalStateException( String.format("Could not find %s configuration", logbackConfigurationFilename ));
configurator.doConfigure( resource );
}
catch ( JoranException e )
{
throw new IllegalStateException( "Failed to configure logging", e );
}
}
@Override
public void stop()
throws Throwable
{
loggerContext.getLogger( "org.neo4j" ).detachAndStopAllAppenders();
}
} );
| false
|
community_kernel_src_main_java_org_neo4j_kernel_logging_LogbackService.java
|
555
|
public class LogbackService
extends LifecycleAdapter
implements Logging
{
private Config config;
private final LoggerContext loggerContext;
private final String logbackConfigurationFilename;
private LifeSupport loggingLife = new LifeSupport();
protected RestartOnChange restartOnChange;
public LogbackService( Config config, LoggerContext loggerContext )
{
this(config, loggerContext, "neo4j-logback.xml");
}
public LogbackService( Config config, LoggerContext loggerContext, String logbackConfigurationFilename )
{
this.config = config;
this.loggerContext = loggerContext;
this.logbackConfigurationFilename = logbackConfigurationFilename;
}
@Override
public void init()
throws Throwable
{
final File storeDir = config.get( InternalAbstractGraphDatabase.Configuration.store_dir );
if ( storeDir != null )
{
File file = storeDir.getAbsoluteFile();
if ( !file.exists() )
{
file.mkdirs();
}
// Neo4j specific log config
loggingLife.add( new LifecycleAdapter()
{
@Override
public void start()
throws Throwable
{
JoranConfigurator configurator = new JoranConfigurator();
configurator.setContext( loggerContext );
if (config.getParams().containsKey( "ha.server_id" ))
loggerContext.putProperty( "host", config.getParams().get( "ha.server_id" ) );
loggerContext.putProperty( "neo_store", storeDir.getPath() );
loggerContext.putProperty( "remote_logging_enabled", config.get( GraphDatabaseSettings
.remote_logging_enabled ).toString() );
loggerContext.putProperty( "remote_logging_host", config.get( GraphDatabaseSettings
.remote_logging_host ) );
loggerContext.putProperty( "remote_logging_port", config.get( GraphDatabaseSettings
.remote_logging_port ).toString() );
try
{
URL resource = getClass().getClassLoader().getResource( logbackConfigurationFilename );
if (resource == null)
throw new IllegalStateException( String.format("Could not find %s configuration", logbackConfigurationFilename ));
configurator.doConfigure( resource );
}
catch ( JoranException e )
{
throw new IllegalStateException( "Failed to configure logging", e );
}
}
@Override
public void stop()
throws Throwable
{
loggerContext.getLogger( "org.neo4j" ).detachAndStopAllAppenders();
}
} );
loggingLife.start();
restartOnChange = new RestartOnChange( "remote_logging_", loggingLife );
config.addConfigurationChangeListener( restartOnChange );
}
}
@Override
public void shutdown()
throws Throwable
{
loggingLife.shutdown();
if ( restartOnChange != null )
{
config.removeConfigurationChangeListener( restartOnChange );
}
}
@Override
public StringLogger getMessagesLog( Class loggingClass )
{
return new Slf4jToStringLoggerAdapter( loggerContext.getLogger( loggingClass ) );
}
@Override
public ConsoleLogger getConsoleLog( Class loggingClass )
{
return new ConsoleLogger( new Slf4jToStringLoggerAdapter( loggerContext.getLogger( loggingClass ) ) );
}
private static class Slf4jToStringLoggerAdapter
extends StringLogger
{
private final Logger logger;
public Slf4jToStringLoggerAdapter( Logger logger )
{
this.logger = logger;
}
@Override
protected void logLine( String line )
{
logger.info( line );
}
@Override
public void logLongMessage( final String msg, Visitor<LineLogger, RuntimeException> source, final boolean flush )
{
logMessage( msg, flush );
source.visit( new LineLogger()
{
@Override
public void logLine( String line )
{
logMessage( line, flush );
}
} );
}
@Override
public void logMessage( String msg, boolean flush )
{
if ( logger.isDebugEnabled() )
{
logger.debug( msg );
}
else
{
logger.info( msg );
}
}
@Override
public void logMessage( String msg, LogMarker marker )
{
logger.info( from( marker ), msg );
}
@Override
public void logMessage( String msg, Throwable cause, boolean flush )
{
logger.error( msg, cause );
}
@Override
public void debug( String msg )
{
logger.debug( msg );
}
@Override
public void debug( String msg, Throwable cause )
{
logger.debug( msg, cause );
}
@Override
public boolean isDebugEnabled()
{
return logger.isDebugEnabled();
}
@Override
public void info( String msg )
{
logger.info( msg );
}
@Override
public void info( String msg, Throwable cause )
{
logger.info( msg, cause );
}
@Override
public void warn( String msg )
{
logger.warn( msg );
}
@Override
public void warn( String msg, Throwable throwable )
{
logger.warn( msg, throwable );
}
@Override
public void error( String msg )
{
logger.error( msg );
}
@Override
public void error( String msg, Throwable throwable )
{
logger.error( msg, throwable );
}
@Override
public void addRotationListener( Runnable listener )
{
// Ignore
}
@Override
public void flush()
{
// Ignore
}
@Override
public void close()
{
// Ignore
}
private static Marker from( LogMarker marker )
{
return new Slf4jMarkerAdapter( marker.getName() );
}
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_logging_LogbackService.java
|
556
|
public class LogMarker
{
private final String name;
public LogMarker( String name )
{
this.name = name;
}
public String getName()
{
return name;
}
public static final String CONSOLE = "console";
public static final LogMarker CONSOLE_MARK = new LogMarker( CONSOLE );
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_logging_LogMarker.java
|
557
|
public class DevNullLoggingService
extends LifecycleAdapter
implements Logging
{
@Override
public StringLogger getMessagesLog( Class loggingClass )
{
return StringLogger.DEV_NULL;
}
@Override
public ConsoleLogger getConsoleLog( Class loggingClass )
{
return new ConsoleLogger( StringLogger.DEV_NULL );
}
public static final Logging DEV_NULL = new DevNullLoggingService();
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_logging_DevNullLoggingService.java
|
558
|
public class DefaultLogging
{
public static Logging createDefaultLogging( Map<String, String> config )
{
return createDefaultLogging( new Config( config ) );
}
public static Logging createDefaultLogging( Config config )
{
return new LogbackWeakDependency().tryLoadLogbackService( config, DEFAULT_TO_CLASSIC );
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_logging_DefaultLogging.java
|
559
|
public class ConsoleLoggingFilter extends Filter<ILoggingEvent>
{
@Override
public FilterReply decide( ILoggingEvent event )
{
if ( event.getMarker() != null && LogMarker.CONSOLE.equals( event.getMarker().getName() ) )
{
return FilterReply.ACCEPT;
}
return FilterReply.DENY;
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_logging_ConsoleLoggingFilter.java
|
560
|
public class ConsoleLogger
{
private final StringLogger realLogger;
public ConsoleLogger( StringLogger realLogger )
{
this.realLogger = realLogger;
}
/**
* Logs a message to the user.
* @param message the message to log.
*/
public void log( String message )
{
realLogger.logMessage( message, CONSOLE_MARK );
}
/**
* Logs a message to the user.
* @param format the format in {@link String#format(String, Object...)}.
* @param parameters the parameters that go into the format.
*/
public void log( String format, Object... parameters )
{
log( String.format( format, parameters ) );
}
/**
* Logs a warning to the user.
* @param message warning message
*/
public void warn( String message )
{
log( message );
}
/**
* Logs a warning to the user.
* @param format the format in {@link String#format(String, Object...)}.
* @param parameters the parameters that go into the format.
*/
public void warn( String format, Object... parameters )
{
log( format, parameters );
}
/**
* Logs a warning, including a cause to the user.
* @param message the warning message.
* @param warning the cause of the warning
* @deprecated since users shouldn't have to see stack traces. Stack traces are for
* developers, not for users. This method exists due to removing any of other logging frameworks
* that would log to the console.
*/
@Deprecated
public void warn( String message, Throwable warning )
{
realLogger.logMessage( message, warning, false, CONSOLE_MARK );
}
/**
* Logs an error to the user.
* @param message error message
*/
public void error( String message )
{
log( message );
}
/**
* Logs an error to the user.
* @param format the format in {@link String#format(String, Object...)}.
* @param parameters the parameters that go into the format.
*/
public void error( String format, Object... parameters )
{
log( format, parameters );
}
/**
* Logs an error, including a cause to the user.
* @param message the warning message.
* @param error the cause of the error
* @deprecated since users shouldn't have to see stack traces. Stack traces are for
* developers, not for users. This method exists due to removing any of other logging frameworks
* that would log to the console.
*/
@Deprecated
public void error( String message, Throwable error )
{
realLogger.logMessage( message, error, true, CONSOLE_MARK );
}
public static final ConsoleLogger DEV_NULL = new ConsoleLogger( StringLogger.DEV_NULL );
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_logging_ConsoleLogger.java
|
561
|
public class ClassicLoggingService extends SingleLoggingService
{
public ClassicLoggingService( Config config )
{
this( config, false );
}
public ClassicLoggingService( Config config, boolean debugEnabled )
{
super( StringLogger.loggerDirectory( new DefaultFileSystemAbstraction(),
config.get( InternalAbstractGraphDatabase.Configuration.store_dir ),
DEFAULT_THRESHOLD_FOR_ROTATION, debugEnabled ) );
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_logging_ClassicLoggingService.java
|
562
|
private static class LogMessage
{
private final String message;
private final Throwable throwable;
private final boolean flush;
public LogMessage( String message, Throwable throwable, boolean flush )
{
this.message = message;
this.throwable = throwable;
this.flush = flush;
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_logging_BufferingLogger.java
|
563
|
public class BufferingLogger extends StringLogger
{
private static class LogMessage
{
private final String message;
private final Throwable throwable;
private final boolean flush;
public LogMessage( String message, Throwable throwable, boolean flush )
{
this.message = message;
this.throwable = throwable;
this.flush = flush;
}
}
private final Queue<LogMessage> buffer = new ConcurrentLinkedQueue<>();
@Override
public void logMessage( String msg )
{
logMessage( msg, null, false );
}
@Override
public void logMessage( String msg, Throwable throwable )
{
logMessage( msg, throwable, false );
}
@Override
public void logMessage( String msg, boolean flush )
{
logMessage( msg, null, flush );
}
@Override
public void logMessage( String msg, LogMarker marker )
{
logMessage( msg );
}
@Override
public void logMessage( String msg, Throwable cause, boolean flush )
{
buffer.add( new LogMessage( msg, cause, flush ) );
}
@Override
public void logLongMessage( String msg, Visitor<LineLogger, RuntimeException> source, boolean flush )
{
source.visit( new LineLoggerImpl( this ) );
}
@Override
public void addRotationListener( Runnable listener )
{
}
@Override
protected void logLine( String line )
{
logMessage( line );
}
@Override
public void flush()
{
logMessage( "", true );
}
@Override
public void close()
{
// no-op
}
/**
* Replays buffered messages and clears the buffer.
*/
public void replayInto( StringLogger other )
{
LogMessage message = buffer.poll();
while ( message != null )
{
if ( message.throwable != null )
{
other.logMessage( message.message, message.throwable, message.flush );
}
else
{
other.logMessage( message.message, message.flush );
}
message = buffer.poll();
}
}
@Override
public String toString()
{
StringWriter stringWriter = new StringWriter();
PrintWriter sb = new PrintWriter( stringWriter );
for ( LogMessage message : buffer )
{
sb.println( message.message );
if ( message.throwable != null )
{
message.throwable.printStackTrace( sb );
}
}
return stringWriter.toString();
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_logging_BufferingLogger.java
|
564
|
private static class LogMessage
{
private final Level level;
private final String message;
private final Throwable throwable;
public LogMessage( Level level, String message, Throwable throwable )
{
this.level = level;
this.message = message;
this.throwable = throwable;
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_logging_BufferingConsoleLogger.java
|
565
|
public class BufferingConsoleLogger extends ConsoleLogger
{
private static enum Level
{
LOG,
WARN,
ERROR;
}
private static class LogMessage
{
private final Level level;
private final String message;
private final Throwable throwable;
public LogMessage( Level level, String message, Throwable throwable )
{
this.level = level;
this.message = message;
this.throwable = throwable;
}
}
private final List<LogMessage> buffer = new ArrayList<LogMessage>();
public BufferingConsoleLogger()
{
super( StringLogger.DEV_NULL );
}
@Override
public void log( String message )
{
buffer.add( new LogMessage( Level.LOG, message, null ) );
}
@Override
public void warn( String message, Throwable warning )
{
buffer.add( new LogMessage( Level.WARN, message, warning ) );
}
@Override
public void error( String message, Throwable error )
{
buffer.add( new LogMessage( Level.ERROR, message, error ) );
}
public void replayInto( ConsoleLogger target )
{
for ( LogMessage item : buffer )
{
switch ( item.level )
{
case LOG:
target.log( item.message );
break;
case WARN:
if ( item.throwable != null )
{
target.warn( item.message, item.throwable );
}
else
{
target.warn( item.message );
}
break;
case ERROR:
if ( item.throwable != null )
{
target.error( item.message, item.throwable );
}
else
{
target.error( item.message );
}
break;
default:
throw new IllegalArgumentException( "Unknown level " + item.level );
}
}
}
@Override
public String toString()
{
StringBuilder builder = new StringBuilder();
for ( LogMessage message : buffer )
{
builder
.append( message.message )
.append( message.throwable != null ? message.throwable.getMessage() : "" )
.append( format( "%n" ) );
}
return builder.toString();
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_logging_BufferingConsoleLogger.java
|
566
|
return new LifecycleException( new Object(){
@Override public String toString(){
return"SomeComponent";
}
}, from, to, null );
| false
|
community_kernel_src_test_java_org_neo4j_kernel_lifecycle_TestLifecycleException.java
|
567
|
public class TestLifecycleException
{
@Test
public void shouldMakeNoneToStoppedIntoHumanReadableInitMessage() throws Exception
{
assertThat(
exceptionFor( NONE, STOPPED ).getMessage(),
is("Component 'SomeComponent' failed to initialize. Please see attached cause exception."));
}
@Test
public void shouldMakeStoppedToStartedIntoHumanReadableStartingMessage() throws Exception
{
assertThat(
exceptionFor( STOPPED, STARTED ).getMessage(),
is("Component 'SomeComponent' was successfully initialized, but failed to start. Please see attached cause exception."));
}
@Test
public void shouldMakeStartedToStoppedIntoHumanReadableStoppingMessage() throws Exception
{
assertThat(
exceptionFor( STARTED, STOPPED ).getMessage(),
is("Component 'SomeComponent' failed to stop. Please see attached cause exception."));
}
@Test
public void shouldMakeShutdownIntoHumanReadableShutdownMessage() throws Exception
{
assertThat(
exceptionFor( STOPPED, SHUTDOWN ).getMessage(),
is("Component 'SomeComponent' failed to shut down. Please see attached cause exception."));
}
private LifecycleException exceptionFor( LifecycleStatus from, LifecycleStatus to )
{
return new LifecycleException( new Object(){
@Override public String toString(){
return"SomeComponent";
}
}, from, to, null );
}
}
| false
|
community_kernel_src_test_java_org_neo4j_kernel_lifecycle_TestLifecycleException.java
|
568
|
{
@Override
public Object apply( Config config )
{
try
{
Class<?> loggerBinderClass = Class.forName( LOGGER_BINDER_CLASS_NAME );
Object loggerBinder = loggerBinderClass.getDeclaredMethod( "getSingleton" ).invoke( null );
return loggerBinder.getClass().getDeclaredMethod( "getLoggerFactory" ).invoke( loggerBinder );
}
catch ( Exception e )
{
throw launderedException( e );
}
}
};
| false
|
community_kernel_src_main_java_org_neo4j_kernel_logging_LogbackWeakDependency.java
|
569
|
public class ModuleConverter
extends ClassicConverter
{
ModuleMapper mapper;
public ModuleConverter() throws IOException
{
mapper = new ModuleMapper();
}
@Override
public String convert(ILoggingEvent iLoggingEvent)
{
return mapper.map(iLoggingEvent.getLoggerName());
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_logging_ModuleConverter.java
|
570
|
public class ModuleMapper
{
Map<String, String> modules;
public ModuleMapper() throws IOException
{
Properties props = new Properties();
modules = new HashMap<String, String>();
// Load all module definitions
Enumeration<URL> moduleDefinitions = getClass().getClassLoader().getResources("META-INF/modules.properties");
while (moduleDefinitions.hasMoreElements())
{
URL url = moduleDefinitions.nextElement();
props.load(new InputStreamReader(url.openStream()));
for (Map.Entry<Object, Object> propEntry : props.entrySet())
{
String packages = modules.get(propEntry.getKey());
if (packages == null)
packages = propEntry.getValue().toString();
else
packages = packages+","+propEntry.getValue().toString();
modules.put(propEntry.getKey().toString(), packages);
}
props.clear();
}
}
public String map(String logger)
{
for (Map.Entry<String, String> moduleEntry : modules.entrySet())
{
String[] packages = moduleEntry.getValue().split(",");
for (String aPackage : packages)
{
if (logger.startsWith(aPackage))
return moduleEntry.getKey();
}
}
// No mapping found, return full logger name
return logger;
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_logging_ModuleMapper.java
|
571
|
private static class UntaggedMonitorListenerInvocationHandler implements MonitorListenerInvocationHandler
{
private final Object monitorListener;
public UntaggedMonitorListenerInvocationHandler( Object monitorListener )
{
this.monitorListener = monitorListener;
}
public Object getMonitorListener()
{
return monitorListener;
}
@Override
public void invoke( Object proxy, Method method, Object[] args, String... tags )
throws Throwable
{
method.invoke( monitorListener, args );
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_monitoring_Monitors.java
|
572
|
public class TestCacheBeans
{
private GraphDatabaseAPI graphDb;
private Collection<Cache> caches;
@Rule
public ImpermanentDatabaseRule dbRule = new ImpermanentDatabaseRule( );
@Before
public synchronized void startGraphDb()
{
graphDb = dbRule.getGraphDatabaseAPI();
caches = graphDb.getDependencyResolver().resolveDependency( JmxKernelExtension.class ).
getManagementBeans( Cache.class );
}
@After
public synchronized void stopGraphDb()
{
if ( graphDb != null )
{
graphDb.shutdown();
}
graphDb = null;
}
@Test
public void canAccessCacheBeans() throws Exception
{
assertNotNull( "no cache beans", caches );
assertFalse( "no cache beans", caches.isEmpty() );
}
@Test
public void canMeasureSizeOfCache() throws Exception
{
long [] before = get( CacheBean.NUMBER_OF_CACHED_ELEMENTS );
try(Transaction tx = graphDb.beginTx())
{
graphDb.createNode();
tx.success();
}
assertChanged( "cache size not updated", before, get( CacheBean.NUMBER_OF_CACHED_ELEMENTS ) );
}
@Test
public void canMeasureAmountsOfHitsAndMisses() throws Exception
{
try(Transaction tx = graphDb.beginTx())
{
graphDb.createNode();
tx.success();
}
graphDb.getDependencyResolver().resolveDependency( NodeManager.class ).clearCache();
long[] hits = get( CacheBean.HIT_COUNT ), miss = get( CacheBean.MISS_COUNT );
Transaction transaction = graphDb.beginTx();
try
{
graphDb.getNodeById(0);
graphDb.getNodeById(0);
}
finally
{
transaction.finish();
}
assertChanged( "hit count not updated", hits, get( CacheBean.HIT_COUNT ) );
assertChanged( "miss count not updated", miss, get( CacheBean.MISS_COUNT ) );
}
private void assertChanged( String message, long[] before, long[] after )
{
if ( Arrays.equals( before, after ) )
{
fail( message + ", before=" + Arrays.toString( before ) + ", after=" + Arrays.toString( after ) );
}
}
private enum CacheBean
{
NUMBER_OF_CACHED_ELEMENTS
{
@Override
long get( Cache bean )
{
return bean.getCacheSize();
}
},
HIT_COUNT
{
@Override
long get( Cache bean )
{
return bean.getHitCount();
}
},
MISS_COUNT
{
@Override
long get( Cache bean )
{
return bean.getMissCount();
}
};
abstract long get( Cache bean );
}
private long[] get( CacheBean accessor )
{
long[] result = new long[caches.size()];
Iterator<Cache> iter = caches.iterator();
for ( int i = 0; i < result.length; i++ )
{
result[i] = accessor.get( iter.next() );
}
return result;
}
}
| false
|
advanced_management_src_test_java_org_neo4j_management_TestCacheBeans.java
|
573
|
public final class Neo4jManager extends KernelProxy implements Kernel
{
public static Neo4jManager get()
{
return get( getPlatformMBeanServer() );
}
public static Neo4jManager get( String kernelIdentifier )
{
return get( getPlatformMBeanServer(), kernelIdentifier );
}
public static Neo4jManager get( JMXServiceURL url )
{
return get( connect( url, null, null ) );
}
public static Neo4jManager get( JMXServiceURL url, String kernelIdentifier )
{
return get( connect( url, null, null ), kernelIdentifier );
}
public static Neo4jManager get( JMXServiceURL url, String username, String password )
{
return get( connect( url, username, password ) );
}
public static Neo4jManager get( JMXServiceURL url, String username, String password,
String kernelIdentifier )
{
return get( connect( url, username, password ), kernelIdentifier );
}
private static MBeanServerConnection connect( JMXServiceURL url, String username,
String password )
{
Map<String, Object> environment = new HashMap<String, Object>();
if ( username != null && password != null )
{
environment.put( JMXConnector.CREDENTIALS, new String[]{username, password} );
}
else if ( username != password )
{
throw new IllegalArgumentException(
"User name and password must either both be specified, or both be null." );
}
try
{
try
{
return JMXConnectorFactory.connect( url, environment ).getMBeanServerConnection();
}
catch ( SecurityException e )
{
environment.put( RMIConnectorServer.RMI_CLIENT_SOCKET_FACTORY_ATTRIBUTE,
new SslRMIClientSocketFactory() );
return JMXConnectorFactory.connect( url, environment ).getMBeanServerConnection();
}
}
catch ( IOException e )
{
throw new IllegalStateException( "Connection failed.", e );
}
}
public static Neo4jManager get( MBeanServerConnection server )
{
server.getClass();
try
{
return get( server, server.queryNames( createObjectName( "*", Kernel.class ), null ) );
}
catch ( IOException e )
{
throw new IllegalStateException( "Connection failed.", e );
}
}
public static Neo4jManager get( MBeanServerConnection server, String kernelIdentifier )
{
server.getClass();
kernelIdentifier.getClass();
try
{
return get( server, server.queryNames( createObjectName( kernelIdentifier, Kernel.class ),
null ) );
}
catch ( IOException e )
{
throw new IllegalStateException( "Connection failed.", e );
}
}
public static Neo4jManager[] getAll( MBeanServerConnection server )
{
try
{
Set<ObjectName> kernels = server.queryNames( createObjectName( "*", Kernel.class ), null );
Neo4jManager[] managers = new Neo4jManager[kernels.size()];
Iterator<ObjectName> it = kernels.iterator();
for ( int i = 0; i < managers.length; i++ )
{
managers[i] = new Neo4jManager( server, it.next() );
}
return managers;
}
catch ( IOException e )
{
throw new IllegalStateException( "Connection failed.", e );
}
}
private static Neo4jManager get( MBeanServerConnection server, Collection<ObjectName> kernels )
{
if ( kernels.size() == 0 )
{
throw new NoSuchElementException( "No matching Neo4j Graph Database running on server" );
}
else if ( kernels.size() == 1 )
{
return new Neo4jManager( server, kernels.iterator().next() );
}
else
{
throw new NoSuchElementException(
"Too many matching Neo4j Graph Databases running on server" );
}
}
private final ObjectName config;
private final Kernel proxy;
public Neo4jManager( Kernel kernel )
{
this( getServer( kernel ), getName( kernel ) );
}
private static MBeanServerConnection getServer( Kernel kernel )
{
if ( kernel instanceof Proxy )
{
InvocationHandler handler = Proxy.getInvocationHandler( kernel );
if ( handler instanceof MBeanServerInvocationHandler )
{
return ((MBeanServerInvocationHandler) handler).getMBeanServerConnection();
}
}
else if ( kernel instanceof Neo4jManager )
{
return ((Neo4jManager) kernel).server;
}
throw new UnsupportedOperationException( "Cannot get server for kernel: " + kernel );
}
private static ObjectName getName( Kernel kernel )
{
if ( kernel instanceof Proxy )
{
InvocationHandler handler = Proxy.getInvocationHandler( kernel );
if ( handler instanceof MBeanServerInvocationHandler )
{
return ((MBeanServerInvocationHandler) handler).getObjectName();
}
}
else if ( kernel instanceof Neo4jManager )
{
return ((Neo4jManager) kernel).kernel;
}
throw new UnsupportedOperationException( "Cannot get name for kernel: " + kernel );
}
private Neo4jManager( MBeanServerConnection server, ObjectName kernel )
{
super( server, kernel );
this.config = createObjectName( ConfigurationBean.CONFIGURATION_MBEAN_NAME );
this.proxy = getBean( Kernel.class );
}
public Collection<Cache> getCacheBeans()
{
return getBeans( Cache.class );
}
public LockManager getLockManagerBean()
{
return getBean( LockManager.class );
}
public MemoryMapping getMemoryMappingBean()
{
return getBean( MemoryMapping.class );
}
public Primitives getPrimitivesBean()
{
return getBean( Primitives.class );
}
public StoreFile getStoreFileBean()
{
return getBean( StoreFile.class );
}
public TransactionManager getTransactionManagerBean()
{
return getBean( TransactionManager.class );
}
public XaManager getXaManagerBean()
{
return getBean( XaManager.class );
}
public HighAvailability getHighAvailabilityBean()
{
return getBean( HighAvailability.class );
}
public BranchedStore getBranchedStoreBean()
{
return getBean( BranchedStore.class );
}
public Object getConfigurationParameter( String key )
{
try
{
return server.getAttribute( config, key );
}
catch ( AttributeNotFoundException e )
{
return null;
}
catch ( Exception e )
{
throw new IllegalStateException( "Could not access the configuration bean", e );
}
}
public Map<String, Object> getConfiguration()
{
final String[] keys;
final AttributeList attributes;
try
{
MBeanAttributeInfo[] keyInfo = server.getMBeanInfo( config ).getAttributes();
keys = new String[keyInfo.length];
for ( int i = 0; i < keys.length; i++ )
{
keys[i] = keyInfo[i].getName();
}
attributes = server.getAttributes( config, keys );
}
catch ( Exception e )
{
throw new IllegalStateException( "Could not access the configuration bean", e );
}
Map<String, Object> configuration = new HashMap<String, Object>();
for ( int i = 0; i < keys.length; i++ )
{
configuration.put( keys[i], attributes.get( i ) );
}
return configuration;
}
@Override
public List<Object> allBeans()
{
List<Object> beans = super.allBeans();
@SuppressWarnings("hiding") Kernel kernel = null;
for ( Object bean : beans )
{
if ( bean instanceof Kernel )
{
kernel = (Kernel) bean;
}
}
if ( kernel != null )
{
beans.remove( kernel );
}
return beans;
}
public Date getKernelStartTime()
{
return proxy.getKernelStartTime();
}
public String getKernelVersion()
{
return proxy.getKernelVersion();
}
public ObjectName getMBeanQuery()
{
return proxy.getMBeanQuery();
}
public Date getStoreCreationDate()
{
return proxy.getStoreCreationDate();
}
public String getStoreDirectory()
{
return proxy.getStoreDirectory();
}
public String getStoreId()
{
return proxy.getStoreId();
}
public long getStoreLogVersion()
{
return proxy.getStoreLogVersion();
}
public boolean isReadOnly()
{
return proxy.isReadOnly();
}
}
| false
|
advanced_management_src_main_java_org_neo4j_management_Neo4jManager.java
|
574
|
public class ManagementBeansTest
{
private static GraphDatabaseAPI graphDb;
@BeforeClass
public static synchronized void startGraphDb()
{
graphDb = (GraphDatabaseAPI) new GraphDatabaseFactory().newEmbeddedDatabase( "target" + File.separator + "var"
+ File.separator + ManagementBeansTest.class.getSimpleName() );
}
@AfterClass
public static synchronized void stopGraphDb()
{
if ( graphDb != null )
{
graphDb.shutdown();
graphDb = null;
}
}
@Test
public void canAccessKernelBean() throws Exception
{
// START SNIPPET: getKernel
Kernel kernel = graphDb.getDependencyResolver().resolveDependency( JmxKernelExtension.class )
.getSingleManagementBean( Kernel.class );
// END SNIPPET: getKernel
assertNotNull( "kernel bean is null", kernel );
assertNotNull( "MBeanQuery of kernel bean is null", kernel.getMBeanQuery() );
}
@Test
public void canAccessPrimitivesBean() throws Exception
{
Primitives primitives = graphDb.getDependencyResolver().resolveDependency( JmxKernelExtension.class )
.getSingleManagementBean( Primitives.class );
assertNotNull( "primitives bean is null", primitives );
primitives.getNumberOfNodeIdsInUse();
}
@Test
public void canListAllBeans() throws Exception
{
Neo4jManager manager = getManager();
assertTrue( "No beans returned", manager.allBeans().size() > 0 );
}
@Test
public void canGetConfigurationParameters() throws Exception
{
Neo4jManager manager = getManager();
Map<String, Object> configuration = manager.getConfiguration();
assertTrue( "No configuration returned", configuration.size() > 0 );
}
private Neo4jManager getManager()
{
return new Neo4jManager( graphDb.getDependencyResolver().resolveDependency( JmxKernelExtension.class )
.getSingleManagementBean( Kernel.class ) );
}
@Test
public void canGetCacheBean() throws Exception
{
Collection<Cache> beans = getManager().getCacheBeans();
assertNotNull( beans );
assertFalse( "No Cache beans found", beans.isEmpty() );
for ( Cache bean : beans )
{
assertNotNull( bean );
}
}
@Test
public void canGetLockManagerBean() throws Exception
{
assertNotNull( getManager().getLockManagerBean() );
}
@Test
public void canGetMemoryMappingBean() throws Exception
{
assertNotNull( getManager().getMemoryMappingBean() );
}
@Test
public void canGetPrimitivesBean() throws Exception
{
assertNotNull( getManager().getPrimitivesBean() );
}
@Test
public void canGetStoreFileBean() throws Exception
{
assertNotNull( getManager().getStoreFileBean() );
}
@Test
public void canGetTransactionManagerBean() throws Exception
{
assertNotNull( getManager().getTransactionManagerBean() );
}
@Test
public void canGetXaManagerBean() throws Exception
{
assertNotNull( getManager().getXaManagerBean() );
}
@Test
public void canAccessMemoryMappingCompositData() throws Exception
{
assertNotNull( "MemoryPools is null", getManager().getMemoryMappingBean().getMemoryPools() );
}
@Test
public void canAccessXaManagerCompositData() throws Exception
{
assertNotNull( "MemoryPools is null", getManager().getXaManagerBean().getXaResources() );
}
}
| false
|
advanced_management_src_test_java_org_neo4j_management_ManagementBeansTest.java
|
575
|
class Main
{
private static final String JCONSOLE = "sun.tools.jconsole.JConsole";
private Main()
{
// no instances
}
public static void main( String[] args ) throws Throwable
{
Throwable failure = null;
Class<?> jconsole = null;
try
{
jconsole = Class.forName( JCONSOLE );
}
catch ( ClassNotFoundException ex )
{
File jar = new File( new File( System.getProperty( "java.home" ), "lib" ), "jconsole.jar" );
if ( !jar.exists() )
{
jar = new File( new File( new File( System.getProperty( "java.home" ) ).getParentFile(), "lib" ),
"jconsole.jar" );
}
ClassLoader loader = null;
if ( jar.exists() )
{
try
{
loader = new URLClassLoader( new URL[] { jar.toURI().toURL() }, Main.class.getClassLoader() );
}
catch ( MalformedURLException e )
{
// Handled by null check
}
}
if ( loader == null )
{
System.err.println( "Could not find jconsole.jar" );
return;
}
try
{
jconsole = loader.loadClass( JCONSOLE );
}
catch ( ClassNotFoundException e )
{
failure = ex;
}
}
Method main = null;
if ( jconsole != null )
{
try
{
main = jconsole.getDeclaredMethod( "main", String[].class );
}
catch ( Exception ex )
{
failure = ex;
}
}
if ( main != null )
{
try
{
main.invoke( null, new Object[] { args } );
return;
}
catch ( InvocationTargetException e )
{
throw e.getTargetException();
}
catch ( Exception ex )
{
failure = ex;
}
}
if ( failure != null )
{
System.err.println( "Failed to launch jconsole: " + failure );
if ( !( failure instanceof ClassNotFoundException ) )
{
failure.printStackTrace();
}
}
}
}
| false
|
advanced_management_src_main_java_org_neo4j_management_Main.java
|
576
|
public class ClusterMemberInfo implements Serializable
{
private static final long serialVersionUID = 1L;
private final String instanceId;
private final boolean available;
private final boolean alive;
private final String haRole;
private final String[] uris;
private final String[] roles;
@ConstructorProperties( { "instanceId", "available", "alive", "haRole", "uris", "roles" } )
public ClusterMemberInfo( String instanceId, boolean available, boolean alive, String haRole, String[] uris,
String[] roles )
{
this.instanceId = instanceId;
this.available = available;
this.alive = alive;
this.haRole = haRole;
this.uris = uris;
this.roles = roles;
}
public String getInstanceId()
{
return instanceId;
}
public boolean isAvailable()
{
return available;
}
public boolean isAlive()
{
return alive;
}
public String getHaRole()
{
return haRole;
}
public String[] getUris()
{
return uris;
}
public String[] getRoles()
{
return roles;
}
@Override
@SuppressWarnings( "boxing" )
public String toString()
{
return String.format( "Neo4jHaInstance[id=%s,available=%s,haRole=%s,HA URI=%s]", instanceId, available, haRole,
Arrays.toString(uris) );
}
public Pair<Neo4jManager, HighAvailability> connect()
{
return connect( null, null );
}
public Pair<Neo4jManager, HighAvailability> connect( String username, String password )
{
URI address = null;
for (String uri : uris)
{
if (uri.startsWith( "jmx" ))
{
// address = uri;
}
}
if ( address == null )
{
throw new IllegalStateException( "The instance does not have a public JMX server." );
}
Neo4jManager manager = Neo4jManager.get( url(address), username, password, instanceId );
return Pair.of( manager, manager.getHighAvailabilityBean() );
}
private JMXServiceURL url( URI address )
{
try
{
return new JMXServiceURL( address.toASCIIString() );
}
catch ( MalformedURLException e )
{
throw new IllegalStateException( "The instance does not have a valid JMX server URL." );
}
}
}
| false
|
advanced_management_src_main_java_org_neo4j_management_ClusterMemberInfo.java
|
577
|
public class ClusterDatabaseInfo extends ClusterMemberInfo
{
private final long lastCommittedTxId;
private final long lastUpdateTime;
public ClusterDatabaseInfo( ClusterMemberInfo memberInfo, long lastCommittedTxId, long lastUpdateTime )
{
super( memberInfo.getInstanceId(), memberInfo.isAvailable(), memberInfo.isAlive(), memberInfo.getHaRole(),
memberInfo.getUris(), memberInfo.getRoles() );
this.lastCommittedTxId = lastCommittedTxId;
this.lastUpdateTime = lastUpdateTime;
}
public long getLastCommittedTxId()
{
return lastCommittedTxId;
}
public long getLastUpdateTime()
{
return lastUpdateTime;
}
}
| false
|
advanced_management_src_main_java_org_neo4j_management_ClusterDatabaseInfo.java
|
578
|
@SuppressWarnings( "serial" )
public final class BranchedStoreInfo implements Serializable
{
private final String directory;
private final long largestTxId;
private final long creationTime;
@ConstructorProperties( { "directory", "largestTxId", "creationTime" } )
public BranchedStoreInfo( String directory, long largestTxId,
long creationTime )
{
this.directory = directory;
this.largestTxId = largestTxId;
this.creationTime = creationTime;
}
public String getDirectory()
{
return directory;
}
public long getLargestTxId()
{
return largestTxId;
}
public long getCreationTime()
{
return creationTime;
}
}
| false
|
advanced_management_src_main_java_org_neo4j_management_BranchedStoreInfo.java
|
579
|
public class MonitorsTest
{
interface MyMonitor
{
void aVoid();
void takesArgs( String arg1, long arg2, Object ... moreArgs );
}
@Test
public void shouldProvideNoOpDelegate() throws Exception
{
// Given
Monitors monitors = new Monitors();
// When
MyMonitor monitor = monitors.newMonitor( MyMonitor.class );
// Then those should be no-ops
monitor.aVoid();
monitor.takesArgs( "ha", 12, new Object() );
}
@Test
public void shouldRegister() throws Exception
{
// Given
Monitors monitors = new Monitors();
MyMonitor listener = mock( MyMonitor.class );
MyMonitor monitor = monitors.newMonitor( MyMonitor.class );
Object obj = new Object();
// When
monitors.addMonitorListener( listener );
monitor.aVoid();
monitor.takesArgs( "ha", 12, obj );
// Then
verify(listener).aVoid();
verify(listener).takesArgs( "ha", 12, obj );
}
@Test
public void shouldUnregister() throws Exception
{
// Given
Monitors monitors = new Monitors();
MyMonitor listener = mock( MyMonitor.class );
MyMonitor monitor = monitors.newMonitor( MyMonitor.class );
Object obj = new Object();
monitors.addMonitorListener( listener );
// When
monitors.removeMonitorListener( listener );
monitor.aVoid();
monitor.takesArgs( "ha", 12, obj );
// Then
verifyNoMoreInteractions( listener );
}
@Test
public void shouldRespectTags() throws Exception
{
// Given
Monitors monitors = new Monitors();
MyMonitor listener = mock( MyMonitor.class );
MyMonitor monitorTag1 = monitors.newMonitor( MyMonitor.class, "tag1" );
MyMonitor monitorTag2 = monitors.newMonitor( MyMonitor.class, "tag2" );
// When
monitors.addMonitorListener( listener, "tag2" );
// Then
monitorTag1.aVoid();
verifyZeroInteractions( listener );
monitorTag2.aVoid();
verify( listener, times(1) ).aVoid();
verifyNoMoreInteractions( listener );
}
}
| false
|
community_kernel_src_test_java_org_neo4j_kernel_monitoring_MonitorsTest.java
|
580
|
private static class TaggedMonitorListenerInvocationHandler
extends UntaggedMonitorListenerInvocationHandler
{
private String[] tags;
public TaggedMonitorListenerInvocationHandler( Object monitorListener, String... tags )
{
super( monitorListener );
this.tags = tags;
}
@Override
public void invoke( Object proxy, Method method, Object[] args, String... tags )
throws Throwable
{
required:
for ( int i = 0; i < this.tags.length; i++ )
{
String requiredTag = this.tags[i];
for ( int j = 0; j < tags.length; j++ )
{
String tag = tags[j];
if ( requiredTag.equals( tag ) )
{
continue required;
}
}
return; // Not all required tags present
}
super.invoke( proxy, method, args, tags );
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_monitoring_Monitors.java
|
581
|
public class SingleLoggingService extends LifecycleAdapter implements Logging
{
private final StringLogger logger;
private final ConsoleLogger consoleLogger;
public SingleLoggingService( StringLogger logger )
{
this.logger = logger;
this.consoleLogger = new ConsoleLogger( this.logger );
}
@Override
public StringLogger getMessagesLog( Class loggingClass )
{
return logger;
}
@Override
public ConsoleLogger getConsoleLog( Class loggingClass )
{
return consoleLogger;
}
@Override
public void shutdown() throws Throwable
{
logger.close();
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_logging_SingleLoggingService.java
|
582
|
private class MonitorInvocationHandler implements InvocationHandler
{
private String[] tags;
public MonitorInvocationHandler( String... tags )
{
this.tags = tags;
}
@Override
public Object invoke( Object proxy, Method method, Object[] args ) throws Throwable
{
invokeMonitorListeners( proxy, method, args );
return null;
}
private void invokeMonitorListeners( Object proxy, Method method, Object[] args )
{
List<MonitorListenerInvocationHandler> handlers = methodMonitorListeners.get().get( method );
if ( handlers != null )
{
for ( int i = 0; i < handlers.size(); i++ )
{
MonitorListenerInvocationHandler monitorListenerInvocationHandler = handlers.get( i );
try
{
monitorListenerInvocationHandler.invoke( proxy, method, args, tags );
}
catch ( Throwable e )
{
if ( !method.getDeclaringClass().equals( Monitor.class ) )
{
monitorsMonitor.monitorListenerException( e );
}
}
}
}
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_monitoring_Monitors.java
|
583
|
public class Adapter
implements Monitor
{
@Override
public void monitorCreated( Class<?> monitorClass, String... tags )
{
}
@Override
public void monitorListenerException( Throwable throwable )
{
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_monitoring_Monitors.java
|
584
|
{
@Override
public boolean accept( Method item )
{
return method.equals( item );
}
}, monitorListenerInvocationHandler );
| false
|
community_kernel_src_main_java_org_neo4j_kernel_monitoring_Monitors.java
|
585
|
public class Monitors
{
public interface Monitor
{
void monitorCreated( Class<?> monitorClass, String... tags );
void monitorListenerException( Throwable throwable );
public class Adapter
implements Monitor
{
@Override
public void monitorCreated( Class<?> monitorClass, String... tags )
{
}
@Override
public void monitorListenerException( Throwable throwable )
{
}
}
}
private AtomicReference<Map<Method, List<MonitorListenerInvocationHandler>>> methodMonitorListeners = new
AtomicReference<Map<Method, List<MonitorListenerInvocationHandler>>>( new HashMap<Method,
List<MonitorListenerInvocationHandler>>() );
private List<Class<?>> monitoredInterfaces = new ArrayList<Class<?>>();
private Map<Predicate<Method>, MonitorListenerInvocationHandler> monitorListeners =
new ConcurrentHashMap<Predicate<Method>, MonitorListenerInvocationHandler>();
private Monitor monitorsMonitor;
public Monitors()
{
monitorsMonitor = newMonitor( Monitor.class );
}
public <T> T newMonitor( Class<T> monitorClass, Class<?> owningClass, String... tags )
{
return newMonitor( monitorClass, toArray( String.class, append( owningClass.getName(), Iterables.<String, String>iterable(
tags ) ) ) );
}
public <T> T newMonitor( Class<T> monitorClass, String... tags )
{
if ( !monitoredInterfaces.contains( monitorClass ) )
{
monitoredInterfaces.add( monitorClass );
for ( Method method : monitorClass.getMethods() )
{
recalculateMethodListeners( method );
}
}
ClassLoader classLoader = monitorClass.getClassLoader();
MonitorInvocationHandler monitorInvocationHandler = new MonitorInvocationHandler( tags );
try
{
return monitorClass.cast( Proxy.newProxyInstance( classLoader, new Class<?>[]{monitorClass},
monitorInvocationHandler ) );
}
finally
{
if ( monitorsMonitor != null )
{
monitorsMonitor.monitorCreated( monitorClass, tags );
}
}
}
public void addMonitorListener( final Object monitorListener, String... tags )
{
MonitorListenerInvocationHandler monitorListenerInvocationHandler = tags.length == 0 ? new
UntaggedMonitorListenerInvocationHandler( monitorListener ) :
new TaggedMonitorListenerInvocationHandler( monitorListener, tags );
for ( Class<?> monitorInterface : getInterfacesOf( monitorListener.getClass() ) )
{
for ( final Method method : monitorInterface.getMethods() )
{
monitorListeners.put( new Predicate<Method>()
{
@Override
public boolean accept( Method item )
{
return method.equals( item );
}
}, monitorListenerInvocationHandler );
recalculateMethodListeners( method );
}
}
}
public void removeMonitorListener( Object monitorListener )
{
Iterator<Map.Entry<Predicate<Method>, MonitorListenerInvocationHandler>> iter = monitorListeners.entrySet
().iterator();
while ( iter.hasNext() )
{
Map.Entry<Predicate<Method>, MonitorListenerInvocationHandler> handlerEntry = iter.next();
if ( handlerEntry.getValue() instanceof UntaggedMonitorListenerInvocationHandler )
{
if ( ((UntaggedMonitorListenerInvocationHandler)
handlerEntry.getValue()).getMonitorListener() == monitorListener )
{
iter.remove();
}
}
}
recalculateAllMethodListeners();
}
public void addMonitorListener( MonitorListenerInvocationHandler invocationHandler,
Predicate<Method> methodSpecification )
{
monitorListeners.put( methodSpecification, invocationHandler );
recalculateAllMethodListeners();
}
public void removeMonitorListener( MonitorListenerInvocationHandler invocationHandler )
{
Iterator<Map.Entry<Predicate<Method>, MonitorListenerInvocationHandler>> iter = monitorListeners.entrySet
().iterator();
while ( iter.hasNext() )
{
Map.Entry<Predicate<Method>, MonitorListenerInvocationHandler> handlerEntry = iter.next();
if ( handlerEntry.getValue() == invocationHandler )
{
iter.remove();
recalculateAllMethodListeners();
return;
}
}
}
private void recalculateMethodListeners( Method method )
{
List<MonitorListenerInvocationHandler> listeners = new ArrayList<MonitorListenerInvocationHandler>();
for ( Map.Entry<Predicate<Method>, MonitorListenerInvocationHandler> handlerEntry : monitorListeners
.entrySet() )
{
if ( handlerEntry.getKey().accept( method ) )
{
listeners.add( handlerEntry.getValue() );
}
}
methodMonitorListeners.get().put( method, listeners );
}
private void recalculateAllMethodListeners()
{
for ( Method method : methodMonitorListeners.get().keySet() )
{
recalculateMethodListeners( method );
}
}
private Iterable<Class<?>> getInterfacesOf( Class<?> aClass )
{
List<Class<?>> interfaces = new ArrayList<Class<?>>();
while ( aClass != null )
{
for ( Class<?> classInterface : aClass.getInterfaces() )
{
interfaces.add( classInterface );
}
aClass = aClass.getSuperclass();
}
return interfaces;
}
private static class UntaggedMonitorListenerInvocationHandler implements MonitorListenerInvocationHandler
{
private final Object monitorListener;
public UntaggedMonitorListenerInvocationHandler( Object monitorListener )
{
this.monitorListener = monitorListener;
}
public Object getMonitorListener()
{
return monitorListener;
}
@Override
public void invoke( Object proxy, Method method, Object[] args, String... tags )
throws Throwable
{
method.invoke( monitorListener, args );
}
}
private static class TaggedMonitorListenerInvocationHandler
extends UntaggedMonitorListenerInvocationHandler
{
private String[] tags;
public TaggedMonitorListenerInvocationHandler( Object monitorListener, String... tags )
{
super( monitorListener );
this.tags = tags;
}
@Override
public void invoke( Object proxy, Method method, Object[] args, String... tags )
throws Throwable
{
required:
for ( int i = 0; i < this.tags.length; i++ )
{
String requiredTag = this.tags[i];
for ( int j = 0; j < tags.length; j++ )
{
String tag = tags[j];
if ( requiredTag.equals( tag ) )
{
continue required;
}
}
return; // Not all required tags present
}
super.invoke( proxy, method, args, tags );
}
}
private class MonitorInvocationHandler implements InvocationHandler
{
private String[] tags;
public MonitorInvocationHandler( String... tags )
{
this.tags = tags;
}
@Override
public Object invoke( Object proxy, Method method, Object[] args ) throws Throwable
{
invokeMonitorListeners( proxy, method, args );
return null;
}
private void invokeMonitorListeners( Object proxy, Method method, Object[] args )
{
List<MonitorListenerInvocationHandler> handlers = methodMonitorListeners.get().get( method );
if ( handlers != null )
{
for ( int i = 0; i < handlers.size(); i++ )
{
MonitorListenerInvocationHandler monitorListenerInvocationHandler = handlers.get( i );
try
{
monitorListenerInvocationHandler.invoke( proxy, method, args, tags );
}
catch ( Throwable e )
{
if ( !method.getDeclaringClass().equals( Monitor.class ) )
{
monitorsMonitor.monitorListenerException( e );
}
}
}
}
}
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_monitoring_Monitors.java
|
586
|
public class MonitoredReadableByteChannel implements ReadableByteChannel
{
private final ReadableByteChannel delegate;
private final ByteCounterMonitor monitor;
public MonitoredReadableByteChannel( ReadableByteChannel delegate, ByteCounterMonitor monitor )
{
this.delegate = delegate;
this.monitor = monitor;
}
@Override
public int read( ByteBuffer dst ) throws IOException
{
int result = delegate.read( dst );
if ( result >= 0 )
{
monitor.bytesRead( result );
}
return result;
}
@Override
public boolean isOpen()
{
return delegate.isOpen();
}
@Override
public void close() throws IOException
{
delegate.close();
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_monitoring_MonitoredReadableByteChannel.java
|
587
|
{
@Override
public void streamingFile( File storefile )
{ // Do nothing
}
@Override
public void streamedFile( File storefile )
{ // Do nothing
}
@Override
public void startCopyingFiles()
{ // Do nothing
}
@Override
public void finishedRotatingLogicalLogs()
{ // Do nothing
}
@Override
public void finishedCopyingStoreFiles()
{ // Do nothing
}
};
| false
|
community_kernel_src_main_java_org_neo4j_kernel_monitoring_BackupMonitor.java
|
588
|
public class SystemOutLogging extends SingleLoggingService
{
public SystemOutLogging()
{
super( StringLogger.SYSTEM );
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_logging_SystemOutLogging.java
|
589
|
public class Slf4jMarkerAdapter implements Marker
{
private final String name;
public Slf4jMarkerAdapter( String name )
{
this.name = name;
}
@Override
public String getName()
{
return name;
}
@Override
public void add( Marker reference )
{
}
@Override
public boolean remove( Marker reference )
{
return false;
}
@Override
public boolean hasChildren()
{
return false;
}
@Override
public boolean hasReferences()
{
return false;
}
@Override
public Iterator iterator()
{
return null;
}
@Override
public boolean contains( Marker other )
{
return false;
}
@Override
public boolean contains( String name )
{
return false;
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_logging_Slf4jMarkerAdapter.java
|
590
|
public class Neo4jJobSchedulerTest
{
private Neo4jJobScheduler scheduler;
@After
public void stopScheduler()
{
scheduler.stop();
}
@Test
public void shouldRunRecurringJob() throws Exception
{
// Given
scheduler = new Neo4jJobScheduler( StringLogger.DEV_NULL );
final AtomicInteger invocations = new AtomicInteger( 0 );
// When
scheduler.start();
scheduler.scheduleRecurring( indexPopulation, new Runnable()
{
public void run()
{
invocations.incrementAndGet();
}
}, 500, MILLISECONDS );
sleep( 1500 );
scheduler.stop();
// Then
int actualInvocations = invocations.get();
assertTrue( actualInvocations >= 2); // <-- Dunno how to better assert that this works correctly :/
assertTrue( actualInvocations < 6);
sleep( 1000 );
assertThat( invocations.get(), equalTo(actualInvocations) );
}
}
| false
|
community_kernel_src_test_java_org_neo4j_kernel_impl_util_Neo4jJobSchedulerTest.java
|
591
|
{
@Override
public void run()
{
try
{
runnable.run();
} catch(RuntimeException e)
{
log.error( "Failed running recurring job.", e );
}
}
}, 0, timeUnit.toMillis( period ) );
| false
|
community_kernel_src_main_java_org_neo4j_kernel_impl_util_Neo4jJobScheduler.java
|
592
|
public class Neo4jJobScheduler extends LifecycleAdapter implements JobScheduler
{
private final StringLogger log;
private final String id;
private ExecutorService executor;
private Timer timer; // Note, we may want a pool of these in the future, to minimize contention.
public Neo4jJobScheduler( StringLogger log )
{
this.log = log;
this.id = getClass().getSimpleName();
}
public Neo4jJobScheduler( String id, StringLogger log )
{
this.log = log;
this.id = id;
}
@Override
public void start()
{
this.executor = newCachedThreadPool(new DaemonThreadFactory("Neo4j " + id));
this.timer = new Timer( "Neo4j Recurring Job Runner", /* daemon= */true );
}
@Override
public void schedule( Group group, Runnable job )
{
this.executor.submit( job );
}
@Override
public void scheduleRecurring( Group group, final Runnable runnable, long period, TimeUnit timeUnit )
{
timer.schedule( new TimerTask()
{
@Override
public void run()
{
try
{
runnable.run();
} catch(RuntimeException e)
{
log.error( "Failed running recurring job.", e );
}
}
}, 0, timeUnit.toMillis( period ) );
}
@Override
public void stop()
{
RuntimeException exception = null;
try
{
if(executor != null)
{
executor.shutdown();
executor = null;
}
} catch(RuntimeException e)
{
exception = e;
}
try
{
if(timer != null)
{
timer.cancel();
timer = null;
}
} catch(RuntimeException e)
{
exception = e;
}
if(exception != null)
{
throw new RuntimeException( "Unable to shut down job scheduler properly.", exception);
}
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_impl_util_Neo4jJobScheduler.java
|
593
|
return new DefaultTraverser( new Factory<TraverserIterator>(){
@Override
public TraverserIterator newInstance()
{
Resource statement = statementFactory.instance();
MonoDirectionalTraverserIterator iterator = new MonoDirectionalTraverserIterator(
statement,
uniqueness.create( uniquenessParameter ),
expander, branchOrdering, evaluator,
iterableStartNodes, initialState );
return sorting != null ? new SortingTraverserIterator( statement, sorting, iterator ) : iterator;
}
});
| false
|
community_kernel_src_main_java_org_neo4j_kernel_impl_traversal_MonoDirectionalTraversalDescription.java
|
594
|
public class TestConstantDirectionExpander extends TraversalTestBase
{
private static enum Types implements RelationshipType
{
A, B
}
private Transaction tx;
@Before
public void createGraph()
{
/*
* (l)--[A]-->(m)--[A]-->(n)<--[A]--(o)<--[B]--(p)<--[B]--(q)
*/
createGraph( "l A m", "m A n", "o A n", "p B o", "q B p" );
tx = beginTx();
}
@After
public void tearDown()
{
tx.close();
}
@Test
public void pathWithConstantDirection()
{
Node l = getNodeWithName( "l" );
expectPaths( getGraphDb().traversalDescription()
.expand(
PathExpanders.forConstantDirectionWithTypes( Types.A ) )
.traverse( l ), "l", "l,m", "l,m,n" );
Node n = getNodeWithName( "n" );
expectPaths( getGraphDb().traversalDescription()
.expand(
PathExpanders.forConstantDirectionWithTypes( Types.A ) )
.traverse( n ), "n", "n,m", "n,m,l", "n,o" );
Node q = getNodeWithName( "q" );
expectPaths( getGraphDb().traversalDescription()
.expand(
PathExpanders.forConstantDirectionWithTypes( Types.B ) )
.traverse( q ), "q", "q,p", "q,p,o" );
}
}
| false
|
community_kernel_src_test_java_org_neo4j_kernel_impl_traversal_TestConstantDirectionExpander.java
|
595
|
private static class RelationshipWeightExpander implements PathExpander<Integer>
{
@Override
public Iterable<Relationship> expand( Path path, BranchState<Integer> state )
{
state.setState( state.getState() + 1 );
return path.endNode().getRelationships( OUTGOING );
}
@Override
public PathExpander<Integer> reverse()
{
return this;
}
}
| false
|
community_kernel_src_test_java_org_neo4j_kernel_impl_traversal_TestBranchState.java
|
596
|
private static class IncrementEveryOtherDepthCountingExpander implements PathExpander<Integer>
{
@Override
public Iterable<Relationship> expand( Path path, BranchState<Integer> state )
{
assertEquals( path.length()/2, state.getState().intValue() );
if ( path.length() % 2 == 1 )
state.setState( state.getState() + 1 );
return path.endNode().getRelationships( Direction.OUTGOING );
}
@Override
public PathExpander<Integer> reverse()
{
return this;
}
}
| false
|
community_kernel_src_test_java_org_neo4j_kernel_impl_traversal_TestBranchState.java
|
597
|
private static class DepthStateExpander implements PathExpander<Integer>
{
@Override
public Iterable<Relationship> expand( Path path, BranchState<Integer> state )
{
assertEquals( path.length(), state.getState().intValue() );
state.setState( state.getState()+1 );
return path.endNode().getRelationships( Direction.OUTGOING );
}
@Override
public PathExpander<Integer> reverse()
{
return this;
}
}
| false
|
community_kernel_src_test_java_org_neo4j_kernel_impl_traversal_TestBranchState.java
|
598
|
{
@Override
public Evaluation evaluate( Path path, BranchState<Integer> state )
{
return ofIncludes( path.endNode().getProperty( "name" ).equals( "c" ) && state.getState() == 3 );
}
};
| false
|
community_kernel_src_test_java_org_neo4j_kernel_impl_traversal_TestBranchState.java
|
599
|
public class TestBranchState extends TraversalTestBase
{
@Test
public void depthAsState() throws Exception
{
/*
* (a) -> (b) -> (c) -> (d)
* \ ^
* v /
* (e) -> (f) -> (g) -> (h)
*/
createGraph( "a to b", "b to c", "c to d", "b to e", "e to f", "f to d", "f to g", "g to h" );
Transaction tx = beginTx();
try
{
DepthStateExpander expander = new DepthStateExpander();
count( traversal().expand( expander, initialState( 0 ) ).traverse( getNodeWithName( "a" ) ) );
tx.success();
}
finally
{
tx.finish();
}
}
@Test
public void everyOtherDepthAsState() throws Exception
{
/*
* (a) -> (b) -> (c) -> (e)
*/
createGraph( "a to b", "b to c", "c to d", "d to e" );
Transaction tx = beginTx();
try
{
/*
* Asserts that state continues down branches even when expander doesn't
* set new state for every step.
*/
IncrementEveryOtherDepthCountingExpander expander = new IncrementEveryOtherDepthCountingExpander();
count( traversal().expand( expander, initialState( 0 ) ).traverse( getNodeWithName( "a" ) ) );
tx.success();
}
finally
{
tx.finish();
}
}
@Test
public void evaluateState() throws Exception
{
/*
* (a)-1->(b)-2->(c)-3->(d)
* \ ^
* 4 6
* (e)-5->(f)
*/
createGraph( "a TO b", "b TO c", "c TO d", "a TO e", "e TO f", "f TO c" );
Transaction tx = beginTx();
try
{
PathEvaluator<Integer> evaluator = new PathEvaluator.Adapter<Integer>()
{
@Override
public Evaluation evaluate( Path path, BranchState<Integer> state )
{
return ofIncludes( path.endNode().getProperty( "name" ).equals( "c" ) && state.getState() == 3 );
}
};
expectPaths( traversal( NODE_PATH ).expand( new RelationshipWeightExpander(), new InitialBranchState.State<Integer>( 1, 1 ) )
.evaluator( evaluator ).traverse( getNodeWithName( "a" ) ), "a,b,c" );
tx.success();
}
finally
{
tx.finish();
}
}
private static class DepthStateExpander implements PathExpander<Integer>
{
@Override
public Iterable<Relationship> expand( Path path, BranchState<Integer> state )
{
assertEquals( path.length(), state.getState().intValue() );
state.setState( state.getState()+1 );
return path.endNode().getRelationships( Direction.OUTGOING );
}
@Override
public PathExpander<Integer> reverse()
{
return this;
}
}
private static class IncrementEveryOtherDepthCountingExpander implements PathExpander<Integer>
{
@Override
public Iterable<Relationship> expand( Path path, BranchState<Integer> state )
{
assertEquals( path.length()/2, state.getState().intValue() );
if ( path.length() % 2 == 1 )
state.setState( state.getState() + 1 );
return path.endNode().getRelationships( Direction.OUTGOING );
}
@Override
public PathExpander<Integer> reverse()
{
return this;
}
}
private static class RelationshipWeightExpander implements PathExpander<Integer>
{
@Override
public Iterable<Relationship> expand( Path path, BranchState<Integer> state )
{
state.setState( state.getState() + 1 );
return path.endNode().getRelationships( OUTGOING );
}
@Override
public PathExpander<Integer> reverse()
{
return this;
}
}
}
| false
|
community_kernel_src_test_java_org_neo4j_kernel_impl_traversal_TestBranchState.java
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.